diff --git a/ml/add_error_checking.V3.sed b/ml/add_error_checking.V3.sed new file mode 100644 index 000000000..170ca2d6b --- /dev/null +++ b/ml/add_error_checking.V3.sed @@ -0,0 +1,2 @@ +# Customize error handling for contexts created in ML: +s/Z3_API Z3_mk_context\(_rc\|\)(\(.*\))/Z3_API Z3_mk_context\1(\2) quote(dealloc,\"Z3_set_error_handler(_res, caml_z3_error_handler);\")/g diff --git a/ml/add_error_checking.sed b/ml/add_error_checking.sed new file mode 100644 index 000000000..ede3275e1 --- /dev/null +++ b/ml/add_error_checking.sed @@ -0,0 +1,86 @@ +# Do not add epilogue to Z3_del_context +/Z3_API .*Z3_del_context.*/b endt + +# Add error checking epilogue for all Z3_API functions that accept two Z3_contexts +:begincc +# add epilogue for two Z3_context parameters +s/Z3_API \(.*\)(\(.*\)Z3_context \([a-zA-Z]*\)\(.*\)Z3_context \([a-zA-Z]*\)\([^a-zA-Z].*\|\))\(;\|\)[ ]*$/Z3_API \1(\2Z3_context \3\4Z3_context \5\6) quote(dealloc,\"check_error_code(\3);\")\7/g + +# if a match was found, done with all Z3_contexts and Z3_theorys +t endt + +# if complete prototype, done with two Z3_contexts +/Z3_API .*(.*)\(;\|\)[ ]*$/b endcc + +# if incomplete prototype +/Z3_API .*(.*/{ + + # read another line + N + + # add epilogue for two Z3_context parameters + s/Z3_API \(.*\)(\(.*\)Z3_context \([a-zA-Z]*\)\(.*\)Z3_context \([a-zA-Z]*\)\([^a-zA-Z].*\|\))\(;\|\)[ ]*$/Z3_API \1(\2Z3_context \3\4Z3_context \5\6) quote(dealloc,\"check_error_code(\3); check_error_code(\5);\")\7/g + + # if a match was found, done with all Z3_contexts and Z3_theorys + t endt + + # else keep looking for two Z3_contexts + b begincc +} +:endcc + +# Add error checking epilogue for all Z3_API functions that accept one Z3_context +:beginc +# add epilogue for one Z3_context parameter +s/Z3_API \(.*\)(\(.*\)Z3_context \([a-zA-Z]*\)\([^a-zA-Z].*\|\))\(;\|\)[ ]*$/Z3_API \1(\2Z3_context \3\4) quote(dealloc,\"check_error_code(\3);\")\5/g + +# if a match was found, done with all Z3_contexts and Z3_theorys +t endt + +# if complete prototype, done with all Z3_contexts +/Z3_API .*(.*)\(;\|\)[ ]*$/b endc + +# if incomplete prototype +/Z3_API .*(.*/{ + + # read another line + N + + # add epilogue for one Z3_context parameter + s/Z3_API \(.*\)(\(.*\)Z3_context \([a-zA-Z]*\)\([^a-zA-Z].*\|\))\(;\|\)[ ]*$/Z3_API \1(\2Z3_context \3\4) quote(dealloc,\"check_error_code(\3);\")\5/g + + # if a match was found, done with all Z3_contexts and Z3_theorys + t endt + + # else keep looking for one Z3_context + b beginc +} +:endc + + +# Add error checking epilogue for all Z3_API functions that accept a Z3_theory +:begint +# add epilogue for one Z3_theory parameter +s/Z3_API \(.*\)(\(.*\)Z3_theory \([a-zA-Z]*\)\([^a-zA-Z].*\|\))\(;\|\)[ ]*$/Z3_API \1(\2Z3_theory \3\4) quote(dealloc,\"check_error_code(Z3_theory_get_context(\3));\")\5/g + +# if a match was found, done with all Z3_contexts and Z3_theorys +t endt + +# if complete prototype, done with all Z3_theorys +/Z3_API .*(.*)\(;\|\)[ ]*$/b endt + +/Z3_API .*(.*/{ + + # read another line + N + + # add epilogue for one Z3_theory parameter + s/Z3_API \(.*\)(\(.*\)Z3_theory \([a-zA-Z]*\)\([^a-zA-Z].*\|\))\(;\|\)[ ]*$/Z3_API \1(\2Z3_theory \3\4) quote(dealloc,\"check_error_code(Z3_theory_get_context(\3));\")\5/g + + # if a match was found, done with all Z3_theorys + t endt + + # else keep looking for one Z3_theory + b begint +} +:endt diff --git a/ml/build.cmd b/ml/build.cmd new file mode 100644 index 000000000..1624f460f --- /dev/null +++ b/ml/build.cmd @@ -0,0 +1,55 @@ +@echo off +SETLOCAL + +REM Script to generate, compile, test, and document the Z3 OCaml API +REM usage: build.cmd [32|64] [-D UNSAFE_ERRORS] [-D LEAK_CONTEXTS] +REM Invoke with "-D UNSAFE_ERRORS" to build version that does not support recoverable errors, but avoids some error-checking overhead. +REM Invoke with "-D LEAK_CONTEXTS" to build version that leaks Z3_context objects, but avoids some garbage-collection overhead. + +if ""%1 == "" ( + set BITS=32 +) else ( + set BITS=%1 +) + +if %BITS% == 32 ( + set ARCH=x86 + set Z3BIN= ..\external + set Z3DBG= ..\debug +) else ( + set ARCH=x64 + set Z3BIN= ..\x64\external_64 + set Z3DBG= ..\x64\Debug +) + +echo { Setting up environment +call "C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat" %ARCH% +call ..\tools\ocaml\win%BITS%\setup.cmd +set PATH=..\tools;..\mlV3;%PATH% +echo } + +echo { Cleaning +call .\clean.cmd +echo } + +echo { Generating OCaml API %3 %5 +call .\generate_mlapi.cmd %2 %3 %4 %5 +if errorlevel 1 goto :EOF +echo } + +echo { Compiling OCaml API +call .\compile_mlapi.cmd ..\lib %Z3BIN% %Z3DBG% +if errorlevel 1 goto :EOF +echo } + +echo { Testing OCaml API +call .\test_mlapi.cmd ..\lib %Z3BIN% %Z3DBG% +if errorlevel 1 goto :EOF +echo } + +echo { Generating OCaml API documentation +call .\update-ml-doc.cmd ..\doc +if errorlevel 1 goto :EOF +echo } + +ENDLOCAL \ No newline at end of file diff --git a/ml/build.sed b/ml/build.sed new file mode 100644 index 000000000..e4434a5a1 --- /dev/null +++ b/ml/build.sed @@ -0,0 +1,82 @@ +# attempt to clean up the mess with 'unsigned' +s/__in unsigned __/__in __/g +s/__out unsigned __/__out __/g +s/__out_opt unsigned __/__out_opt __/g + + +# '@name ' -> 'Section: ' +# '\sa ' -> 'See also: ' +# '\brief ' -> 'Summary: ' +# '\remark ' -> 'Remark: ' +# '\pre ' -> 'Precondition: ' +# '\param ' -> '@param' +# '\warning ' -> 'Warning: ' +# '\code' -> 'C Example:' +# '\endcode' -> '' +/\\pre/s/(/ /g;/\\pre/s/,//g;/\\pre/s/)//g;s/\\pre /- {b Precondition}: /g +/\\ccode/s/(/ /g;/\\ccode/s/\\,//g;/\\ccode/s/)//g;s/\\ccode{\(.*\)}/\[\1\]/g +s/\\defgroup .*//g +s/@name \(.*\)/{2 {L \1}}/g +s/\\sa \(.*\)/- {b See also}: {!Z3.\1}/g +s/\\see \(.*\)/- {b See}: {!Z3.\1}/g +s//{e /g +s|| }|g +s/\\nicebox{/{e/g +s/\\brief /Summary: /g +s/\\remark /- {b Remarks}: /g +s/\\pre /- {b Precondition}: /g +s/\\param /@param /g +s/\\conly .*//g +s/\\warning /- {b Warning}: /g +s/\\code/{v /g +s/\\endcode/ v}/g +s/\\verbatim/{v /g +s/\\endverbatim/ v}/g +s/\\mlonly//g +s/\\endmlonly//g +s/\\mlh/\\\[ \[/g +s/\\endmlh/\] \\\]/g +s/\\deprecated/@deprecated/g +s/\\ / /g + +# '\c code ' -> '[code]' +s/\\c \([^ .,:]*\)/[\1]/g + +# '#Z3_' -> 'Z3.' +s/#Z3_\([^ \n\.\t,)]*\)/{!Z3.\1}/g + +# '/*@}*/' -> '' +s/\/\*@{\*\///g + +# '/*@{*/' -> '' +s/\/\*@}\*\///g + +# '/*...*/' -> '' +s/\/\*.*\*\///g + +s|(\*\*/\*\*)|(\*\*%\*\*)|g + +# '/**' -> 'quote(mli,"(**' +s|/\*\*|quote(mli,\"(**|g + +# '...*/' -> '*)");' +s|[ ]*\*/|*)\");|g + +s|(\*\*%\*\*)|(\*\*/\*\*)|g + +# 'extern "C"' -> 'extern ~~C~~' +# 'quote(foo,"bar")' -> quote(foo,~~bar~~) +# mltype("foo") -> mltype(~~foo~~) +s/extern \"C\"/extern ~~C~~/g +s/quote(\(.*\),\"\(.*\)\")/quote(\1,~~\2~~)/g +s/quote(\(.*\),\"/quote(\1,~~/g +s/\")\;/~~);/g +s/\;\"/;~~/g +s/mltype(\"\(.*\)\")/mltype(~~\1~~)/g + +# '"' -> '\"' +s/\\\"/\"/g +s/\"/\\\"/g + +# '~~' -> '"' +s/~~/\"/g diff --git a/ml/clean.cmd b/ml/clean.cmd new file mode 100644 index 000000000..8214d1143 --- /dev/null +++ b/ml/clean.cmd @@ -0,0 +1,13 @@ +@echo off + +REM Script to delete generated Z3 OCaml API files + +call .\cleantmp.cmd + +REM files produced by generate_mlapi.cmd +del /q 2>NUL z3_stubs.c z3.mli z3.ml z3V3_stubs.*.c z3V3.*.mli z3V3.*.ml + +REM files produced by update-ml-doc.cmd +rd 2>NUL /s /q doc + +exit /B 0 diff --git a/ml/cleantmp.cmd b/ml/cleantmp.cmd new file mode 100644 index 000000000..6d4e12849 --- /dev/null +++ b/ml/cleantmp.cmd @@ -0,0 +1,15 @@ +@echo off + +REM Script to delete intermediate temporary files from generating Z3 OCaml API + +REM files produced by generate_mlapi.cmd +del /q 2>NUL z3_api.idl + +REM files produced by compile_mlapi.cmd +del /q 2>NUL *.cmi *.cmo *.cmx *.cma *.cmxa *.obj *.lib *.pdb ocamlz3.exe + +REM files produced by test_mlapi.cmd +del /q 2>NUL test*.exe queen*.exe test_*api.out test_*apiV3.out test_*api.err test_*apiV3.err queen.out queen.err z3.log ml.log test_mlapi.log + +REM backup files +del /q 2>NUL *~ diff --git a/ml/compile_mlapi.cmd b/ml/compile_mlapi.cmd new file mode 100644 index 000000000..02a2f2745 --- /dev/null +++ b/ml/compile_mlapi.cmd @@ -0,0 +1,95 @@ +@echo off +SETLOCAL + +REM Script to compile the Z3 OCaml API +REM Compiles byte and debug native code versions with debug info, optimized native code versions without + +REM directory containing z3_api.h +set Z3SRC=%1 + +REM directory containing z3.dll +set Z3BIN=%2 + +REM directory containing debug z3.dll +set Z3BINDBG=%3 + +REM link Z3 statically or dynamically +set STATIC=false +REM set STATIC=true + +if %STATIC% == true ( + set Z3LIB=z3lib.lib + set Z3DBGLIB=z3lib.lib +) else ( + set Z3LIB=z3.lib + set Z3DBGLIB=z3_dbg.lib +) + +REM ocaml 3.11 and later calls the linker through flexlink +ocamlc -version >> ocaml_version +set /p OCAML_VERSION= DBG z3_stubs.obj z3.{cmi,cmo,obj} +ocamlc -c %XCDBG% z3_stubs.c z3_theory_stubs.c z3.mli z3.ml +if errorlevel 1 goto :EOF + +REM z3_stubs.c z3_theory_stubs.c z3.mli z3.ml -> DBG z3_stubs.obj z3.{cmi,cmx,obj} +ocamlopt -c %XCDBG% z3_stubs.c z3_theory_stubs.c z3.mli z3.ml +if errorlevel 1 goto :EOF + +REM %Z3DBGLIB% z3.obj z3_stubs.obj z3_theory_stubs.obj -> libz3_dbg.lib: +lib /nologo %XLIBPATH% /out:libz3_dbg.lib %Z3BINDBG%\%Z3DBGLIB% z3.obj z3_stubs.obj z3_theory_stubs.obj +if errorlevel 1 goto :EOF + +REM z3_stubs.c z3_theory_stubs.c z3.mli z3.ml -> OPT z3_stubs.obj z3.{cmi,cmx,obj} +ocamlopt -c %XCOPT% z3_stubs.c z3_theory_stubs.c z3.mli z3.ml +if errorlevel 1 goto :EOF + +REM %Z3LIB% z3.obj z3_stubs.obj z3_theory_stubs.obj -> libz3.lib: +lib /nologo %XLIBPATH% /out:libz3.lib %Z3BIN%\%Z3LIB% z3.obj z3_stubs.obj z3_theory_stubs.obj +if errorlevel 1 goto :EOF + + +REM ole32.lib is needed by camlidl +REM camlidl.lib is the runtime library for camlidl +REM psapi.lib is needed when statically linking Z3 for process statistics functions + +REM libz3_dbg.lib ole32.lib camlidl.lib z3.cmo -> z3_dbg.cma +ocamlc -custom -a %XCDBG% -cclib -L"%CD%\..\bin" -cclib -lz3_dbg -cclib ole32.lib -cclib -lcamlidl -cclib psapi.lib z3.cmo -o z3_dbg.cma +if errorlevel 1 goto :EOF + +REM libz3.lib ole32.lib camlidl.lib z3.cmo -> z3.cma +ocamlc -custom -a -cclib -L"%CD%\..\bin" -cclib -lz3 -cclib ole32.lib -cclib -lcamlidl -cclib psapi.lib z3.cmo -o z3.cma +if errorlevel 1 goto :EOF + + +REM libz3_dbg.lib ole32.lib camlidl.lib z3.cmx -> z3_dbg.cmxa +ocamlopt -a -cclib -L"%CD%\..\bin" -cclib -lz3_dbg -cclib ole32.lib -cclib -lcamlidl -cclib psapi.lib z3.cmx -o z3_dbg.cmxa +if errorlevel 1 goto :EOF + +REM libz3.lib ole32.lib camlidl.lib z3.cmx -> z3.cmxa +ocamlopt -a -cclib -L"%CD%\..\bin" -cclib -lz3 -cclib ole32.lib -cclib -lcamlidl -cclib psapi.lib z3.cmx -o z3.cmxa +if errorlevel 1 goto :EOF + + +REM build OCaml toplevel 'ocamlz3' pre-linked with Z3 +ocamlmktop -o ocamlz3 z3.cma +if errorlevel 1 goto :EOF + + +del /q 2>NUL z3.cmo z3.cmx *.obj + +ENDLOCAL diff --git a/ml/diff.exe b/ml/diff.exe new file mode 100644 index 000000000..2797ffd05 Binary files /dev/null and b/ml/diff.exe differ diff --git a/ml/error_handling.idl b/ml/error_handling.idl new file mode 100644 index 000000000..cc49a91e4 --- /dev/null +++ b/ml/error_handling.idl @@ -0,0 +1,162 @@ +/*++ +Copyright (c) Microsoft Corporation + +Module Name: + + error_handling + +Abstract: + + Error handling in the OCaml API for Z3. + + The wrapper of each Z3 API routine that takes a Z3_context or a Z3_theory + argument calls check_error_code before returning. (These calls are added + in generate_mlapi.cmd using the build.sed script.) + + There are two error handling schemes implemented, depending on whether + (UN)SAFE_ERRORS is set. + + - SAFE_ERRORS checks Z3_error_code after each call and raises an OCaml + exception in error conditions. Z3_set_error_handler is not exposed by + the SAFE_ERRORS version. + + - UNSAFE_ERRORS sets a Z3 error handler routine that either calls a + globally registered OCaml function or, by default, raises an OCaml + exception. This avoids overhead of repeatedly checking + Z3_get_error_code, but leaves Z3 in a broken state. + +Notes: + + The current SAFE_ERRORS implementation interacts badly with theory plugin + callbacks. Z3 errors are converted into OCaml exceptions, which the + wrappers of theory plugin callbacks are not expecting. Therefore, if a + theory plugin calls a Z3 API routine that triggers an error, an OCaml + exception will be raised and bypass any C++ destructors pushed onto the + stack by Z3 before the call to the plugin and after the preceding OCaml + exception handler. One solution to this would be to modify the theory + plugin callback registration functions to wrap callbacks in an OCaml + exception handler. Since OCaml exceptions are cheap to raise at the + expense of some cost to install a handler, this may not be desirable. + Another solution would be to modify check_error_code to detect if it is + executing in a plugin callback and simply maintain the Z3_error_code, or + raise a C++ exception, instead of raising an OCaml exception. + +Author: + + Josh Berdine (jjb) 2012-03-21 + +--*/ + + +#if !defined(UNSAFE_ERRORS) && !defined(SAFE_ERRORS) +#define SAFE_ERRORS +#endif + + +#ifdef SAFE_ERRORS + +quote(mlmli," +(** Exceptions raised by Z3. It is safe to continue interacting with Z3 after + catching [Error] exceptions. + + - {b See also}: {!get_error_msg} +*) +exception Error of context * error_code +"); +quote(ml," +/* Register dynamically-generated exception tag for use from C */ +let _ = Callback.register_exception \"Z3.Error\" (Error (Obj.magic None, OK)) +"); + +quote(c," +value camlidl_c2ml_z3_Z3_error_code(Z3_error_code * _c2, camlidl_ctx _ctx); + +/* Error checking routine that raises OCaml Error exceptions */ +void check_error_code (Z3_context c) +{ + static struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + value* exn_tag = NULL; + value ctx_err[2]; + Z3_error_code e; + e = Z3_get_error_code(c); + if (e != Z3_OK) { + ctx_err[0] = c2ml_Z3_context(&c); + ctx_err[1] = camlidl_c2ml_z3_Z3_error_code(&e, &_ctxs); + exn_tag = caml_named_value(\"Z3.Error\"); + if (*exn_tag == 0) { + fprintf(stderr, \"Z3.Error not found\"); + exit(1); + } + caml_raise_with_args(*exn_tag, 2, ctx_err); + } +} + +/* Disable default error handler, all error checking is done by check_error_code */ +void* error_handler_static = NULL; +"); + +#else + +quote(mlmli," +(** Exceptions raised by Z3. {b Warning}: It is unsafe to continue + interacting with Z3 after catching [Error] exceptions. To recover from + error conditions, use {!set_error_handler} to set an error handler that + does nothing, and then test {!get_error_code} after every call to Z3. + + - {b See also}: {!get_error_msg} +*) +exception Error of context * error_code +"); +quote(ml," +/* Register dynamically-generated exception tag for use from C */ +let _ = Callback.register_exception \"Z3.Error\" (Error (Obj.magic None, OK)) +"); + +quote(c," +/* Error checking routine that does nothing */ +void check_error_code(Z3_context c) {} + +/* All contexts share the same handler */ +static value caml_error_handler = 0; + +static void error_handler_static (Z3_context c, Z3_error_code e) +{ + static struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + value* exn_tag = NULL; + value ctx_err[2]; + ctx_err[0] = c2ml_Z3_context(&c); + ctx_err[1] = camlidl_c2ml_z3_Z3_error_code(&e, &_ctxs); + if (caml_error_handler) { + caml_callback2(caml_error_handler, ctx_err[0], ctx_err[1]); + } else { + /* if no handler set, raise OCaml Error exception */ + exn_tag = caml_named_value(\"Z3.Error\"); + if (*exn_tag == 0) { + fprintf(stderr, \"Z3.Error not found\"); + exit(1); + } + caml_raise_with_args(*exn_tag, 2, ctx_err); + } +} + +void ml2c_Z3_error_handler (value ml_handler, void* c_handler) +{ + caml_error_handler = ml_handler; + c_handler = (void*)error_handler_static; +} + +/* Never called */ +value c2ml_Z3_error_handler (void* _) +{ + return 0; +} +"); + +typedef [mltype("context -> error_code -> unit"), + ml2c(ml2c_Z3_error_handler), + c2ml(c2ml_Z3_error_handler) + ] void Z3_error_handler; + +quote(c,"#define Z3_error_handler void*"); + +#endif diff --git a/ml/generate_mlapi.cmd b/ml/generate_mlapi.cmd new file mode 100644 index 000000000..8f64cb057 --- /dev/null +++ b/ml/generate_mlapi.cmd @@ -0,0 +1,69 @@ +@echo off + +REM Script to generate the Z3 OCaml API +REM Invoke with "-D UNSAFE_ERRORS" to build version that does not support recoverable errors, but avoids some error-checking overhead. +REM Invoke with "-D LEAK_CONTEXTS" to build version that leaks Z3_context objects, but avoids some garbage-collection overhead. + +REM ../lib/z3_api.h -> z3V3_api.idl using add_error_checking.V3.sed and build.sed +sed -f add_error_checking.V3.sed ../lib/z3_api.h | sed -f build.sed >z3V3_api.idl +if errorlevel 1 goto :EOF + +REM z3.idl -> z3V3_stubs.c, z3V3.mli, z3V3.ml +camlidl -D MLAPIV3 %* z3.idl +move >NUL z3_stubs.c z3V3_stubs.c +move >NUL z3.ml z3V3.ml +move >NUL z3.mli z3V3.mli +if errorlevel 1 goto :EOF + +REM ../lib/z3_api.h -> z3_api.idl +REM add calls to error checking routine +REM convert from doxygen to ocamldoc markup and other syntactic munging +sed <../lib/z3_api.h -f add_error_checking.sed | ^ +sed -f build.sed >z3_api.idl +if errorlevel 1 goto :EOF + +REM z3.idl -> z3_stubs.c, z3.mli, z3.ml +camlidl %* z3.idl +if errorlevel 1 goto :EOF + +REM sometimes z3_stubs.c can be generated with mixed line endings, which can confuse sed and grep +dos2unix 2>NUL z3V3_stubs.c ; unix2dos 2>NUL z3V3_stubs.c +dos2unix 2>NUL z3_stubs.c ; unix2dos 2>NUL z3_stubs.c + +REM modify generated z3.ml{,i} to remove "Z3_" prefix from names +move >NUL z3V3.mli z3V3.1.mli && sed "s/{\!Z3\./{!/g;s/\<[zZ]3_//g" z3V3.1.mli >z3V3.mli && del z3V3.1.mli +move >NUL z3V3.ml z3V3.1.ml && sed "s/{\!Z3\./{!/g;s/\<[zZ]3_//g" z3V3.1.ml >z3V3.ml && del z3V3.1.ml +move >NUL z3.mli z3.1.mli && sed "s/{\!Z3\./{!/g;s/\<[zZ]3_//g" z3.1.mli >z3.mli && del z3.1.mli +move >NUL z3.ml z3.1.ml && sed "s/{\!Z3\./{!/g;s/\<[zZ]3_//g" z3.1.ml >z3.ml && del z3.1.ml + +REM modify generated z3V3 files to rename z3_ to z3V3_ +move >NUL z3V3.mli z3V3.2.mli && sed "s/camlidl\(.*\)_z3_/camlidl\1_z3V3_/g" z3V3.2.mli >z3V3.mli && del z3V3.2.mli +move >NUL z3V3.ml z3V3.2.ml && sed "s/camlidl\(.*\)_z3_/camlidl\1_z3V3_/g" z3V3.2.ml >z3V3.ml && del z3V3.2.ml +move >NUL z3V3_stubs.c z3V3_stubs.2.c && sed "s/camlidl\(.*\)_z3_/camlidl\1_z3V3_/g" z3V3_stubs.2.c >z3V3_stubs.c && del z3V3_stubs.2.c + + +REM substitute out type equations for enums and options +REM reverse order of substitution of enums to avoid matching prefixes such as enum_1 of enum_10 +grep "^and \([a-z][a-zA-Z_]*\) = \([a-z][a-zA-Z_]*[0-9]*\)$" z3.mli | sed "s|and \([a-zA-Z_]*\) = \([ a-zA-Z_0-9]*\)|s/\2/\1/g|g" | sed "1!G;h;$!d" >rename.sed +grep "^and \([a-z][a-zA-Z_]*\) = \([a-z][a-zA-Z_]* option*\)$" z3.mli | sed "s|and \([a-zA-Z_]*\) = \([ a-zA-Z_0-9]*\)|s/\1/\2/g|g" >>rename.sed +move >NUL z3.mli z3.3.mli && sed -f rename.sed z3.3.mli >z3.mli && del z3.3.mli +move >NUL z3.ml z3.3.ml && sed -f rename.sed z3.3.ml >z3.ml && del z3.3.ml +del rename.sed + +grep "^and \([a-z][a-zA-Z_]*\) = \([a-z][a-zA-Z_]*[0-9]*\)$" z3V3.mli | sed "s|and \([a-zA-Z_]*\) = \([ a-zA-Z_0-9]*\)|s/\2/\1/g|g" | sed "1!G;h;$!d" >rename.sed +grep "^and \([a-z][a-zA-Z_]*\) = \([a-z][a-zA-Z_]* option*\)$" z3V3.mli | sed "s|and \([a-zA-Z_]*\) = \([ a-zA-Z_0-9]*\)|s/\1/\2/g|g" >>rename.sed +move >NUL z3V3.mli z3V3.3.mli && sed -f rename.sed z3V3.3.mli >z3V3.mli && del z3V3.3.mli +move >NUL z3V3.ml z3V3.3.ml && sed -f rename.sed z3V3.3.ml >z3V3.ml && del z3V3.3.ml +del rename.sed + +REM remove cyclic definitions introduced by substituting type equations +move >NUL z3V3.mli z3V3.4.mli && sed "s/^and \([a-z][a-zA-Z_ ]*\) = \1$//g" z3V3.4.mli >z3V3.mli && del z3V3.4.mli +move >NUL z3V3.ml z3V3.4.ml && sed "s/^and \([a-z][a-zA-Z_ ]*\) = \1$//g" z3V3.4.ml >z3V3.ml && del z3V3.4.ml +move >NUL z3.mli z3.4.mli && sed "s/^and \([a-z][a-zA-Z_ ]*\) = \1$//g" z3.4.mli >z3.mli && del z3.4.mli +move >NUL z3.ml z3.4.ml && sed "s/^and \([a-z][a-zA-Z_ ]*\) = \1$//g" z3.4.ml >z3.ml && del z3.4.ml + +REM append Z3.V3 module onto Z3 module +type z3V3.ml >> z3.ml +type z3V3.mli >> z3.mli +sed "1,22d" z3V3_stubs.c >> z3_stubs.c +del /q 2>NUL z3V3_api.idl z3V3.ml z3V3.mli z3V3_stubs.c diff --git a/ml/import.cmd b/ml/import.cmd new file mode 100644 index 000000000..b5239e011 --- /dev/null +++ b/ml/import.cmd @@ -0,0 +1,55 @@ +@echo off +SETLOCAL + +:CHECKARG1 +if not "%1"=="" ( + set SDTROOT=%1 + goto :CHECKARG2 +) + +goto :FAIL + + +:CHECKARG2 +if "%2"=="" ( + goto :IMPORT +) + +goto :FAIL + + +:IMPORT +cd import +sd edit ... +del z3.h z3_api.h z3_macros.h z3lib.lib msbig_rational.lib z3.exe test_capi.c test_mlapi_header.html z3_mlapi_header.html mldoc_footer.html tabs.css z3.png z3_ml.css +copy %SDTROOT%\lib\z3.h +copy %SDTROOT%\lib\z3_api.h +copy %SDTROOT%\lib\z3_macros.h +copy %SDTROOT%\release_mt\z3lib.lib +copy %SDTROOT%\release_mt\msbig_rational.lib +copy %SDTROOT%\release_mt\z3.exe +copy %SDTROOT%\test_capi\test_capi.c +copy %SDTROOT%\doc\test_mlapi_header.html +copy %SDTROOT%\doc\z3_mlapi_header.html +copy %SDTROOT%\doc\mldoc_footer.html +copy %SDTROOT%\doc\html\tabs.css +copy %SDTROOT%\doc\z3.png +copy %SDTROOT%\doc\z3_ml.css +sd add ... +sd revert -a ... +cd .. +goto :END + +:FAIL +echo "Usage:" +echo " %0 SDTROOT" +echo "" +echo "Examples:" +echo " %0 \\risebuild\drops\z32\2.0.51220.7" +echo " %0 \\risebuild\drops\z32\latest" +echo " %0 J:\SD\other\sdt1\src\z3_2" +echo "" +goto :END + +:END +ENDLOCAL diff --git a/ml/mlx_get_app_args.idl b/ml/mlx_get_app_args.idl new file mode 100644 index 000000000..fe3407af8 --- /dev/null +++ b/ml/mlx_get_app_args.idl @@ -0,0 +1,11 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mli," +(** + Summary: \[ [ get_app_args c a ] \] is the array of arguments of an application. If [t] is a constant, then the array is empty. + + - {b See also}: {!get_app_num_args} + - {b See also}: {!get_app_arg} +*) +val get_app_args: context -> app -> ast array +"); diff --git a/ml/mlx_get_array_sort.idl b/ml/mlx_get_array_sort.idl new file mode 100644 index 000000000..81bf6e00f --- /dev/null +++ b/ml/mlx_get_array_sort.idl @@ -0,0 +1,11 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mli," +(** + Summary: \[ [ get_array_sort c t ] \] is the domain and the range of [t]. + + - {b See also}: {!get_array_sort_domain} + - {b See also}: {!get_array_sort_range} +*) +val get_array_sort: context -> sort -> sort * sort +"); diff --git a/ml/mlx_get_datatype_sort.idl b/ml/mlx_get_datatype_sort.idl new file mode 100644 index 000000000..3466a9050 --- /dev/null +++ b/ml/mlx_get_datatype_sort.idl @@ -0,0 +1,13 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mli," +(** + Summary: \[ [ get_datatype_sort c ty ] \] is the array of triples [(constructor, recognizer, fields)] where [constructor] is the constructor declaration of [ty], [recognizer] is the recognizer for the [constructor], and [fields] is the array of fields in [ty]. + + - {b See also}: {!get_datatype_sort_num_constructors} + - {b See also}: {!get_datatype_sort_constructor} + - {b See also}: {!get_datatype_sort_recognizer} + - {b See also}: {!get_datatype_sort_constructor_accessor} +*) +val get_datatype_sort: context -> sort -> datatype_constructor array +"); diff --git a/ml/mlx_get_domains.idl b/ml/mlx_get_domains.idl new file mode 100644 index 000000000..ebc6d8556 --- /dev/null +++ b/ml/mlx_get_domains.idl @@ -0,0 +1,11 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mli," +(** + Summary: \[ [ get_domains c d ] \] is the array of parameters of [d]. + + - {b See also}: {!get_domain_size} + - {b See also}: {!get_domain} +*) +val get_domains: context -> func_decl -> sort array +"); diff --git a/ml/mlx_get_error_msg.idl b/ml/mlx_get_error_msg.idl new file mode 100644 index 000000000..b8ea97e03 --- /dev/null +++ b/ml/mlx_get_error_msg.idl @@ -0,0 +1,6 @@ +quote(mli," +(** + Summary: Return a string describing the given error code. +*) +val get_error_msg: context -> error_code -> string +"); diff --git a/ml/mlx_get_pattern_terms.idl b/ml/mlx_get_pattern_terms.idl new file mode 100644 index 000000000..749a90f3a --- /dev/null +++ b/ml/mlx_get_pattern_terms.idl @@ -0,0 +1,11 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mli," +(** + Summary: \[ [ get_pattern_terms c p ] \] is the ast's in pattern. + + - {b See also}: {!get_pattern_num_terms} + - {b See also}: {!get_pattern} +*) +val get_pattern_terms: context -> pattern -> ast array;; +"); diff --git a/ml/mlx_get_tuple_sort.idl b/ml/mlx_get_tuple_sort.idl new file mode 100644 index 000000000..1555f6c8a --- /dev/null +++ b/ml/mlx_get_tuple_sort.idl @@ -0,0 +1,12 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mli," +(** + Summary: \[ [ get_tuple_sort c ty ] \] is the pair [(mk_decl, fields)] where [mk_decl] is the constructor declaration of [ty], and [fields] is the array of fields in [ty]. + + - {b See also}: {!get_tuple_sort_mk_decl} + - {b See also}: {!get_tuple_sort_num_fields} + - {b See also}: {!get_tuple_sort_field_decl} +*) +val get_tuple_sort: context -> sort -> (func_decl * func_decl array) +"); diff --git a/ml/mlx_mk_context_x.idl b/ml/mlx_mk_context_x.idl new file mode 100644 index 000000000..7e4fd25c9 --- /dev/null +++ b/ml/mlx_mk_context_x.idl @@ -0,0 +1,36 @@ +quote(mlmli,"external mk_context: (string * string) list -> context = \"caml_z3_mk_context\" +"); +// Note: lack of whitespace and comments in the previous 2 lines is important for the documentation generation +quote(c," +value caml_z3_mk_context(value key_val_list) +{ + CAMLparam1( key_val_list ); + CAMLlocal4( item, vkey, vval, _vres ); + char * ckey; + char * cval; + Z3_config cfg; + Z3_context _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + + cfg = Z3_mk_config(); + + while (key_val_list != Val_emptylist) + { + item = Field(key_val_list, 0); + vkey = Field(item, 0); + vval = Field(item, 1); + ckey = camlidl_malloc_string(vkey, _ctx); + cval = camlidl_malloc_string(vval, _ctx); + Z3_set_param_value(cfg, ckey, cval); + key_val_list = Field(key_val_list, 1); + } + + _res = Z3_mk_context_rc(cfg); + Z3_del_config(cfg); + _vres = camlidl_c2ml_z3_Z3_context(&_res, _ctx); + camlidl_free(_ctx); + Z3_set_error_handler(_res, error_handler_static); + CAMLreturn(_vres); +} +"); diff --git a/ml/mlx_mk_datatypes.idl b/ml/mlx_mk_datatypes.idl new file mode 100644 index 000000000..21bdcdbc7 --- /dev/null +++ b/ml/mlx_mk_datatypes.idl @@ -0,0 +1,28 @@ +quote(mlmli," +(** A constructor of a datatype is described by: *) +type datatype_constructor_desc = { + constructor_desc : symbol; (** name of the constructor function *) + recognizer_desc : symbol; (** name of the recognizer function *) + accessor_descs : (symbol * sort) array; (** names and sorts of the fields *) +} + +(** A datatype is described by a name and constructor descriptors. *) +type datatype_desc = symbol * datatype_constructor_desc array + +(** A constructor of a datatype is represented by: *) +type datatype_constructor = { + constructor : func_decl; (** constructor function *) + recognizer : func_decl; (** recognizer function *) + accessors : func_decl array; (** field accessor functions *) +} + +(** A datatype is represented by a sort and constructors. *) +type datatype = sort * datatype_constructor array +"); + +quote(mli," +(** [mk_datatypes ctx sorts_to_descriptors] creates mutually recursive datatypes described by + [sorts_to_descriptors], which is a function from the sorts of the datatypes to be created to + descriptors of the datatypes' constructors. {b See also}: {!Test_mlapi.forest_example} *) +val mk_datatypes: context -> (sort array -> (datatype_desc array) option) -> datatype array +"); diff --git a/ml/mlx_mk_numeral.idl b/ml/mlx_mk_numeral.idl new file mode 100644 index 000000000..0fa9caf39 --- /dev/null +++ b/ml/mlx_mk_numeral.idl @@ -0,0 +1,21 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mlmli," +(** + Summary: \[ [ numeral_refined ] \] is the refined view of a numeral . +*) +type numeral_refined = + | Numeral_int of int * sort + | Numeral_int64 of int64 * sort + | Numeral_large of string * sort + | Numeral_rational of numeral_refined * numeral_refined +"); + +quote(mli," +(** + Summary: \[ [ embed_numeral c nr ] \] constructs the numeral described by [nr]. + + - {b See also}: {!numeral_refine} +*) +val embed_numeral: context -> numeral_refined -> ast +"); diff --git a/ml/mlx_mk_sort.idl b/ml/mlx_mk_sort.idl new file mode 100644 index 000000000..dd4222f81 --- /dev/null +++ b/ml/mlx_mk_sort.idl @@ -0,0 +1,69 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mlmli," +(** + A datatype constructor descriptor. +*) +type datatype_constructor_desc = { + constructor_desc : symbol; (** name of the constructor function *) + recognizer_desc : symbol; (** name of the recognizer function *) + accessor_descs : (symbol * sort) array; (** names and sorts of the fields *) +} + +(** + A datatype is described by a name and constructor descriptors. +*) +type datatype_desc = symbol * datatype_constructor_desc array + +(** + A datatype constructor representation. +*) +type datatype_constructor = { + constructor : func_decl; (** constructor function *) + recognizer : func_decl; (** recognizer function *) + accessors : func_decl array; (** field accessor functions *) +} + +(** + A datatype is represented by a sort and constructors. +*) +type datatype = sort * datatype_constructor array + +(** + Refined view of a {!sort}. + + - {b See also}: {!mk_sort} + - {b See also}: {!sort_refine} +*) +type sort_refined = + | Sort_uninterpreted of symbol + | Sort_bool + | Sort_int + | Sort_bv of int + | Sort_finite_domain of symbol * int64 + | Sort_real + | Sort_array of sort * sort + | Sort_datatype of datatype_constructor array + | Sort_relation of sort array + | Sort_unknown +"); + +quote(mli," +(** + Summary: \[ [ mk_sort c sr ] \] constructs the sort described by [sr]. + + - {b Precondition}: [sr] is not of form [Sort_relation] or [Sort_unknown], which cannot be directly constructed + - {b See also}: {!mk_datatypes} + - {b See also}: {!sort_refine} +*) +val mk_sort: context -> sort_refined -> sort + +(** + \[ [mk_datatypes ctx sorts_to_descriptors] \] creates mutually recursive datatypes described by + [sorts_to_descriptors], which is a function from the sorts of the datatypes to be created to + descriptors of the datatypes' constructors. + + - {b See also}: {!Test_mlapi.forest_example} +*) +val mk_datatypes: context -> (sort array -> (datatype_desc array) option) -> datatype array +"); diff --git a/ml/mlx_mk_symbol.idl b/ml/mlx_mk_symbol.idl new file mode 100644 index 000000000..6969c7380 --- /dev/null +++ b/ml/mlx_mk_symbol.idl @@ -0,0 +1,22 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mlmli," +(** + Refined view of a {!symbol}. + + - {b See also}: {!mk_symbol} + - {b See also}: {!symbol_refine} +*) +type symbol_refined = + | Symbol_int of int + | Symbol_string of string +"); + +quote(mli," +(** + Summary: \[ [ mk_symbol c sr ] \] constructs the symbol described by [sr]. + + - {b See also}: {!symbol_refine} +*) +val mk_symbol: context -> symbol_refined -> symbol +"); diff --git a/ml/mlx_model.idl b/ml/mlx_model.idl new file mode 100644 index 000000000..192a982b3 --- /dev/null +++ b/ml/mlx_model.idl @@ -0,0 +1,19 @@ +quote(mlmli," +(** + A model assigns uninterpreted sorts to finite universes of distinct values, constants to values, + and arrays and functions to finite maps from argument values to result values plus a default + value for all other arguments. +*) +type model_refined = { + sorts : (sort, ast_vector) Hashtbl.t; + consts : (func_decl, ast) Hashtbl.t; + arrays : (func_decl, (ast, ast) Hashtbl.t * ast) Hashtbl.t; + funcs : (func_decl, (ast array, ast) Hashtbl.t * ast) Hashtbl.t; +} +"); +quote(mli," +(** + Summary: [model_refine c m] is the refined model of [m]. +*) +val model_refine : context -> model -> model_refined +"); diff --git a/ml/mlx_numeral_refine.idl b/ml/mlx_numeral_refine.idl new file mode 100644 index 000000000..8b2f0a07f --- /dev/null +++ b/ml/mlx_numeral_refine.idl @@ -0,0 +1,10 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mli," +(** + Summary: \[ [ numeral_refine c a ] \] is the refined view of [a]. + + - {b Precondition}: [get_ast_kind c a = NUMERAL_AST] +*) +val numeral_refine : context -> ast -> numeral_refined +"); diff --git a/ml/mlx_parse_smtlib.idl b/ml/mlx_parse_smtlib.idl new file mode 100644 index 000000000..dbc2e42da --- /dev/null +++ b/ml/mlx_parse_smtlib.idl @@ -0,0 +1,40 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mli," +(** + Summary: \[ [ parse_smtlib_string_x c str sort_names sorts decl_names decls ] \] + + Parse the given string using the SMT-LIB parser. + + The symbol table of the parser can be initialized using the given sorts and declarations. + The symbols in the arrays [sort_names] and [decl_names] don't need to match the names + of the sorts and declarations in the arrays [sorts] and [decls]. This is an useful feature + since we can use arbitrary names to reference sorts and declarations defined using the API. + + - {b See also}: {!parse_smtlib_file_x} +*) +val parse_smtlib_string_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) + +(** + Summary: Similar to {!parse_smtlib_string_x}, but reads the benchmark from a file. + + - {b See also}: {!parse_smtlib_string_x} +*) +val parse_smtlib_file_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) + +(** + Summary: \[ [ parse_smtlib_string_formula c ... ] \] calls [(parse_smtlib_string c ...)] and returns the single formula produced. + + - {b See also}: {!parse_smtlib_file_formula} + - {b See also}: {!parse_smtlib_string_x} +*) +val parse_smtlib_string_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + +(** + Summary: \[ [ parse_smtlib_file_formula c ... ] \] calls [(parse_smtlib_file c ...)] and returns the single formula produced. + + - {b See also}: {!parse_smtlib_string_formula} + - {b See also}: {!parse_smtlib_file_x} +*) +val parse_smtlib_file_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast +"); diff --git a/ml/mlx_sort_refine.idl b/ml/mlx_sort_refine.idl new file mode 100644 index 000000000..1f2ba8eab --- /dev/null +++ b/ml/mlx_sort_refine.idl @@ -0,0 +1,8 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mli," +(** + Summary: \[ [ sort_refine c s ] \] is the refined view of [s]. +*) +val sort_refine: context -> sort -> sort_refined +"); diff --git a/ml/mlx_statistics.idl b/ml/mlx_statistics.idl new file mode 100644 index 000000000..47028f012 --- /dev/null +++ b/ml/mlx_statistics.idl @@ -0,0 +1,10 @@ +quote(mlmli," +type stat_datum = Stat_int of int | Stat_float of float +type stats_refined = (string, stat_datum) Hashtbl.t +"); +quote(mli," +(** + Summary: [stats_refine c s] is the refined stats of [s]. +*) +val stats_refine : context -> stats -> stats_refined +"); diff --git a/ml/mlx_symbol_refine.idl b/ml/mlx_symbol_refine.idl new file mode 100644 index 000000000..0d74e9cd9 --- /dev/null +++ b/ml/mlx_symbol_refine.idl @@ -0,0 +1,8 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mli," +(** + Summary: \[ [ symbol_refine c s ] \] is the refined view of [s]. +*) +val symbol_refine: context -> symbol -> symbol_refined +"); diff --git a/ml/mlx_term_refine.idl b/ml/mlx_term_refine.idl new file mode 100644 index 000000000..2fa8fd36f --- /dev/null +++ b/ml/mlx_term_refine.idl @@ -0,0 +1,37 @@ +/* Copyright (c) Microsoft Corporation */ + +quote(mlmli," +(** + Summary: \[ [ binder_type ] \] is a universal or existential quantifier. + + - {b See also}: {!term_refined} +*) +type binder_type = Forall | Exists + +(** + Summary: \[ [ term_refined ] \] is the refinement of a {!ast} . + + - {b See also}: {!term_refine} +*) +type term_refined = + | Term_numeral of numeral_refined + | Term_app of decl_kind * func_decl * ast array + | Term_quantifier of binder_type * int * ast array array * (symbol * sort) array * ast + | Term_var of int * sort +"); + +quote(mli," +(** + Summary: \[ [ mk_term c tr ] \] constructs the term described by [tr]. + + - {b Precondition}: [tr] is not of form + - {b See also}: {!term_refine} +*) +(* val mk_term: context -> term_refined -> ast *) + + +(** + Summary: \[ [ term_refine c a ] \] is the refined view of [a]. +*) +val term_refine : context -> ast -> term_refined +"); diff --git a/ml/msbuild.proj b/ml/msbuild.proj new file mode 100644 index 000000000..ee2a6915e --- /dev/null +++ b/ml/msbuild.proj @@ -0,0 +1,72 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/ml/queen.ml b/ml/queen.ml new file mode 100644 index 000000000..e22db9cfb --- /dev/null +++ b/ml/queen.ml @@ -0,0 +1,112 @@ +(* + queen.exe - JakobL@2007-09-22 + + Demonstration of how Z3 can be used to find solutions to the + N-Queens problem. + + See: http://en.wikipedia.org/wiki/Eight_queens_puzzle + + Problem specification: Is the following constraint system satisfiable, + for increasing n>=1, what are the models? + + constant + n: 8; + + variable + row: array n of [0..n-1]; + + rule + forall i in [0..n-2]: + (forall j in [i+1..n-1]: + ((row[i] <> row[j]) and + (i+row[i]) <> (j+row[j]) and + (i+row[j]) <> (j+row[i]))); + + The answer is yes for n different from 2 and 3. The number of solutions are: + * n=1: 1 + * n=2: 0 + * n=3: 0 + * n=4: 2 + * n=5: 10 + * n=6: 4 + * n=7: 40 + * n=8: 92 + * n=9: 352 + * n=10: 724 + ... +*) + +module Z3 = Z3.V3 + +(* Auxillary functions *) +let ( |> ) x f = f x;; +let printf = Printf.printf;; +let mk_var ctx name ty = Z3.mk_const ctx (Z3.mk_int_symbol ctx name) ty;; +let mk_int_var ctx name = Z3.mk_int_sort ctx |> mk_var ctx name;; +let mk_int ctx v = Z3.mk_int ctx v (Z3.mk_int_sort ctx);; +let checkreturn v = match v with | (true,r) -> r | _ -> failwith "checkreturn";; +let get_numeral_value_int a1 a2 = Z3.get_numeral_int a1 a2 |> checkreturn;; +let iterate_x lower upper f = for i = lower to upper do f i done;; +let forall_x ctx lower upper f = Z3.mk_and ctx (Array.init (1+upper-lower) (fun i->f (i+lower))) +let exist_x ctx lower upper f = Z3.mk_or ctx (Array.init (1+upper-lower) (fun i->f (i+lower))) +let get_value ctx model f = let (ok, v) = Z3.eval_func_decl ctx model f in (assert ok; v) + +let queen_n n = + let ctx = Z3.mk_context_x + [|("MODEL","true"); + ("RELEVANCY","0")|] in + let ( &&& ) x y = Z3.mk_and ctx [|x;y|] in + let ( <~> ) x y = Z3.mk_not ctx (Z3.mk_eq ctx x y) in + let ( <<= ) x y = Z3.mk_le ctx x y in + let ( +++ ) x y = Z3.mk_add ctx [|x;y|] in + let row = Array.init n (fun i->mk_int_var ctx i) in + let c x = mk_int ctx x in (* make constant *) + let v x = row.(x) in (* make variable *) + let constraint_domain=forall_x ctx (0) (n-1) (fun x-> ((c 0) <<= (v x)) &&& ((v x) <<= (c (n-1)))) in + let constraint_queen= + forall_x ctx (0) (n-2) (fun i-> + forall_x ctx (i+1) (n-1) (fun j-> + ((v i) <~> (v j)) &&& + (((c i)+++(v i)) <~> ((c j)+++(v j))) &&& + (((c i)+++(v j)) <~> ((c j)+++(v i))) + ) + ) in + let res = constraint_domain &&& constraint_queen in + Z3.assert_cnstr ctx res; + let rec f i = + (match Z3.check_and_get_model ctx with + | (Z3.L_FALSE,_) -> + printf "queen %d, total models: %d\n" n i; + flush stdout; + | (Z3.L_UNDEF,_) -> failwith "Z3.L_UNDEF" + | (Z3.L_TRUE,model) -> + begin + let model_constants=Z3.get_model_constants ctx model in + let vars=Array.map (fun mc->Z3.mk_app ctx mc [||]) model_constants in + let vals=Array.map (fun mc->get_value ctx model mc |> get_numeral_value_int ctx) model_constants in + Z3.del_model ctx model; + + let line = String.make n '-' in + let q_line i = let r = String.make n ' ' in String.set r i 'Q'; r in + printf "queen %d, model #%d:\n" n (i+1); + printf "\n"; + printf " /%s\\\n" line; + iterate_x 0 (n-1) (fun x->printf " |%s|\n" (q_line (vals.(x)))); + printf " \\%s/\n" line; + printf "\n"; + flush stdout; + let negated_model = exist_x ctx 0 (n-1) (fun x->(vars.(x)) <~> (c (vals.(x)))) in + Z3.assert_cnstr ctx negated_model; + f (i+1); + end + ) in + f 0; + Z3.del_context ctx; + ();; + +let queen() = + for n = 1 to 8 do + queen_n n + done;; + +let _ = queen();; diff --git a/ml/queen.regress.err b/ml/queen.regress.err new file mode 100644 index 000000000..e69de29bb diff --git a/ml/queen.regress.out b/ml/queen.regress.out new file mode 100644 index 000000000..30e713386 --- /dev/null +++ b/ml/queen.regress.out @@ -0,0 +1,1852 @@ +queen 1, model #1: + + /-\ + |Q| + \-/ + +queen 1, total models: 1 +queen 2, total models: 0 +queen 3, total models: 0 +queen 4, model #1: + + /----\ + | Q | + | Q| + |Q | + | Q | + \----/ + +queen 4, model #2: + + /----\ + | Q | + |Q | + | Q| + | Q | + \----/ + +queen 4, total models: 2 +queen 5, model #1: + + /-----\ + | Q | + | Q | + |Q | + | Q | + | Q| + \-----/ + +queen 5, model #2: + + /-----\ + | Q | + | Q| + | Q | + |Q | + | Q | + \-----/ + +queen 5, model #3: + + /-----\ + | Q| + | Q | + |Q | + | Q | + | Q | + \-----/ + +queen 5, model #4: + + /-----\ + |Q | + | Q | + | Q | + | Q| + | Q | + \-----/ + +queen 5, model #5: + + /-----\ + | Q | + | Q| + | Q | + | Q | + |Q | + \-----/ + +queen 5, model #6: + + /-----\ + | Q | + |Q | + | Q | + | Q| + | Q | + \-----/ + +queen 5, model #7: + + /-----\ + | Q| + | Q | + | Q | + |Q | + | Q | + \-----/ + +queen 5, model #8: + + /-----\ + | Q | + | Q | + | Q| + | Q | + |Q | + \-----/ + +queen 5, model #9: + + /-----\ + |Q | + | Q | + | Q| + | Q | + | Q | + \-----/ + +queen 5, model #10: + + /-----\ + | Q | + |Q | + | Q | + | Q | + | Q| + \-----/ + +queen 5, total models: 10 +queen 6, model #1: + + /------\ + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + \------/ + +queen 6, model #2: + + /------\ + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + \------/ + +queen 6, model #3: + + /------\ + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + \------/ + +queen 6, model #4: + + /------\ + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + \------/ + +queen 6, total models: 4 +queen 7, model #1: + + /-------\ + | Q | + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + \-------/ + +queen 7, model #2: + + /-------\ + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + \-------/ + +queen 7, model #3: + + /-------\ + | Q | + | Q | + | Q| + | Q | + | Q | + | Q | + |Q | + \-------/ + +queen 7, model #4: + + /-------\ + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + | Q | + \-------/ + +queen 7, model #5: + + /-------\ + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + \-------/ + +queen 7, model #6: + + /-------\ + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + | Q | + \-------/ + +queen 7, model #7: + + /-------\ + | Q | + | Q| + | Q | + | Q | + | Q | + |Q | + | Q | + \-------/ + +queen 7, model #8: + + /-------\ + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + \-------/ + +queen 7, model #9: + + /-------\ + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + \-------/ + +queen 7, model #10: + + /-------\ + |Q | + | Q | + | Q | + | Q | + | Q | + | Q| + | Q | + \-------/ + +queen 7, model #11: + + /-------\ + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + \-------/ + +queen 7, model #12: + + /-------\ + |Q | + | Q | + | Q | + | Q | + | Q| + | Q | + | Q | + \-------/ + +queen 7, model #13: + + /-------\ + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + | Q | + \-------/ + +queen 7, model #14: + + /-------\ + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + | Q | + \-------/ + +queen 7, model #15: + + /-------\ + | Q | + |Q | + | Q | + | Q | + | Q | + | Q | + | Q| + \-------/ + +queen 7, model #16: + + /-------\ + | Q | + |Q | + | Q | + | Q | + | Q | + | Q| + | Q | + \-------/ + +queen 7, model #17: + + /-------\ + | Q | + |Q | + | Q | + | Q | + | Q | + | Q| + | Q | + \-------/ + +queen 7, model #18: + + /-------\ + | Q | + |Q | + | Q | + | Q | + | Q | + | Q| + | Q | + \-------/ + +queen 7, model #19: + + /-------\ + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + \-------/ + +queen 7, model #20: + + /-------\ + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + \-------/ + +queen 7, model #21: + + /-------\ + | Q | + |Q | + | Q | + | Q | + | Q | + | Q| + | Q | + \-------/ + +queen 7, model #22: + + /-------\ + | Q | + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + \-------/ + +queen 7, model #23: + + /-------\ + | Q | + | Q | + |Q | + | Q | + | Q | + | Q | + | Q| + \-------/ + +queen 7, model #24: + + /-------\ + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + | Q | + \-------/ + +queen 7, model #25: + + /-------\ + | Q| + | Q | + | Q | + | Q | + |Q | + | Q | + | Q | + \-------/ + +queen 7, model #26: + + /-------\ + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + \-------/ + +queen 7, model #27: + + /-------\ + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + \-------/ + +queen 7, model #28: + + /-------\ + | Q | + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + \-------/ + +queen 7, model #29: + + /-------\ + | Q| + | Q | + | Q | + | Q | + | Q | + |Q | + | Q | + \-------/ + +queen 7, model #30: + + /-------\ + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + \-------/ + +queen 7, model #31: + + /-------\ + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + \-------/ + +queen 7, model #32: + + /-------\ + | Q | + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + \-------/ + +queen 7, model #33: + + /-------\ + | Q | + | Q| + | Q | + | Q | + | Q | + |Q | + | Q | + \-------/ + +queen 7, model #34: + + /-------\ + | Q | + | Q| + | Q | + | Q | + | Q | + |Q | + | Q | + \-------/ + +queen 7, model #35: + + /-------\ + | Q | + | Q| + | Q | + | Q | + | Q | + |Q | + | Q | + \-------/ + +queen 7, model #36: + + /-------\ + | Q | + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + \-------/ + +queen 7, model #37: + + /-------\ + | Q | + | Q| + | Q | + | Q | + | Q | + | Q | + |Q | + \-------/ + +queen 7, model #38: + + /-------\ + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + \-------/ + +queen 7, model #39: + + /-------\ + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + | Q | + \-------/ + +queen 7, model #40: + + /-------\ + | Q | + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + \-------/ + +queen 7, total models: 40 +queen 8, model #1: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #2: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + \--------/ + +queen 8, model #3: + + /--------\ + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #4: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + \--------/ + +queen 8, model #5: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + \--------/ + +queen 8, model #6: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q | + | Q | + | Q | + | Q| + \--------/ + +queen 8, model #7: + + /--------\ + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #8: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + \--------/ + +queen 8, model #9: + + /--------\ + |Q | + | Q | + | Q | + | Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #10: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #11: + + /--------\ + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #12: + + /--------\ + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #13: + + /--------\ + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #14: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + \--------/ + +queen 8, model #15: + + /--------\ + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #16: + + /--------\ + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #17: + + /--------\ + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #18: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + \--------/ + +queen 8, model #19: + + /--------\ + | Q | + | Q | + | Q | + | Q| + | Q | + | Q | + | Q | + |Q | + \--------/ + +queen 8, model #20: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #21: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + \--------/ + +queen 8, model #22: + + /--------\ + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #23: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + \--------/ + +queen 8, model #24: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #25: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #26: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #27: + + /--------\ + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #28: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #29: + + /--------\ + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #30: + + /--------\ + | Q | + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + \--------/ + +queen 8, model #31: + + /--------\ + | Q| + | Q | + | Q | + | Q | + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #32: + + /--------\ + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #33: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + \--------/ + +queen 8, model #34: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q | + | Q| + |Q | + | Q | + \--------/ + +queen 8, model #35: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q | + | Q| + |Q | + | Q | + \--------/ + +queen 8, model #36: + + /--------\ + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #37: + + /--------\ + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #38: + + /--------\ + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #39: + + /--------\ + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #40: + + /--------\ + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #41: + + /--------\ + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #42: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #43: + + /--------\ + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #44: + + /--------\ + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #45: + + /--------\ + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #46: + + /--------\ + | Q | + | Q| + |Q | + | Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #47: + + /--------\ + | Q | + | Q| + |Q | + | Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #48: + + /--------\ + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #49: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + \--------/ + +queen 8, model #50: + + /--------\ + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #51: + + /--------\ + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #52: + + /--------\ + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #53: + + /--------\ + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #54: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #55: + + /--------\ + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #56: + + /--------\ + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #57: + + /--------\ + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #58: + + /--------\ + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #59: + + /--------\ + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #60: + + /--------\ + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #61: + + /--------\ + | Q | + |Q | + | Q| + | Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #62: + + /--------\ + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #63: + + /--------\ + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #64: + + /--------\ + | Q | + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + \--------/ + +queen 8, model #65: + + /--------\ + | Q | + | Q | + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #66: + + /--------\ + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #67: + + /--------\ + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #68: + + /--------\ + | Q | + |Q | + | Q| + | Q | + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #69: + + /--------\ + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #70: + + /--------\ + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #71: + + /--------\ + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #72: + + /--------\ + | Q | + | Q | + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #73: + + /--------\ + | Q | + | Q | + | Q | + | Q | + |Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #74: + + /--------\ + | Q | + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + \--------/ + +queen 8, model #75: + + /--------\ + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + \--------/ + +queen 8, model #76: + + /--------\ + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #77: + + /--------\ + |Q | + | Q | + | Q | + | Q| + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #78: + + /--------\ + | Q | + |Q | + | Q | + | Q| + | Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #79: + + /--------\ + | Q | + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + \--------/ + +queen 8, model #80: + + /--------\ + | Q | + | Q | + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + \--------/ + +queen 8, model #81: + + /--------\ + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #82: + + /--------\ + | Q | + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + \--------/ + +queen 8, model #83: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q | + |Q | + | Q| + | Q | + \--------/ + +queen 8, model #84: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q | + |Q | + | Q| + | Q | + \--------/ + +queen 8, model #85: + + /--------\ + | Q | + | Q | + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + \--------/ + +queen 8, model #86: + + /--------\ + | Q | + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #87: + + /--------\ + | Q | + | Q | + | Q | + | Q | + |Q | + | Q | + | Q| + | Q | + \--------/ + +queen 8, model #88: + + /--------\ + | Q | + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #89: + + /--------\ + | Q | + | Q| + | Q | + | Q | + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #90: + + /--------\ + | Q | + | Q | + | Q| + | Q | + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, model #91: + + /--------\ + | Q | + | Q | + | Q | + | Q | + |Q | + | Q | + | Q | + | Q| + \--------/ + +queen 8, model #92: + + /--------\ + | Q | + | Q | + | Q | + | Q| + |Q | + | Q | + | Q | + | Q | + \--------/ + +queen 8, total models: 92 diff --git a/ml/readme.txt b/ml/readme.txt new file mode 100644 index 000000000..71b2ab56d --- /dev/null +++ b/ml/readme.txt @@ -0,0 +1,144 @@ +Z3 - JakobL@2011-12-20 + +============================================================================== + +What: + +Z3 is a high-performance theorem prover being developed at Microsoft +Research by Nikolaj Bjørner (NBjorner) and Leonardo de Moura +(Leonardo). + +This folder contains the Z3 ML module used by the SLAM verification +engine. The Z3 ML module provides a complete ML interface to the Z3 +x86 native library. + +============================================================================== + +Multiple source depots: + +This folder is hosted in two separate source depots: +* SDT (sdport=BGIT-SDTVMDEPOT:5010): //depot/src/z3_2/ml/ +* SLAM (SDPort=BGIT-SDSLAM:7021): //depot/src/main/slam/engine/slam2/z3/ + +Goal is to have identical contents in both source depots. Reason for +hosting in SDT source depot: to allow for testing of the Z3 ML module +'close' to Z3. Reason for maintaining in SLAM source depot: to allow +for building SLAM without access to SDT. + +Discrepancy between usage and files in the two source depots are in +the following marked with [SDT] or [SLAM]. + +============================================================================== + +How to use the Z3 ML Module: + +* doc\index.html: Reference documentation of the ML interface. Notice: + This is generated during build and hence first available afterwards. + +* z3.mli: Provides the actual Z3 ML Signature, generated at build + time. The Reference documentation is built from this file. + +* test_mlapi.ml: Sample program that demonstrate how to use the Z3 ML library. + +* queen.ml: Sample program that demonstrate how to use the Z3 ML library. + +* import\z3.exe: Z3 shell: Useful for trying out queries. ([SDT]: in + %SDTROOT%\release_mt\z3.exe) + +============================================================================== + +Building and linking: + +Z3 ML is used as any other ML library. + +Prerequisites: + +* [SLAM]: Just a standard 'SDV Build Environment'. + +* [SDT]: NB. Make sure to use an x86 build window. + +1. Install OCaml: + * Install from: \\sdv-fs.ntdev.corp.microsoft.com\software\3rdParty\ocaml-3.07pl2-win-msvc.exe + Or from z3_2\tools + * Install to: C:\ocaml + +2. Install CamlIDL: + * Install from: \\sdv-fs.ntdev.corp.microsoft.com\software\Installers\camlidl-1.04-2.exe + Or from z3_2\tools + * Install to: C:\ocaml + +3. Build z3.sln's configuration 'release_mt': + cd %SDTROOT%\src\z3_2 + msbuild /target:lib /p:configuration=release_mt + msbuild /target:shell /p:configuration=release_mt + +To build and run regressions: +* [SLAM]: mb +* [SDT]: build + +To clean: +* [SLAM]: mc +* [SDT]: clean + +To link with your favorite app: +* [SLAM]: Reference z3.proj from your msbuild.proj file: + + +* [SDT]: Link the Z3 ML library as well as supporting libraries: + ocamlopt -ccopt "/MT /nologo /DWIN32" ole32.lib %OCAMLLIB%\libcamlidl.lib -I %SDTROOT%\src\z3_2\ml %SDTROOT%\src\z3_2\ml\z3.cmxa -o queen.exe queen.ml +============================================================================== + +Files: + +* readme.txt: This file +* build.cmd: Build script [SDT]: invoke directly; [SLAM]: invoked automatically +* clean.cmd: [SDT]: Script for cleaning; [SLAM]: use mc for cleaning +* regress.cmd: Script for updating regressions. Not for regular users. +* build.sed, update-ml-doc.cmd: Supporting scripts for building. +* diff.exe.exe: Supporting tool for building. Obtained from [SLAM] from //depot/src/main/tools/Win32/UnxUtils.zip. +* sed.exe: Supporting tool for building. Obtained from http://sed.sourceforge.net/ -> "super sed v3.59 for Windows by Paolo Bonzini" -> sed-3.59.zip -> sed-3.59.exe. See http://www.pement.org/sed/ for a good overview of sed for Windows. +* msbuild.proj: [SLAM only]: Used by mb and mc +* z3.proj: [SLAM only]: Project file for consumers of the Z3 module +* import.cmd: [SLAM only]: Script to import files from SDT. +* z3.idl,z3_api.idl: Interface definition files, z3_api.idl is autogenerated during build. +* z3.h: Supporting header file for z3.idl +* x3.{mli,ml}: Module X3 contains Z3 ML specific extensions. Do not use directly, included in Z3 during build. +* queen.ml: Z3 ML test program. +* test_mlapi.ml: Z3 ML test program. +* z3_theory_stubs.c and test_theory.ml: Theory plugin and test. + +*.regress.*: Regression files, used by build. + +[SLAM only]: +* import\z3lib.lib: Z3 C library. +* import\msbig_rational.lib: Supporting C library. +* import\test_capi.c: Z3 C test program. +* import\{z3.h,z3_api.h,z3_macros.h}: Z3 C header files. +* import\{mldoc_footer.html,tabs.css,test_mlapi_header.html,z3.png,z3_ml.css,z3_mlapi_header.html}: Files for automated documentation generation. + +============================================================================== + +Import from MSR: + +Certain files are imported from MSR. See above list for details as +well as import.cmd script. To determine the version of z3.exe you are +using, a bit of investigate work will lead you to exact build: + +Run import\z3.exe -version. This will generate: + Version (major minor build revision): 0 1 0 0 +Or: + Version (major minor build revision): 0 1 10828 7 + +The first example indicate a private drop imported with something like +'import.cmd J:\SD\other\sdt1\src\z3_2'. The second example indicate +drop 10828 from risebuild imported with something like 'import.cmd +\\risebuild\drops\z32\2.0.51220.7'. + +TODO: Update following: Look at +http://pexbuild3/ccnet/ViewFarmReport.aspx -> View All Builds -> +10828. This will give you the SD change number. Voila! + +============================================================================== + +Known issues: +* warning LNK4099: This message is shown when linking. Please ignore. diff --git a/ml/regress.cmd b/ml/regress.cmd new file mode 100644 index 000000000..be610a403 --- /dev/null +++ b/ml/regress.cmd @@ -0,0 +1,10 @@ +@echo off +call .\build.cmd +sd edit test_capi.regress.txt test_capi.regress.err test_mlapi.regress.txt test_mlapi.regress.err queen.regress.txt queen.regress.err +move test_capi.txt test_capi.regress.txt +move test_capi.err test_capi.regress.err +move test_mlapi.txt test_mlapi.regress.txt +move test_mlapi.err test_mlapi.regress.err +move queen.txt queen.regress.txt +move queen.err queen.regress.err +sd revert -a test_capi.regress.txt test_capi.regress.err test_mlapi.regress.txt test_mlapi.regress.err queen.regress.txt queen.regress.err diff --git a/ml/sed.exe b/ml/sed.exe new file mode 100644 index 000000000..75ffba78a Binary files /dev/null and b/ml/sed.exe differ diff --git a/ml/test_capi.regress.err b/ml/test_capi.regress.err new file mode 100644 index 000000000..0c383b409 --- /dev/null +++ b/ml/test_capi.regress.err @@ -0,0 +1,5 @@ +WARNING: invalid function application, sort mismatch on argument at position 1 +WARNING: (define iff Bool Bool Bool) applied to: +x of sort Int +y of sort Bool + diff --git a/ml/test_capi.regress.out b/ml/test_capi.regress.out new file mode 100644 index 000000000..4e173f7f6 --- /dev/null +++ b/ml/test_capi.regress.out @@ -0,0 +1,386 @@ +Z3 4.0.0.0 + +simple_example +CONTEXT: +(solver)END OF CONTEXT + +DeMorgan +DeMorgan is valid + +find_model_example1 +model for: x xor y +sat +y -> false +x -> true + + +find_model_example2 +model for: x < y + 1, x > 2 +sat +y -> 3 +x -> 3 + +model for: x < y + 1, x > 2, not(x = y) +sat +y -> 4 +x -> 3 + + +prove_example1 +prove: x = y implies g(x) = g(y) +valid +disprove: x = y implies g(g(x)) = g(y) +invalid +counterexample: +y -> U!val!0 +x -> U!val!0 +g -> { + U!val!0 -> U!val!1 + U!val!1 -> U!val!2 + else -> U!val!1 +} + + +prove_example2 +prove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < 0 +valid +disprove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < -1 +invalid +counterexample: +z -> -1 +y -> -7719 +x -> -7719 +g -> { + -7719 -> 0 + 0 -> 2 + -1 -> 3 + else -> 0 +} + + +push_pop_example1 +assert: x >= 'big number' +push +number of scopes: 1 +assert: x <= 3 +unsat +pop +number of scopes: 0 +sat +x = 1000000000000000000000000000000000000000000000000000000:int +function interpretations: +assert: y > x +sat +y = 1000000000000000000000000000000000000000000000000000001:int +x = 1000000000000000000000000000000000000000000000000000000:int +function interpretations: + +quantifier_example1 +pattern: {(f #0 #1)} + +assert axiom: +(forall (k!0 Int) (k!1 Int) (= (inv!0 (f k!1 k!0)) k!0) :pat {(f k!1 k!0)}) +prove: f(x, y) = f(w, v) implies y = v +valid +disprove: f(x, y) = f(w, v) implies x = w +that is: not(f(x, y) = f(w, v) implies x = w) is satisfiable +unknown +potential model: +w = 2:int +v = 1:int +y = 1:int +x = 0:int +function interpretations: +f = {(else|->(define f!52 Int Int Int)[(define k!50 Int Int)[#unknown], (define k!51 Int Int)[#unknown]])} +#51 = {(2:int|->2:int), (1:int|->1:int), (15:int|->15:int), (11:int|->11:int), (0:int|->0:int), (19:int|->19:int), (else|->2:int)} +f!52 = {(0:int, 1:int|->3:int), (2:int, 1:int|->3:int), (0:int, 0:int|->4:int), (2:int, 0:int|->5:int), (6:int, 2:int|->7:int), (2:int, 2:int|->8:int), (0:int, 2:int|->9:int), (6:int, 0:int|->10:int), (0:int, 11:int|->12:int), (2:int, 11:int|->13:int), (6:int, 11:int|->14:int), (0:int, 15:int|->16:int), (2:int, 15:int|->17:int), (6:int, 15:int|->18:int), (0:int, 19:int|->20:int), (6:int, 19:int|->21:int), (2:int, 19:int|->22:int), (else|->3:int)} +inv!0 = {(3:int|->1:int), (4:int|->0:int), (5:int|->0:int), (7:int|->2:int), (8:int|->2:int), (9:int|->2:int), (10:int|->0:int), (12:int|->11:int), (13:int|->11:int), (14:int|->11:int), (16:int|->15:int), (17:int|->15:int), (18:int|->15:int), (20:int|->19:int), (21:int|->19:int), (22:int|->19:int), (else|->2:int)} +#50 = {(2:int|->2:int), (6:int|->6:int), (0:int|->0:int), (else|->2:int)} +reason for last failure: 7 (7 = quantifiers) + +array_example1 +prove: store(a1, i1, v1) = store(a2, i2, v2) implies (i1 = i3 or i2 = i3 or select(a1, i3) = select(a2, i3)) +(implies (= (store a1 i1 v1) (store a2 i2 v2)) + (or (= i1 i3) (= i2 i3) (= (select a1 i3) (select a2 i3)))) +valid + +array_example2 +n = 2 +(distinct k!0 k!1) +sat +#0 = (define as-array[k!0] (Array Bool Bool)) +#1 = (define as-array[k!1] (Array Bool Bool)) +function interpretations: +#0 = {((define false Bool)|->(define true Bool)), (else|->(define true Bool))} +#1 = {((define false Bool)|->(define false Bool)), (else|->(define false Bool))} +n = 3 +(distinct k!0 k!1 k!2) +sat +#0 = (define as-array[k!0] (Array Bool Bool)) +#1 = (define as-array[k!1] (Array Bool Bool)) +#2 = (define as-array[k!2] (Array Bool Bool)) +function interpretations: +#0 = {((define true Bool)|->(define true Bool)), ((define false Bool)|->(define false Bool)), (else|->(define true Bool))} +#1 = {((define false Bool)|->(define true Bool)), (else|->(define true Bool))} +#2 = {((define true Bool)|->(define false Bool)), ((define false Bool)|->(define false Bool)), (else|->(define false Bool))} +n = 4 +(distinct k!0 k!1 k!2 k!3) +sat +#0 = (define as-array[k!0] (Array Bool Bool)) +#1 = (define as-array[k!1] (Array Bool Bool)) +#2 = (define as-array[k!2] (Array Bool Bool)) +#3 = (define as-array[k!3] (Array Bool Bool)) +function interpretations: +#0 = {((define true Bool)|->(define false Bool)), ((define false Bool)|->(define true Bool)), (else|->(define false Bool))} +#1 = {((define true Bool)|->(define true Bool)), ((define false Bool)|->(define false Bool)), (else|->(define true Bool))} +#2 = {((define true Bool)|->(define true Bool)), ((define false Bool)|->(define true Bool)), (else|->(define true Bool))} +#3 = {((define true Bool)|->(define false Bool)), ((define false Bool)|->(define false Bool)), (else|->(define false Bool))} +n = 5 +(distinct k!0 k!1 k!2 k!3 k!4) +unsat + +array_example3 +domain: int +range: bool + +tuple_example1 +tuple_sort: (real, real) +prove: get_x(mk_pair(x, y)) = 1 implies x = 1 +valid +disprove: get_x(mk_pair(x, y)) = 1 implies y = 1 +invalid +counterexample: +y -> 0 +x -> 1 + +prove: get_x(p1) = get_x(p2) and get_y(p1) = get_y(p2) implies p1 = p2 +valid +disprove: get_x(p1) = get_x(p2) implies p1 = p2 +invalid +counterexample: +p1 -> (mk_pair 1 0) +p2 -> (mk_pair 1 2) + +prove: p2 = update(p1, 0, 10) implies get_x(p2) = 10 +valid +disprove: p2 = update(p1, 0, 10) implies get_y(p2) = 10 +invalid +counterexample: +p2 -> (mk_pair 10 1) +p1 -> (mk_pair 0 1) + + +bitvector_example1 +disprove: x - 10 <= 0 IFF x <= 10 for (32-bit) machine integers +invalid +counterexample: +x -> bv2147483656[32] + + +bitvector_example2 +find values of x and y, such that x ^ y - 103 == x * y +sat +y -> bv3905735879[32] +x -> bv3787456528[32] + + +eval_example1 +MODEL: +y -> 4 +x -> 3 + +evaluating x+y +result = 7:int + +two_contexts_example1 +k!0 + +error_code_example1 +last call succeeded. +last call failed. + +error_code_example2 +before Z3_mk_iff +Z3 error: type error. + +parser_example1 +formula 0: (> x y) +formula 1: (> x 0) +sat +y -> 0 +x -> 1 + + +parser_example2 +formula: (> x y) +sat +y -> -1 +x -> 0 + + +parser_example3 +assert axiom: +(forall (x Int) (y Int) (= (g x y) (g y x)) :qid {k!1}) +formula: (forall (x Int) (y Int) (implies (= x y) (= (g x 0) (g 0 y))) :qid {k!1}) +valid + +parser_example4 +declaration 0: (define y Int) +declaration 1: (define sk_hack Bool Bool) +declaration 2: (define x Int) +assumption 0: (= x 20) +formula 0: (> x y) +formula 1: (> x 0) + +parser_example5 +Z3 error: parser error. +Error message: 'ERROR: line 1 column 41: could not find sort symbol 'y'. +'. + +numeral_example +Numerals n1:1/2 n2:1/2 +valid +Numerals n1:-1/3 n2:-33333333333333333333333333333333333333333333333333/100000000000000000000000000000000000000000000000000 +valid + +ite_example +term: (if false 1 0) + +list_example +valid +valid +valid +valid +valid +valid +valid +Formula (implies (is_cons u) (= u (cons (head u) (tail u)))) +valid +invalid +counterexample: +u -> nil + + +tree_example +valid +valid +valid +valid +valid +Formula (implies (is_cons u) (= u (cons (car u) (cdr u)))) +valid +invalid +counterexample: +u -> nil + + +forest_example +valid +valid +valid +valid +valid +valid + +binary_tree_example +valid +valid +valid +valid +valid + +enum_example +(define apple[fruit:0] fruit) +(define banana[fruit:1] fruit) +(define orange[fruit:2] fruit) +(define is_apple[fruit:0] fruit Bool) +(define is_banana[fruit:1] fruit Bool) +(define is_orange[fruit:2] fruit Bool) +valid +valid +invalid +counterexample: + +valid +valid + +unsat_core_and_proof_example +unsat +proof: [unit-resolution + [def-axiom (or (or (not PredA) PredB (not PredC)) (not PredB))] + [unit-resolution + [def-axiom (or (or (not PredA) (not PredB) (not PredC)) PredB)] + [unit-resolution + [mp + [asserted (or (and PredA PredB PredC) P1)] + [monotonicity + [rewrite + (iff (and PredA PredB PredC) + (not (or (not PredA) (not PredB) (not PredC))))] + (iff (or (and PredA PredB PredC) P1) + (or (not (or (not PredA) (not PredB) (not PredC))) P1))] + (or (not (or (not PredA) (not PredB) (not PredC))) P1)] + [asserted (not P1)] + (not (or (not PredA) (not PredB) (not PredC)))] + PredB] + [unit-resolution + [mp + [asserted (or (and PredA (not PredB) PredC) P2)] + [monotonicity + [rewrite + (iff (and PredA (not PredB) PredC) + (not (or (not PredA) PredB (not PredC))))] + (iff (or (and PredA (not PredB) PredC) P2) + (or (not (or (not PredA) PredB (not PredC))) P2))] + (or (not (or (not PredA) PredB (not PredC))) P2)] + [asserted (not P2)] + (not (or (not PredA) PredB (not PredC)))] + false] + +core: +(not P1) +(not P2) + + +get_implied_equalities example +Class a |-> 0 +Class b |-> 0 +Class c |-> 0 +Class d |-> 3 +Class (f a) |-> 0 +Class (f b) |-> 0 +Class (f c) |-> 0 +asserting f(a) <= b +Class a |-> 0 +Class b |-> 0 +Class c |-> 0 +Class d |-> 3 +Class (f a) |-> 0 +Class (f b) |-> 0 +Class (f c) |-> 0 + +incremental_example1 +unsat core: 0 2 3 +unsat +sat +unsat core: 0 2 3 +unsat +unsat core: 0 2 3 +unsat +sat + +reference_counter_example +model for: x xor y +sat +y -> false +x -> true + + +smt2parser_example +formulas: (and (bvuge a bv16[8]) (bvule a bv240[8])) + +substitute_example +substitution result: (f (f a 0) 1) + +substitute_vars_example +substitution result: (f (f a (g b)) a) diff --git a/ml/test_mlapi.cmd b/ml/test_mlapi.cmd new file mode 100644 index 000000000..3d538a9df --- /dev/null +++ b/ml/test_mlapi.cmd @@ -0,0 +1,58 @@ +@echo off +SETLOCAL + +REM Script to test the Z3 OCaml API + +REM directory containing z3_api.h +set Z3SRC=%1 + +REM directory containing z3.dll and z3.lib +set Z3BIN=%2 + +REM directory containing debug z3.dll +set Z3BINDBG=%3 + +set PATH=.;%2;%3;%PATH% + +echo Build test_capi +cl /nologo /I %Z3SRC% %Z3BIN%\z3.lib ..\test_capi\test_capi.c + +echo Build test_mlapi +ocamlc -w -a -o test_mlapi.byte.exe z3.cma test_mlapi.ml +ocamlopt -w -a -o test_mlapi.exe z3.cmxa test_mlapi.ml +ocamlc -g -w -a -o test_mlapi.byte.dbg.exe z3_dbg.cma test_mlapi.ml +ocamlopt -g -w -a -o test_mlapi.dbg.exe z3_dbg.cmxa test_mlapi.ml + +echo Build test_mlapiV3 +ocamlopt -g -w -a -o test_mlapiV3.dbg.exe z3_dbg.cmxa test_mlapiV3.ml + +echo Build test_theory +ocamlopt -g -w -a -o test_theory.dbg.exe z3_dbg.cmxa test_theory.ml + +echo Build queen +ocamlopt -g -w -a -o queen.exe z3_dbg.cmxa queen.ml + +echo Execute test_capi, test_mlapi, test_mlapiV3 and queen +test_capi.exe >test_capi.out 2>test_capi.orig.err +test_mlapi.dbg.exe >test_mlapi.out 2>test_mlapi.orig.err +test_mlapiV3.dbg.exe >test_mlapiV3.out 2>test_mlapiV3.orig.err +queen.exe >queen.out 2>queen.orig.err + +REM Strip pointers as they will always differ +sed test_capi.err "s/ \[.*\]/ [...]/g" +sed test_mlapi.err "s/ \[.*\]/ [...]/g" +sed test_mlapiV3.err "s/ \[.*\]/ [...]/g" +sed queen.err "s/ \[.*\]/ [...]/g" +del test_capi.orig.err test_mlapi.orig.err test_mlapiV3.orig.err queen.orig.err + +REM Compare with regressions +diff test_capi.regress.out test_capi.out >NUL || echo Regression failed, see: windiff test_capi.regress.out test_capi.out +diff test_mlapi.regress.out test_mlapi.out >NUL || echo Regression failed, see: windiff test_mlapi.regress.out test_mlapi.out +diff test_mlapiV3.regress.out test_mlapiV3.out >NUL || echo Regression failed, see: windiff test_mlapiV3.regress.out test_mlapiV3.out +diff test_capi.regress.err test_capi.err >NUL || echo Regression failed, see: windiff test_capi.regress.err test_capi.err +diff test_mlapi.regress.err test_mlapi.err >NUL || echo Regression failed, see: windiff test_mlapi.regress.err test_mlapi.err +diff test_mlapiV3.regress.err test_mlapiV3.err >NUL || echo Regression failed, see: windiff test_mlapiV3.regress.err test_mlapiV3.err +diff queen.regress.out queen.out >NUL || echo Regression failed, see: windiff queen.regress.out queen.out +diff queen.regress.err queen.err >NUL || echo Regression failed, see: windiff queen.regress.err queen.err + +ENDLOCAL diff --git a/ml/test_mlapi.ml b/ml/test_mlapi.ml new file mode 100644 index 000000000..149ae27f8 --- /dev/null +++ b/ml/test_mlapi.ml @@ -0,0 +1,209 @@ +(** Examples of using the OCaml API for Z3. *) + +(**/**) +(* pause documentation *) + +(* + @name Auxiliary Functions +*) + +(** + printf +*) +let printf = Printf.printf +;; + +(** + fprintf +*) +let fprintf = Printf.fprintf +;; + +(** + Exit gracefully in case of error. +*) +let exitf message = fprintf stderr "BUG: %s.\n" message ; exit 1 +;; + +(** + Create and print datatypes +*) +let mk_datatypes ctx generator = + let datatypes = Z3.mk_datatypes ctx generator in + printf "datatype created:\n%!" ; + Array.iter (fun (sort, ctors) -> + printf "sort: %s\n%!" (Z3.sort_to_string ctx sort) ; + Array.iter (fun {Z3.constructor; recognizer; accessors} -> + printf "constructor: %s%! recognizer: %s%! accessors:" + (Z3.func_decl_to_string ctx constructor) + (Z3.func_decl_to_string ctx recognizer) ; + Array.iter (fun accessor -> + printf " %s%!" (Z3.func_decl_to_string ctx accessor) + ) accessors ; + printf "\n" + ) ctors + ) datatypes ; + printf "\n" ; + datatypes +;; + + +(** + Create a variable using the given name and type. +*) +let mk_var ctx name ty = Z3.mk_const ctx (Z3.mk_string_symbol ctx name) ty +;; + +(* resume documentation *) +(**/**) + + +(** + Prove that the constraints already asserted into the logical + context implies the given formula. The result of the proof is + displayed. + Z3 is a satisfiability checker. So, one can prove {e f } by showing + that {e (not f) } is unsatisfiable. + The context {e ctx } is not modified by this function. +*) +let prove ctx slv f is_valid = + (* save the current state of the context *) + Z3.solver_push ctx slv ; + + let not_f = Z3.mk_not ctx f in + Z3.solver_assert ctx slv not_f ; + + (match Z3.solver_check ctx slv with + | Z3.L_FALSE -> + (* proved *) + printf "valid\n" ; + if not is_valid then exitf "unexpected result" + | Z3.L_UNDEF -> + (* Z3 failed to prove/disprove f. *) + printf "unknown\n" ; + let m = Z3.solver_get_model ctx slv in + (* m should be viewed as a potential counterexample. *) + printf "potential counterexample:\n%s\n" (Z3.model_to_string ctx m) ; + if is_valid then exitf "unexpected result" + | Z3.L_TRUE -> + (* disproved *) + printf "invalid\n" ; + let m = Z3.solver_get_model ctx slv in + (* the model returned by Z3 is a counterexample *) + printf "counterexample:\n%s\n" (Z3.model_to_string ctx m) ; + if is_valid then exitf "unexpected result" + ); + (* restore context *) + Z3.solver_pop ctx slv 1 +;; + + +(* n-ary trees and forests in OCaml *) +type tree = Leaf of int | Node of forest +and forest = tree list + +(** + Demonstrates the usage of {!Z3.mk_datatypes} with an example of forests of trees. +*) +let forest_example () = + let ctx = Z3.mk_context [] in + let slv = Z3.mk_solver ctx + in + let int_sort = Z3.mk_int_sort ctx in + let sym name = Z3.mk_string_symbol ctx name + in + (* n-ary trees and forests in Z3 *) + match + mk_datatypes ctx + (function [|tree; forest|] -> Some + [|(sym"tree", + [|{Z3.constructor_desc= sym"leaf"; recognizer_desc= sym"is_leaf"; accessor_descs= [|(sym"data", int_sort)|]}; + {Z3.constructor_desc= sym"node"; recognizer_desc= sym"is_node"; accessor_descs= [|(sym"children", forest)|]}|]); + (sym"forest", + [|{Z3.constructor_desc= sym"nil" ; recognizer_desc= sym"is_nil" ; accessor_descs= [||]}; + {Z3.constructor_desc= sym"cons"; recognizer_desc= sym"is_cons"; accessor_descs= [|(sym"hd", tree); (sym"tl", forest)|]}|])|] + | _ -> None + ) + with + [|(tree, + [|{Z3.constructor= leaf; recognizer= is_leaf; accessors= [|data|]}; + {Z3.constructor= node; recognizer= is_node; accessors= [|children|]}|]); + (forest, + [|{Z3.constructor= nil ; recognizer= is_nil ; accessors= [||]}; + {Z3.constructor= cons; recognizer= is_cons; accessors= [|hd; tl|]}|])|] + -> + (* translate from OCaml to Z3 *) + let rec ml2z3_tree = function + | Leaf(i) -> Z3.mk_app ctx leaf [|Z3.mk_int ctx i (Z3.mk_int_sort ctx)|] + | Node(f) -> Z3.mk_app ctx node [|ml2z3_forest f|] + + and ml2z3_forest = function + | [] -> Z3.mk_app ctx nil [||] + | t :: f -> Z3.mk_app ctx cons [|ml2z3_tree t; ml2z3_forest f|] + in + + (* construct some OCaml trees *) + let t0 = Leaf 0 in + let t12 = Node [Leaf 1; Leaf 2] in + let t123 = Node [t12; Leaf 3] in + let t1212 = Node [t12; t12] in + let t412 = Node [Leaf 4; t12] in + + (* construct some Z3 trees using the translation from OCaml *) + let t1 = ml2z3_tree t12 in printf "t1: %s\n%!" (Z3.ast_to_string ctx t1) ; + let t2 = ml2z3_tree t123 in printf "t2: %s\n%!" (Z3.ast_to_string ctx t2) ; + let t3 = ml2z3_tree t1212 in printf "t3: %s\n%!" (Z3.ast_to_string ctx t3) ; + let t4 = ml2z3_tree t412 in printf "t4: %s\n%!" (Z3.ast_to_string ctx t4) ; + let f1 = ml2z3_forest [t0] in printf "f1: %s\n%!" (Z3.ast_to_string ctx f1) ; + let f2 = ml2z3_forest [t12] in printf "f2: %s\n%!" (Z3.ast_to_string ctx f2) ; + let f3 = ml2z3_forest [t12; t0] in printf "f3: %s\n%!" (Z3.ast_to_string ctx f3) ; + + (* or using the Z3 API *) + let nil = Z3.mk_app ctx nil [||] in + let cons t f = Z3.mk_app ctx cons [|t; f|] in + let leaf i = Z3.mk_app ctx leaf [|Z3.mk_int ctx i (Z3.mk_int_sort ctx)|] in + let node f = Z3.mk_app ctx node [|f|] in + + let t0 = leaf 0 in + let t12 = node (cons (leaf 1) (cons (leaf 2) nil)) in + let t123 = node (cons t12 (cons (leaf 3) nil)) in + let t1212 = node (cons t12 (cons t12 nil)) in + let t412 = node (cons (leaf 4) (cons t12 nil)) in + + let t1 = t12 in printf "t1: %s\n%!" (Z3.ast_to_string ctx t1) ; + let t2 = t123 in printf "t2: %s\n%!" (Z3.ast_to_string ctx t2) ; + let t3 = t1212 in printf "t3: %s\n%!" (Z3.ast_to_string ctx t3) ; + let t4 = t412 in printf "t4: %s\n%!" (Z3.ast_to_string ctx t4) ; + let f1 = cons t0 nil in printf "f1: %s\n%!" (Z3.ast_to_string ctx f1) ; + let f2 = cons t12 nil in printf "f2: %s\n%!" (Z3.ast_to_string ctx f2) ; + let f3 = cons t12 f1 in printf "f3: %s\n%!" (Z3.ast_to_string ctx f3) ; + + (* nil != cons(nil,nil) *) + prove ctx slv (Z3.mk_not ctx (Z3.mk_eq ctx nil f1)) true ; + prove ctx slv (Z3.mk_not ctx (Z3.mk_eq ctx (leaf 5) t1)) true ; + + (* cons(x,u) = cons(x, v) => u = v *) + let u = mk_var ctx "u" forest in + let v = mk_var ctx "v" forest in + let x = mk_var ctx "x" tree in + let y = mk_var ctx "y" tree in + let l1 = cons x u in printf "l1: %s\n%!" (Z3.ast_to_string ctx l1) ; + let l2 = cons y v in printf "l2: %s\n%!" (Z3.ast_to_string ctx l2) ; + + prove ctx slv (Z3.mk_implies ctx (Z3.mk_eq ctx l1 l2) (Z3.mk_eq ctx u v)) true ; + prove ctx slv (Z3.mk_implies ctx (Z3.mk_eq ctx l1 l2) (Z3.mk_eq ctx x y)) true ; + + (* is_nil(u) or is_cons(u) *) + prove ctx slv (Z3.mk_or ctx [|Z3.mk_app ctx is_nil [|u|]; Z3.mk_app ctx is_cons [|u|]|]) true ; + + (* occurs check u != cons(x,u) *) + prove ctx slv (Z3.mk_not ctx (Z3.mk_eq ctx u l1)) true ; + + | _ -> + exitf "unexpected datatype signature" +;; + +let _ = + ignore( Z3.open_log "test_mlapi.log" ); + forest_example () ; +;; diff --git a/ml/test_mlapi.regress.err b/ml/test_mlapi.regress.err new file mode 100644 index 000000000..e69de29bb diff --git a/ml/test_mlapi.regress.out b/ml/test_mlapi.regress.out new file mode 100644 index 000000000..1fb6289c7 --- /dev/null +++ b/ml/test_mlapi.regress.out @@ -0,0 +1,32 @@ +datatype created: +sort: tree +constructor: (define leaf[tree:0] Int tree) recognizer: (define is_leaf[tree:0] tree Bool) accessors: (define data[tree:0:0] tree Int) +constructor: (define node[tree:1] forest tree) recognizer: (define is_node[tree:1] tree Bool) accessors: (define children[tree:1:0] tree forest) +sort: forest +constructor: (define nil[forest:0] forest) recognizer: (define is_nil[forest:0] forest Bool) accessors: +constructor: (define cons[forest:1] tree forest forest) recognizer: (define is_cons[forest:1] forest Bool) accessors: (define hd[forest:1:0] forest tree) (define tl[forest:1:1] forest forest) + +t1: (node (cons (leaf 1) (cons (leaf 2) nil))) +t2: (node (cons (node (cons (leaf 1) (cons (leaf 2) nil))) (cons (leaf 3) nil))) +t3: (node (cons (node (cons (leaf 1) (cons (leaf 2) nil))) + (cons (node (cons (leaf 1) (cons (leaf 2) nil))) nil))) +t4: (node (cons (leaf 4) (cons (node (cons (leaf 1) (cons (leaf 2) nil))) nil))) +f1: (cons (leaf 0) nil) +f2: (cons (node (cons (leaf 1) (cons (leaf 2) nil))) nil) +f3: (cons (node (cons (leaf 1) (cons (leaf 2) nil))) (cons (leaf 0) nil)) +t1: (node (cons (leaf 1) (cons (leaf 2) nil))) +t2: (node (cons (node (cons (leaf 1) (cons (leaf 2) nil))) (cons (leaf 3) nil))) +t3: (node (cons (node (cons (leaf 1) (cons (leaf 2) nil))) + (cons (node (cons (leaf 1) (cons (leaf 2) nil))) nil))) +t4: (node (cons (leaf 4) (cons (node (cons (leaf 1) (cons (leaf 2) nil))) nil))) +f1: (cons (leaf 0) nil) +f2: (cons (node (cons (leaf 1) (cons (leaf 2) nil))) nil) +f3: (cons (node (cons (leaf 1) (cons (leaf 2) nil))) (cons (leaf 0) nil)) +valid +valid +l1: (cons x u) +l2: (cons y v) +valid +valid +valid +valid diff --git a/ml/test_mlapiV3.ml b/ml/test_mlapiV3.ml new file mode 100644 index 000000000..a88d13000 --- /dev/null +++ b/ml/test_mlapiV3.ml @@ -0,0 +1,1418 @@ +(** Module test_mlapi - ML test and demo program for Z3. Matches test_capi.ml - JakobL@2007-09-08 *) + +module Z3 = Z3.V3 + +(* + @name Auxiliary Functions +*) + +(** + printf +*) +let printf = Printf.printf;; + +(** + fprintf +*) +let fprintf = Printf.fprintf;; + +(** + Exit gracefully in case of error. +*) +let exitf message = fprintf stderr "BUG: %s.\n" message; exit 1;; + +(** + Create a logical context. Enable model construction. + Also enable tracing to stderr. +*) +let mk_context ctx = + let ctx = Z3.mk_context_x (Array.append [|("MODEL", "true")|] ctx) in + (* You may comment out the following line to disable tracing: *) + (* Z3.trace_to_stderr ctx; *) + ctx;; + +(** + Create a variable using the given name and type. +*) +let mk_var ctx name ty = Z3.mk_const ctx (Z3.mk_string_symbol ctx name) ty;; + +(** + Create a boolean variable using the given name. +*) +let mk_bool_var ctx name = mk_var ctx name (Z3.mk_bool_sort ctx);; + +(** + Create an integer variable using the given name. +*) +let mk_int_var ctx name = mk_var ctx name (Z3.mk_int_sort ctx);; + +(** + Create a Z3 integer node using a C int. +*) +let mk_int ctx v = Z3.mk_int ctx v (Z3.mk_int_sort ctx);; + +(** + Create a real variable using the given name. +*) +let mk_real_var ctx name = mk_var ctx name (Z3.mk_real_sort ctx);; + +(** + Create the unary function application: {e (f x) }. +*) +let mk_unary_app ctx f x = Z3.mk_app ctx f [|x|];; + +(** + Create the binary function application: {e (f x y) }. +*) +let mk_binary_app ctx f x y = Z3.mk_app ctx f [|x;y|];; + +(** + Auxiliary function to check whether two Z3 types are equal or not. +*) +let equal_sorts ctx t1 t2 = Z3.is_eq_sort ctx t1 t2;; + +(** + Check whether the logical context is satisfiable, and compare the result with the expected result. + If the context is satisfiable, then display the model. +*) +let check ctx expected_result = + begin + let (result, m) = Z3.check_and_get_model ctx in + (match result with + | Z3.L_FALSE -> printf "unsat\n"; + | Z3.L_UNDEF -> + printf "unknown\n"; + printf "potential model:\n%s\n" (Z3.model_to_string ctx m); + (Z3.del_model ctx m); + | Z3.L_TRUE -> printf "sat\n%s\n" (Z3.model_to_string ctx m); + (Z3.del_model ctx m); + ); + if result != expected_result then exitf "unexpected result"; + end;; + +(** + Prove that the constraints already asserted into the logical + context implies the given formula. The result of the proof is + displayed. + Z3 is a satisfiability checker. So, one can prove {e f } by showing + that {e (not f) } is unsatisfiable. + The context {e ctx } is not modified by this function. +*) +let prove ctx f is_valid = + begin + (* save the current state of the context *) + Z3.push ctx; + + let not_f = Z3.mk_not ctx f in + Z3.assert_cnstr ctx not_f; + + (match Z3.check_and_get_model ctx with + | (Z3.L_FALSE,_) -> + (* proved *) + printf "valid\n"; + if not is_valid then exitf "unexpected result"; + | (Z3.L_UNDEF,m) -> + (* Z3 failed to prove/disprove f. *) + printf "unknown\n"; + (* m should be viewed as a potential counterexample. *) + printf "potential counterexample:\n%s\n" (Z3.model_to_string ctx m); + if is_valid then exitf "unexpected result"; + (Z3.del_model ctx m); + | (Z3.L_TRUE,m) -> + (* disproved *) + printf "invalid\n"; + (* the model returned by Z3 is a counterexample *) + printf "counterexample:\n%s\n" (Z3.model_to_string ctx m); + if is_valid then exitf "unexpected result"; + (Z3.del_model ctx m); + ); + (* restore context *) + Z3.pop ctx 1; + end;; + +(** + Assert the axiom: function f is injective in the i-th argument. + + The following axiom is asserted into the logical context: + + forall (x_1, ..., x_n) finv(f(x_1, ..., x_i, ..., x_n)) = x_i + + Where, {e finv } is a fresh function declaration. +*) +let assert_inj_axiom ctx f i = + begin + let sz = Z3.get_domain_size ctx f in + if i >= sz then exitf "failed to create inj axiom"; + + (* declare the i-th inverse of f: finv *) + let finv_domain = Z3.get_range ctx f in + let finv_range = Z3.get_domain ctx f i in + let finv = Z3.mk_fresh_func_decl ctx "inv" [|finv_domain|] finv_range in + + (* allocate temporary arrays *) + (* fill types, names and xs *) + let types = Z3.get_domains ctx f in + let names = Array.init sz (Z3.mk_int_symbol ctx) in + let xs = Array.init sz (fun j->Z3.mk_bound ctx j (types.(j))) in + + (* create f(x_0, ..., x_i, ..., x_{n-1}) *) + let fxs = Z3.mk_app ctx f xs in + + (* create f_inv(f(x_0, ..., x_i, ..., x_{n-1})) *) + let finv_fxs = mk_unary_app ctx finv fxs in + + (* create finv(f(x_0, ..., x_i, ..., x_{n-1})) = x_i *) + let eq = Z3.mk_eq ctx finv_fxs (xs.(i)) in + + (* use f(x_0, ..., x_i, ..., x_{n-1}) as the pattern for the quantifier *) + let p = Z3.mk_pattern ctx [|fxs|] in + printf "pattern: %s\n" (Z3.pattern_to_string ctx p); + printf "\n"; + + (* create & assert quantifier *) + let q = Z3.mk_forall ctx + 0 (* using default weight *) + [|p|] (* the "array" of patterns *) + types + names + eq + in + printf "assert axiom:\n%s\n" (Z3.ast_to_string ctx q); + Z3.assert_cnstr ctx q; + end;; + +(** + Assert the axiom: function f is commutative. + + This example uses the SMT-LIB parser to simplify the axiom construction. +*) +let assert_comm_axiom ctx f = + begin + let t = Z3.get_range ctx f in + if Z3.get_domain_size ctx f != 2 || not (equal_sorts ctx (Z3.get_domain ctx f 0) t) || not (equal_sorts ctx (Z3.get_domain ctx f 1) t) then + exitf "function must be binary, and argument types must be equal to return type"; + (* Inside the parser, function f will be referenced using the symbol 'f'. *) + let f_name = Z3.mk_string_symbol ctx "f" in + (* Inside the parser, type t will be referenced using the symbol 'T'. *) + let t_name = Z3.mk_string_symbol ctx "T" in + let str = "(benchmark comm :formula (forall (x T) (y T) (= (f x y) (f y x))))" in + let q = Z3.parse_smtlib_string_formula ctx str [|t_name|] [|t|] [|f_name|] [|f|] in + printf "assert axiom:\n%s\n" (Z3.ast_to_string ctx q); + Z3.assert_cnstr ctx q; + end;; + +(** + Z3 does not support explicitly tuple updates. They can be easily implemented + as macros. The argument {e t } must have tuple type. + A tuple update is a new tuple where field {e i } has value {e new_val }, and all + other fields have the value of the respective field of {e t }. + + {e update(t, i, new_val) } is equivalent to + {e mk_tuple(proj_0(t), ..., new_val, ..., proj_n(t)) } +*) +let mk_tuple_update c t i new_val = + begin + let ty = Z3.get_sort c t in + let (mk_tuple_decl,fields)=Z3.get_tuple_sort c ty in + if i>=Array.length fields then exitf "invalid tuple update, index is too big"; + let f j = + if i = j then (* use new_val at position i: *) new_val + else (* use field j of t: *) (mk_unary_app c (fields.(j)) t) + in let new_fields = Array.init (Array.length fields) f in + Z3.mk_app c (Z3.get_tuple_sort_mk_decl c ty) new_fields; + end;; + +(** + Display a symbol in the given output stream. +*) +let display_symbol c out s = + match Z3.symbol_refine c s with + | Z3.Symbol_int i -> fprintf out "#%d" i; + | Z3.Symbol_string r ->fprintf out "%s" r; + | Z3.Symbol_unknown -> ();; + +(** + Display the given type. +*) +let rec display_sort c out ty = + begin + match Z3.sort_refine c ty with + | Z3.Sort_uninterpreted s -> display_symbol c out s; + | Z3.Sort_bool -> fprintf out "bool"; + | Z3.Sort_int -> fprintf out "int"; + | Z3.Sort_real -> fprintf out "real"; + | Z3.Sort_relation -> fprintf out "relation"; + | Z3.Sort_finite_domain -> fprintf out "finite-domain"; + | Z3.Sort_bv sz -> fprintf out "bv%d" sz; + | Z3.Sort_array (domain, range) -> + fprintf out "["; + display_sort c out domain; + fprintf out "->"; + display_sort c out range; + fprintf out "]"; + | Z3.Sort_datatype cons -> + Array.iter (fun (dt_con : Z3.datatype_constructor_refined) -> + let fields = dt_con.Z3.accessors in + fprintf out "("; + let f i v = + if i>0 then fprintf out ", "; + display_sort c out (Z3.get_range c v); + in Array.iteri f fields; + fprintf out ")") cons + | Z3.Sort_unknown s -> + fprintf out "unknown["; + display_symbol c out s; + fprintf out "unknown]"; + end;; + +(** + Custom ast pretty printer. + + This function demonstrates how to use the API to navigate terms. +*) + +let rec display_numeral c out nm = + match nm with + | Z3.Numeral_small(n,1L) -> + Printf.fprintf out "%Ld" n + | Z3.Numeral_small(n,d) -> + Printf.fprintf out "%Ld/%Ld" n d + | Z3.Numeral_large s -> + Printf.fprintf out "%s" s + +let rec display_ast c out v = + begin + match Z3.term_refine c v with + | Z3.Term_app(k, f, args) -> + let num_fields = Array.length args in + let a = Z3.to_app c v in + let d = Z3.get_app_decl c a in + Printf.fprintf out "%s" (Z3.func_decl_to_string c d); + if num_fields > 0 then + begin + Printf.fprintf out "["; + for i = 0 to num_fields - 1 do + if i > 0 then Printf.fprintf out ", "; + display_ast c out (Z3.get_app_arg c a i) + done; + Printf.fprintf out "]" + end + | Z3.Term_numeral(nm, s) -> + display_numeral c out nm; + Printf.fprintf out ":"; + display_sort c out s + | Z3.Term_var(idx, s) -> + printf "#unknown" + | Z3.Term_quantifier(b, w, pats, bound, body) -> + printf "quantifier" + end;; + +(** + Custom function for traversing a term and replacing the constant + 'x' by the bound variable having index 'idx'. + This function illustrates how to walk Z3 terms and + reconstruct them. +**) + +let rec abstract c x idx term = + if Z3.is_eq_ast c term x then Z3.mk_bound c idx (Z3.get_sort c x) else + match Z3.term_refine c term with + | Z3.Term_app(k, f, args) -> Z3.mk_app c f (Array.map (abstract c x idx) args) + | Z3.Term_numeral(nm, s) -> term + | Z3.Term_var(idx, s) -> term + | Z3.Term_quantifier(b, w, pats, bound, body) -> + let idx = (idx + Array.length bound) in + let body = abstract c x idx body in + let is_forall = b = Z3.Forall in + let mk_pattern terms = Z3.mk_pattern c (Array.map (abstract c x idx) terms) in + let patterns = Array.map mk_pattern pats in + Z3.mk_quantifier c is_forall w patterns + (Array.map snd bound) (Array.map fst bound) body + +(** + Example abstraction function. +**) + + +let abstract_example() = + begin + printf "\nabstract_example\n"; + let ctx = mk_context [||] in + let x = mk_int_var ctx "x" in + let x_decl = Z3.get_app_decl ctx (Z3.to_app ctx x) in + let y = mk_int_var ctx "y" in + let y_decl = Z3.get_app_decl ctx (Z3.to_app ctx y) in + let decls = [| x_decl; y_decl |] in + let a = Z3.mk_string_symbol ctx "a" in + let b = Z3.mk_string_symbol ctx "b" in + let names = [| a; b |] in + let str = "(benchmark tst :formula (> a b))" in + let f = Z3.parse_smtlib_string_formula ctx str [||] [||] names decls in + printf "formula: %s\n" (Z3.ast_to_string ctx f); + + let f2 = abstract ctx x 0 f in + + printf "abstracted formula: %s\n" (Z3.ast_to_string ctx f2); + (* delete logical context *) + Z3.del_context ctx; + + end;; + +(** + Custom function interpretations pretty printer. +*) +let display_function_interpretations c out m = + begin + fprintf out "function interpretations:\n"; + let display_function (name, entries, func_else) = + begin + display_symbol c out name; + fprintf out " = {"; + let display_entry j (args,valu) = + if j > 0 then fprintf out ", "; + fprintf out "("; + let f k arg = + if k > 0 then fprintf out ", "; + display_ast c out arg + in Array.iteri f args; + fprintf out "|->"; + display_ast c out valu; + fprintf out ")"; + in Array.iteri display_entry entries; + if Array.length entries > 0 then fprintf out ", "; + fprintf out "(else|->"; + display_ast c out func_else; + fprintf out ")}\n"; + end; + in + Array.iter display_function (Z3.get_model_funcs c m); + end;; + +(** + Custom model pretty printer. +*) +let display_model c out m = + begin + let constants=Z3.get_model_constants c m in + let f i e = + let name = Z3.get_decl_name c e in + let (ok, v) = Z3.eval_func_decl c m e in + display_symbol c out name; + fprintf out " = "; + display_ast c out v; + fprintf out "\n" + in Array.iteri f constants; + display_function_interpretations c out m; + end;; + +(** + Similar to #check, but uses #display_model instead of #Z3_model_to_string. +*) +let check2 ctx expected_result = + begin + let (result,m) = Z3.check_and_get_model ctx in + (match result with + | Z3.L_FALSE -> + printf "unsat\n"; + | Z3.L_UNDEF -> + printf "unknown\n"; + printf "potential model:\n"; + display_model ctx stdout m; + (Z3.del_model ctx m); + | Z3.L_TRUE -> + printf "sat\n"; + display_model ctx stdout m; + (Z3.del_model ctx m); + ); + if result != expected_result then exitf "unexpected result"; + end;; + +(** + Display Z3 version in the standard output. +*) +let display_version() = + begin + let (major, minor, build, revision)=Z3.get_version() in + printf "Z3 %d.%d.%d.%d\n" major minor build revision; + end;; + +(* + @name Examples +*) + +(** + "Hello world" example: create a Z3 logical context, and delete it. +*) +let simple_example() = + begin + printf "\nsimple_example\n"; + let ctx = mk_context [||] in + (* do something with the context *) + printf "CONTEXT:\n%sEND OF CONTEXT\n" (Z3.context_to_string ctx); + (* delete logical context *) + Z3.del_context ctx; + end;; + +(** + Demonstration of how Z3 can be used to prove validity of + De Morgan's Duality Law: {e not(x and y) <-> (not x) or ( not y) } +*) +let demorgan() = + begin + printf "\nDeMorgan\n"; + let ctx = mk_context [||] in + let bool_sort = Z3.mk_bool_sort ctx in + let symbol_x = Z3.mk_int_symbol ctx 0 in + let symbol_y = Z3.mk_int_symbol ctx 1 in + let x = Z3.mk_const ctx symbol_x bool_sort in + let y = Z3.mk_const ctx symbol_y bool_sort in + + (* De Morgan - with a negation around: *) + (* !(!(x && y) <-> (!x || !y)) *) + let not_x = Z3.mk_not ctx x in + let not_y = Z3.mk_not ctx y in + let x_and_y = Z3.mk_and ctx [|x;y|] in + let ls = Z3.mk_not ctx x_and_y in + let rs = Z3.mk_or ctx [|not_x;not_y|] in + let conjecture = Z3.mk_iff ctx ls rs in + let negated_conjecture = Z3.mk_not ctx conjecture in + + Z3.assert_cnstr ctx negated_conjecture; + (match Z3.check ctx with + | Z3.L_FALSE -> + (* The negated conjecture was unsatisfiable, hence the conjecture is valid *) + printf "DeMorgan is valid\n" + | Z3.L_UNDEF -> + (* Check returned undef *) + printf "Undef\n" + | Z3.L_TRUE -> + (* The negated conjecture was satisfiable, hence the conjecture is not valid *) + Printf.printf "DeMorgan is not valid\n"); + Z3.del_context ctx; + end;; + +(** + Find a model for {e x xor y }. +*) +let find_model_example1() = + begin + printf "\nfind_model_example1\n"; + let ctx = mk_context [||] in + let x = mk_bool_var ctx "x" in + let y = mk_bool_var ctx "y" in + let x_xor_y = Z3.mk_xor ctx x y in + Z3.assert_cnstr ctx x_xor_y; + printf "model for: x xor y\n"; + check ctx Z3.L_TRUE; + Z3.del_context ctx; + end;; + +(** + Find a model for {e x < y + 1, x > 2 }. + Then, assert {e not(x = y) }, and find another model. +*) +let find_model_example2() = + begin + printf "\nfind_model_example2\n"; + let ctx = mk_context [||] in + let x = mk_int_var ctx "x" in + let y = mk_int_var ctx "y" in + let one = mk_int ctx 1 in + let two = mk_int ctx 2 in + let y_plus_one = Z3.mk_add ctx [|y;one|] in + let c1 = Z3.mk_lt ctx x y_plus_one in + let c2 = Z3.mk_gt ctx x two in + Z3.assert_cnstr ctx c1; + Z3.assert_cnstr ctx c2; + printf "model for: x < y + 1, x > 2\n"; + check ctx Z3.L_TRUE; + + (* assert not(x = y) *) + let x_eq_y = Z3.mk_eq ctx x y in + let c3 = Z3.mk_not ctx x_eq_y in + Z3.assert_cnstr ctx c3; + printf "model for: x < y + 1, x > 2, not(x = y)\n"; + check ctx Z3.L_TRUE; + Z3.del_context ctx; + end;; + +(** + Prove {e x = y implies g(x) = g(y) }, and + disprove {e x = y implies g(g(x)) = g(y) }. + + This function demonstrates how to create uninterpreted types and + functions. +*) +let prove_example1() = + begin + printf "\nprove_example1\n"; + + let ctx = mk_context [||] in + + (* create uninterpreted type. *) + let u_name = Z3.mk_string_symbol ctx "U" in + let u = Z3.mk_uninterpreted_sort ctx u_name in + + (* declare function g *) + let g_name = Z3.mk_string_symbol ctx "g" in + let g = Z3.mk_func_decl ctx g_name [|u|] u in + + (* create x and y *) + let x_name = Z3.mk_string_symbol ctx "x" in + let y_name = Z3.mk_string_symbol ctx "y" in + let x = Z3.mk_const ctx x_name u in + let y = Z3.mk_const ctx y_name u in + (* create g(x), g(y) *) + let gx = mk_unary_app ctx g x in + let gy = mk_unary_app ctx g y in + + (* assert x = y *) + let eq = Z3.mk_eq ctx x y in + Z3.assert_cnstr ctx eq; + + (* prove g(x) = g(y) *) + let f = Z3.mk_eq ctx gx gy in + printf "prove: x = y implies g(x) = g(y)\n"; + prove ctx f true; + + (* create g(g(x)) *) + let ggx = mk_unary_app ctx g gx in + + (* disprove g(g(x)) = g(y) *) + let f = Z3.mk_eq ctx ggx gy in + printf "disprove: x = y implies g(g(x)) = g(y)\n"; + prove ctx f false; + + Z3.del_context ctx; + end;; + +(** + Prove {e not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < 0 }. + Then, show that {e z < -1 } is not implied. + + This example demonstrates how to combine uninterpreted functions and arithmetic. +*) +let prove_example2() = + begin + printf "\nprove_example2\n"; + + let ctx = mk_context [||] in + + (* declare function g *) + let int_sort = Z3.mk_int_sort ctx in + let g_name = Z3.mk_string_symbol ctx "g" in + let g = Z3.mk_func_decl ctx g_name [|int_sort|] int_sort in + + (* create x, y, and z *) + let x = mk_int_var ctx "x" in + let y = mk_int_var ctx "y" in + let z = mk_int_var ctx "z" in + + (* create gx, gy, gz *) + let gx = mk_unary_app ctx g x in + let gy = mk_unary_app ctx g y in + let gz = mk_unary_app ctx g z in + + (* create zero *) + let zero = mk_int ctx 0 in + + (* assert not(g(g(x) - g(y)) = g(z)) *) + let gx_gy = Z3.mk_sub ctx [|gx;gy|] in + let ggx_gy = mk_unary_app ctx g gx_gy in + let eq = Z3.mk_eq ctx ggx_gy gz in + let c1 = Z3.mk_not ctx eq in + Z3.assert_cnstr ctx c1; + + (* assert x + z <= y *) + let x_plus_z = Z3.mk_add ctx [|x;z|] in + let c2 = Z3.mk_le ctx x_plus_z y in + Z3.assert_cnstr ctx c2; + + (* assert y <= x *) + let c3 = Z3.mk_le ctx y x in + Z3.assert_cnstr ctx c3; + + (* prove z < 0 *) + let f = Z3.mk_lt ctx z zero in + printf "prove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < 0\n"; + prove ctx f true; + + (* disprove z < -1 *) + let minus_one = mk_int ctx (-1) in + let f = Z3.mk_lt ctx z minus_one in + printf "disprove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < -1\n"; + prove ctx f false; + + Z3.del_context ctx; + end;; + +(** + Show how push & pop can be used to create "backtracking" + points. + + This example also demonstrates how big numbers can be created in Z3. +*) +let push_pop_example1() = + begin + printf "\npush_pop_example1\n"; + let ctx = mk_context [||] in + + (* create a big number *) + let int_sort = Z3.mk_int_sort ctx in + let big_number = Z3.mk_numeral ctx "1000000000000000000000000000000000000000000000000000000" int_sort in + + (* create number 3 *) + let three = Z3.mk_numeral ctx "3" int_sort in + + (* create x *) + let x_sym = Z3.mk_string_symbol ctx "x" in + let x = Z3.mk_const ctx x_sym int_sort in + + (* assert x >= "big number" *) + let c1 = Z3.mk_ge ctx x big_number in + printf "assert: x >= 'big number'\n"; + Z3.assert_cnstr ctx c1; + + (* create a backtracking point *) + printf "push\n"; + Z3.push ctx; + + printf "number of scopes: %d\n" (Z3.get_num_scopes ctx); + + (* assert x <= 3 *) + let c2 = Z3.mk_le ctx x three in + printf "assert: x <= 3\n"; + Z3.assert_cnstr ctx c2; + + (* context is inconsistent at this point *) + check2 ctx Z3.L_FALSE; + + (* backtrack: the constraint x <= 3 will be removed, since it was + asserted after the last push. *) + printf "pop\n"; + Z3.pop ctx 1; + + printf "number of scopes: %d\n" (Z3.get_num_scopes ctx); + + (* the context is consistent again. *) + check2 ctx Z3.L_TRUE; + + (* new constraints can be asserted... *) + + (* create y *) + let y_sym = Z3.mk_string_symbol ctx "y" in + let y = Z3.mk_const ctx y_sym int_sort in + + (* assert y > x *) + let c3 = Z3.mk_gt ctx y x in + printf "assert: y > x\n"; + Z3.assert_cnstr ctx c3; + + (* the context is still consistent. *) + check2 ctx Z3.L_TRUE; + + Z3.del_context ctx; + end;; + +(** + Prove that {e f(x, y) = f(w, v) implies y = v } when + {e f } is injective in the second argument. +*) +let quantifier_example1() = + begin + printf "\nquantifier_example1\n"; + + (* If quantified formulas are asserted in a logical context, then + Z3 may return L_UNDEF. In this case, the model produced by Z3 should be viewed as a potential/candidate model. + Limiting the number of iterations of the model finder for quantified formulas. + *) + let ctx = mk_context [|("MBQI_MAX_ITERATIONS", "10")|] in + + (* declare function f *) + let int_sort = Z3.mk_int_sort ctx in + let f_name = Z3.mk_string_symbol ctx "f" in + let f = Z3.mk_func_decl ctx f_name [|int_sort; int_sort|] int_sort in + + (* assert that f is injective in the second argument. *) + assert_inj_axiom ctx f 1; + + (* create x, y, v, w, fxy, fwv *) + let x = mk_int_var ctx "x" in + let y = mk_int_var ctx "y" in + let v = mk_int_var ctx "v" in + let w = mk_int_var ctx "w" in + let fxy = mk_binary_app ctx f x y in + let fwv = mk_binary_app ctx f w v in + + (* assert f(x, y) = f(w, v) *) + let p1 = Z3.mk_eq ctx fxy fwv in + Z3.assert_cnstr ctx p1; + + (* prove f(x, y) = f(w, v) implies y = v *) + let p2 = Z3.mk_eq ctx y v in + printf "prove: f(x, y) = f(w, v) implies y = v\n"; + prove ctx p2 true; + + (* disprove f(x, y) = f(w, v) implies x = w *) + (* using check2 instead of prove *) + let p3 = Z3.mk_eq ctx x w in + let not_p3 = Z3.mk_not ctx p3 in + Z3.assert_cnstr ctx not_p3; + printf "disprove: f(x, y) = f(w, v) implies x = w\n"; + printf "that is: not(f(x, y) = f(w, v) implies x = w) is satisfiable\n"; + check2 ctx Z3.L_UNDEF; + Printf.printf + "reason for last failure: %d (7 = quantifiers)\n" + (if Z3.get_search_failure(ctx) = Z3.QUANTIFIERS then 7 else -1); + + + Z3.del_context ctx; + end;; + +(** + Prove {e store(a1, i1, v1) = store(a2, i2, v2) implies (i1 = i3 or i2 = i3 or select(a1, i3) = select(a2, i3)) }. + + This example demonstrates how to use the array theory. +*) +let array_example1() = + begin + printf "\narray_example1\n"; + + let ctx = mk_context [||] in + + let int_sort = Z3.mk_int_sort ctx in + let array_sort = Z3.mk_array_sort ctx int_sort int_sort in + + let a1 = mk_var ctx "a1" array_sort in + let a2 = mk_var ctx "a2" array_sort in + let i1 = mk_var ctx "i1" int_sort in + let i2 = mk_var ctx "i2" int_sort in + let i3 = mk_var ctx "i3" int_sort in + let v1 = mk_var ctx "v1" int_sort in + let v2 = mk_var ctx "v2" int_sort in + + let st1 = Z3.mk_store ctx a1 i1 v1 in + let st2 = Z3.mk_store ctx a2 i2 v2 in + + let sel1 = Z3.mk_select ctx a1 i3 in + let sel2 = Z3.mk_select ctx a2 i3 in + + (* create antecedent *) + let antecedent = Z3.mk_eq ctx st1 st2 in + + (* create consequent: i1 = i3 or i2 = i3 or select(a1, i3) = select(a2, i3) *) + let ds = [| + Z3.mk_eq ctx i1 i3; + Z3.mk_eq ctx i2 i3; + Z3.mk_eq ctx sel1 sel2; + |] in + + let consequent = Z3.mk_or ctx ds in + + (* prove store(a1, i1, v1) = store(a2, i2, v2) implies (i1 = i3 or i2 = i3 or select(a1, i3) = select(a2, i3)) *) + let thm = Z3.mk_implies ctx antecedent consequent in + printf "prove: store(a1, i1, v1) = store(a2, i2, v2) implies (i1 = i3 or i2 = i3 or select(a1, i3) = select(a2, i3))\n"; + printf "%s\n" (Z3.ast_to_string ctx thm); + prove ctx thm true; + + Z3.del_context ctx; + end;; + +(** + Show that {e distinct(a_0, ... , a_n) } is + unsatisfiable when {e a_i's } are arrays from boolean to + boolean and n > 4. + + This example also shows how to use the {e distinct } construct. +*) +let array_example2() = + begin + printf "\narray_example2\n"; + + for n = 2 to 5 do + printf "n = %d\n" n; + let ctx = mk_context [||] in + + let bool_sort = Z3.mk_bool_sort ctx in + let array_sort = Z3.mk_array_sort ctx bool_sort bool_sort in + + (* create arrays *) + let a = Array.init n + (fun i->Z3.mk_const ctx (Z3.mk_int_symbol ctx i) array_sort) in + + (* assert distinct(a[0], ..., a[n]) *) + let d = Z3.mk_distinct ctx a in + printf "%s\n" (Z3.ast_to_string ctx d); + Z3.assert_cnstr ctx d; + + (* context is satisfiable if n < 5 *) + check2 ctx (if n < 5 then Z3.L_TRUE else Z3.L_FALSE); + + Z3.del_context ctx; + done + end;; + +(** + Simple array type construction/deconstruction example. +*) +let array_example3() = + begin + printf "\narray_example3\n"; + + let ctx = mk_context [||] in + + let bool_sort = Z3.mk_bool_sort ctx in + let int_sort = Z3.mk_int_sort ctx in + let array_sort = Z3.mk_array_sort ctx int_sort bool_sort in + + let (domain,range) = Z3.get_array_sort ctx array_sort in + printf "domain: "; + display_sort ctx stdout domain; + printf "\n"; + printf "range: "; + display_sort ctx stdout range; + printf "\n"; + + if (not (Z3.is_eq_sort ctx int_sort domain)) || + (not (Z3.is_eq_sort ctx bool_sort range)) then + exitf "invalid array type"; + Z3.del_context ctx; + end;; + +(** + Simple tuple type example. It creates a tuple that is a pair of real numbers. +*) +let tuple_example1() = + begin + printf "\ntuple_example1\n"; + let ctx = mk_context [||] in + + let real_sort = Z3.mk_real_sort ctx in + + (* Create pair (tuple) type *) + let mk_tuple_name = Z3.mk_string_symbol ctx "mk_pair" in + let proj_names_0 = Z3.mk_string_symbol ctx "get_x" in + let proj_names_1 = Z3.mk_string_symbol ctx "get_y" in + let proj_names = [|proj_names_0; proj_names_1|] in + let proj_sorts = [|real_sort;real_sort|] in + (* Z3_mk_tuple_sort will set mk_tuple_decl and proj_decls *) + let (pair_sort,mk_tuple_decl,proj_decls) = Z3.mk_tuple_sort ctx mk_tuple_name proj_names proj_sorts in + let get_x_decl = proj_decls.(0) in (* function that extracts the first element of a tuple. *) + let get_y_decl = proj_decls.(1) in (* function that extracts the second element of a tuple. *) + + printf "tuple_sort: "; + display_sort ctx stdout pair_sort; + printf "\n"; + + begin + (* prove that get_x(mk_pair(x,y)) == 1 implies x = 1*) + let x = mk_real_var ctx "x" in + let y = mk_real_var ctx "y" in + let app1 = mk_binary_app ctx mk_tuple_decl x y in + let app2 = mk_unary_app ctx get_x_decl app1 in + let one = Z3.mk_numeral ctx "1" real_sort in + let eq1 = Z3.mk_eq ctx app2 one in + let eq2 = Z3.mk_eq ctx x one in + let thm = Z3.mk_implies ctx eq1 eq2 in + printf "prove: get_x(mk_pair(x, y)) = 1 implies x = 1\n"; + prove ctx thm true; + + (* disprove that get_x(mk_pair(x,y)) == 1 implies y = 1*) + let eq3 = Z3.mk_eq ctx y one in + let thm = Z3.mk_implies ctx eq1 eq3 in + printf "disprove: get_x(mk_pair(x, y)) = 1 implies y = 1\n"; + prove ctx thm false; + end; + + begin + (* prove that get_x(p1) = get_x(p2) and get_y(p1) = get_y(p2) implies p1 = p2 *) + let p1 = mk_var ctx "p1" pair_sort in + let p2 = mk_var ctx "p2" pair_sort in + let x1 = mk_unary_app ctx get_x_decl p1 in + let y1 = mk_unary_app ctx get_y_decl p1 in + let x2 = mk_unary_app ctx get_x_decl p2 in + let y2 = mk_unary_app ctx get_y_decl p2 in + let antecedents_0 = Z3.mk_eq ctx x1 x2 in + let antecedents_1 = Z3.mk_eq ctx y1 y2 in + let antecedents = [|antecedents_0; antecedents_1|] in + let antecedent = Z3.mk_and ctx antecedents in + let consequent = Z3.mk_eq ctx p1 p2 in + let thm = Z3.mk_implies ctx antecedent consequent in + printf "prove: get_x(p1) = get_x(p2) and get_y(p1) = get_y(p2) implies p1 = p2\n"; + prove ctx thm true; + + (* disprove that get_x(p1) = get_x(p2) implies p1 = p2 *) + let thm = Z3.mk_implies ctx (antecedents.(0)) consequent in + printf "disprove: get_x(p1) = get_x(p2) implies p1 = p2\n"; + prove ctx thm false; + end; + + begin + (* demonstrate how to use the mk_tuple_update function *) + (* prove that p2 = update(p1, 0, 10) implies get_x(p2) = 10 *) + let p1 = mk_var ctx "p1" pair_sort in + let p2 = mk_var ctx "p2" pair_sort in + let one = Z3.mk_numeral ctx "1" real_sort in + let ten = Z3.mk_numeral ctx "10" real_sort in + let updt = mk_tuple_update ctx p1 0 ten in + let antecedent = Z3.mk_eq ctx p2 updt in + let x = mk_unary_app ctx get_x_decl p2 in + let consequent = Z3.mk_eq ctx x ten in + let thm = Z3.mk_implies ctx antecedent consequent in + printf "prove: p2 = update(p1, 0, 10) implies get_x(p2) = 10\n"; + prove ctx thm true; + + (* disprove that p2 = update(p1, 0, 10) implies get_y(p2) = 10 *) + let y = mk_unary_app ctx get_y_decl p2 in + let consequent = Z3.mk_eq ctx y ten in + let thm = Z3.mk_implies ctx antecedent consequent in + printf "disprove: p2 = update(p1, 0, 10) implies get_y(p2) = 10\n"; + prove ctx thm false; + end; + + Z3.del_context ctx; + end;; + +(** + Simple bit-vector example. This example disproves that x - 10 <= 0 IFF x <= 10 for (32-bit) machine integers + *) +let bitvector_example1() = + begin + printf "\nbitvector_example1\n"; + + let ctx = mk_context [||] in + + let bv_sort = Z3.mk_bv_sort ctx 32 in + + let x = mk_var ctx "x" bv_sort in + let zero = Z3.mk_numeral ctx "0" bv_sort in + let ten = Z3.mk_numeral ctx "10" bv_sort in + let x_minus_ten = Z3.mk_bvsub ctx x ten in + (* bvsle is signed less than or equal to *) + let c1 = Z3.mk_bvsle ctx x ten in + let c2 = Z3.mk_bvsle ctx x_minus_ten zero in + let thm = Z3.mk_iff ctx c1 c2 in + printf "disprove: x - 10 <= 0 IFF x <= 10 for (32-bit) machine integers\n"; + prove ctx thm false; + + Z3.del_context ctx; + end;; + +(** + Find x and y such that: x ^ y - 103 == x * y + *) +let bitvector_example2() = + begin + printf "\nbitvector_example2\n"; + let ctx = mk_context [||] in + (* construct x ^ y - 103 == x * y *) + let bv_sort = Z3.mk_bv_sort ctx 32 in + let x = mk_var ctx "x" bv_sort in + let y = mk_var ctx "y" bv_sort in + let x_xor_y = Z3.mk_bvxor ctx x y in + let c103 = Z3.mk_numeral ctx "103" bv_sort in + let lhs = Z3.mk_bvsub ctx x_xor_y c103 in + let rhs = Z3.mk_bvmul ctx x y in + let ctr = Z3.mk_eq ctx lhs rhs in + printf "find values of x and y, such that x ^ y - 103 == x * y\n"; + Z3.assert_cnstr ctx ctr; + check ctx Z3.L_TRUE; + Z3.del_context ctx; + end;; + +(** + Demonstrate how to use #Z3_eval. +*) +let eval_example1() = + begin + printf "\neval_example1\n"; + + let ctx = mk_context [||] in + let x = mk_int_var ctx "x" in + let y = mk_int_var ctx "y" in + let two = mk_int ctx 2 in + + (* assert x < y *) + let c1 = Z3.mk_lt ctx x y in + Z3.assert_cnstr ctx c1; + + (* assert x > 2 *) + let c2 = Z3.mk_gt ctx x two in + Z3.assert_cnstr ctx c2; + + (* find model for the constraints above *) + (match Z3.check_and_get_model ctx with + | (Z3.L_TRUE, m) -> + begin + let args = [|x; y|] in + printf "MODEL:\n%s" (Z3.model_to_string ctx m); + let x_plus_y = Z3.mk_add ctx args in + printf "\nevaluating x+y\n"; + (match Z3.eval ctx m x_plus_y with + | (true,v) -> + printf "result = "; + display_ast ctx stdout v; + printf "\n"; + | _ -> + exitf "failed to evaluate: x+y"; + ); + (Z3.del_model ctx m); + end; + | (_,_) -> + exitf "the constraints are satisfiable"; + ); + Z3.del_context ctx; + end;; + +(** + Several logical context can be used simultaneously. +*) +let two_contexts_example1() = + begin + printf "\ntwo_contexts_example1\n"; + (* using the same (default) configuration to initialized both logical contexts. *) + let ctx1 = mk_context [||] in + let ctx2 = mk_context [||] in + let x1 = Z3.mk_const ctx1 (Z3.mk_int_symbol ctx1 0) (Z3.mk_bool_sort ctx1) in + let x2 = Z3.mk_const ctx2 (Z3.mk_int_symbol ctx2 0) (Z3.mk_bool_sort ctx2) in + Z3.del_context ctx1; + (* ctx2 can still be used. *) + printf "%s\n" (Z3.ast_to_string ctx2 x2); + Z3.del_context ctx2; + end;; + +(** + Demonstrates how error codes can be read insted of registering an error handler. + *) +let error_code_example1() = + begin + printf "\nerror_code_example1\n"; + + let ctx = mk_context [||] in + let x = mk_bool_var ctx "x" in + let x_decl = Z3.get_app_decl ctx (Z3.to_app ctx x) in + Z3.assert_cnstr ctx x; + + match Z3.check_and_get_model ctx with + | (Z3.L_TRUE,m) -> + begin + let (ok, v) = Z3.eval_func_decl ctx m x_decl in + printf "last call succeeded.\n"; + + (* The following call will fail since the value of x is a boolean *) + (try ignore(Z3.get_numeral_string ctx v) + with | _ -> printf "last call failed.\n"); + (Z3.del_model ctx m); + Z3.del_context ctx; + end + | (_,_) -> exitf "unexpected result"; + end;; + +(** + Demonstrates how Z3 exceptions can be used. +*) +let error_code_example2() = + begin + printf "\nerror_code_example2\n%!"; + + let ctx = mk_context [||] in + try + let x = mk_int_var ctx "x" in + let y = mk_bool_var ctx "y" in + printf "before Z3_mk_iff\n"; + let app = Z3.mk_iff ctx x y in + printf "unreachable"; + with | _ -> printf "Z3 error: type error.\n"; + Z3.del_context ctx; + end;; + +(** + Demonstrates how to use the SMTLIB parser. + *) +let parser_example1() = + begin + printf "\nparser_example1\n"; + + let ctx = mk_context [||] in + let str = "(benchmark tst :extrafuns ((x Int) (y Int)) :formula (> x y) :formula (> x 0))" in + let (formulas,_,_) = Z3.parse_smtlib_string_x ctx str [||] [||] [||] [||] in + let f i c = + printf "formula %d: %s\n" i (Z3.ast_to_string ctx c); + Z3.assert_cnstr ctx c; + in Array.iteri f formulas; + check ctx Z3.L_TRUE; + Z3.del_context ctx; + end;; + +(** + Demonstrates how to initialize the parser symbol table. + *) +let parser_example2() = + begin + printf "\nparser_example2\n%!"; + + let ctx = mk_context [||] in + let x = mk_int_var ctx "x" in + let x_decl = Z3.get_app_decl ctx (Z3.to_app ctx x) in + let y = mk_int_var ctx "y" in + let y_decl = Z3.get_app_decl ctx (Z3.to_app ctx y) in + let decls = [| x_decl; y_decl |] in + let a = Z3.mk_string_symbol ctx "a" in + let b = Z3.mk_string_symbol ctx "b" in + let names = [| a; b |] in + let str = "(benchmark tst :formula (> a b))" in + let f = Z3.parse_smtlib_string_formula ctx str [||] [||] names decls in + printf "formula: %s\n" (Z3.ast_to_string ctx f); + Z3.assert_cnstr ctx f; + check ctx Z3.L_TRUE; + Z3.del_context ctx; + end;; + +(** + Demonstrates how to initialize the parser symbol table. + *) +let parser_example3() = + begin + printf "\nparser_example3\n%!"; + + let ctx = mk_context [| |] in + let int_sort = Z3.mk_int_sort ctx in + let g_name = Z3.mk_string_symbol ctx "g" in + let g = Z3.mk_func_decl ctx g_name [| int_sort; int_sort |] int_sort in + let str = "(benchmark tst :formula (forall (x Int) (y Int) (implies (= x y) (= (g x 0) (g 0 y)))))" in + assert_comm_axiom ctx g; + let thm = Z3.parse_smtlib_string_formula ctx str [||] [||] [|g_name|] [|g|] in + printf "formula: %s\n" (Z3.ast_to_string ctx thm); + prove ctx thm true; + Z3.del_context ctx; + end;; + +(** + Display the declarations, assumptions and formulas in a SMT-LIB string. + *) +let parser_example4() = + begin + printf "\nparser_example4\n%!"; + + let ctx = mk_context [||] in + let str = "(benchmark tst :extrafuns ((x Int) (y Int)) :assumption (= x 20) :formula (> x y) :formula (> x 0))" in + (* arithmetic theory is automatically initialized, when an + int/real variable or arith operation is created using the API. + Since no such function is invoked in this example, we should do + that manually. + *) + let (formulas, assumptions, decls) = Z3.parse_smtlib_string_x ctx str [||] [||] [||] [||] in + let f prefix i n = printf "%s %d: %s\n" prefix i (Z3.ast_to_string ctx n) in + Array.iteri (fun i n -> printf "declaration %d: %s\n" i (Z3.func_decl_to_string ctx n)) decls; + Array.iteri (f "assumption") assumptions; + Array.iteri (f "formula") formulas; + Z3.del_context ctx; + end;; + +(** + Demonstrates how to handle parser errors using Z3 exceptions. + *) +let parser_example5() = + begin + printf "\nparser_example5\n"; + let ctx = mk_context [||] in + try + (* the following string has a parsing error: missing parenthesis *) + let str = "(benchmark tst :extrafuns ((x Int (y Int)) :formula (> x y) :formula (> x 0))" in + ignore(Z3.parse_smtlib_string_x ctx str [||] [||] [||] [||]); + with | _ -> (printf "Z3 error: parser error.\n"; + printf "Error message: '%s'.\n" (Z3.get_smtlib_error ctx) + ); + Z3.del_context ctx; + end;; + +(** + Example for creating an if-then-else expression. + *) +let ite_example() = + begin + printf "\nite_example\n%!"; + let ctx = mk_context [||] in + let f = Z3.mk_false ctx in + let one = mk_int ctx 1 in + let zero = mk_int ctx 0 in + let ite = Z3.mk_ite ctx f one zero in + printf "term: %s\n" (Z3.ast_to_string ctx ite); + Z3.del_context ctx; + end;; + + +(** + Create an enumeration data type. + + Several more examples of creating and using data-types (lists, trees, records) + are provided for the C-based API. + The translation from the examples in C to use the OCaml API follow the same pattern + that is used here. +*) +let enum_example() = + begin + printf "\nenum_example\n"; + let ctx = mk_context [||] in + let name = Z3.mk_string_symbol ctx "fruit" in + let enum_names = [| Z3.mk_string_symbol ctx "apple"; + Z3.mk_string_symbol ctx "banana"; + Z3.mk_string_symbol ctx "orange" |] in + let (fruit, enum_consts, enum_testers) = Z3.mk_enumeration_sort ctx name enum_names in + + printf "%s\n" (Z3.func_decl_to_string ctx enum_consts.(0)); + printf "%s\n" (Z3.func_decl_to_string ctx enum_consts.(1)); + printf "%s\n" (Z3.func_decl_to_string ctx enum_consts.(2)); + printf "%s\n" (Z3.func_decl_to_string ctx enum_testers.(0)); + printf "%s\n" (Z3.func_decl_to_string ctx enum_testers.(1)); + printf "%s\n" (Z3.func_decl_to_string ctx enum_testers.(2)); + + let apple = Z3.mk_app ctx (enum_consts.(0)) [||] in + let banana = Z3.mk_app ctx (enum_consts.(1)) [||] in + let orange = Z3.mk_app ctx (enum_consts.(2)) [||] in + + (* Apples are different from oranges *) + prove ctx (Z3.mk_not ctx (Z3.mk_eq ctx apple orange)) true; + + (* Apples pass the apple test *) + prove ctx (Z3.mk_app ctx enum_testers.(0) [| apple |]) true; + + (* Oranges fail the apple test *) + prove ctx (Z3.mk_app ctx enum_testers.(0) [| orange |]) false; + prove ctx (Z3.mk_not ctx (Z3.mk_app ctx enum_testers.(0) [| orange |])) true; + + let fruity = mk_var ctx "fruity" fruit in + + (* If something is fruity, then it is an apple, banana, or orange *) + let ors = [| Z3.mk_eq ctx fruity apple; + Z3.mk_eq ctx fruity banana; + Z3.mk_eq ctx fruity orange |] in + + prove ctx (Z3.mk_or ctx ors) true; + Z3.del_context ctx; + end;; + +(** + Example for extracting unsatisfiable core and proof. + The example uses the function check_assumptions which allows passing in additional + hypotheses. The unsatisfiable core is a subset of these additional hypotheses. + *) +let unsat_core_and_proof_example() = + begin + printf "\nunsat_core_and_proof_example\n%!"; + let ctx = mk_context [| ("PROOF_MODE","2") |] in + let pa = mk_bool_var ctx "PredA" in + let pb = mk_bool_var ctx "PredB" in + let pc = mk_bool_var ctx "PredC" in + let pd = mk_bool_var ctx "PredD" in + let p1 = mk_bool_var ctx "P1" in + let p2 = mk_bool_var ctx "P2" in + let p3 = mk_bool_var ctx "P3" in + let p4 = mk_bool_var ctx "P4" in + let assumptions = [| Z3.mk_not ctx p1; Z3.mk_not ctx p2; Z3.mk_not ctx p3; Z3.mk_not ctx p4 |] in + let f1 = Z3.mk_and ctx [| pa; pb; pc |] in + let f2 = Z3.mk_and ctx [| pa; Z3.mk_not ctx pc; pb |] in + let f3 = Z3.mk_or ctx [| Z3.mk_not ctx pa; Z3.mk_not ctx pc |] in + let f4 = pd in + let core_dummy = [| pa; pa; pa; pa |] in + Z3.assert_cnstr ctx (Z3.mk_or ctx [| f1; p1 |]); + Z3.assert_cnstr ctx (Z3.mk_or ctx [| f2; p2 |]); + Z3.assert_cnstr ctx (Z3.mk_or ctx [| f3; p3 |]); + Z3.assert_cnstr ctx (Z3.mk_or ctx [| f4; p4 |]); + let result = Z3.check_assumptions ctx assumptions 4 core_dummy in + (match result with + | (Z3.L_FALSE, _, proof, core_size, core) -> + printf "unsat\n"; + printf "proof: %s\n" (Z3.ast_to_string ctx proof); + printf("\ncore:\n"); + for i = 0 to core_size - 1 do + printf "%s\n" (Z3.ast_to_string ctx (core.(i))); + done; + printf("\n") + | (_,_,_,_,_)-> assert false; + ); + (* delete logical context *) + Z3.del_context(ctx); + end + +(** + +*) + +let get_implied_equalities_example() = + begin + printf "\nget_implied_equalities example\n%!"; + let ctx = mk_context [| |] in + let int_ty = Z3.mk_int_sort ctx in + let a = mk_int_var ctx "a" in + let b = mk_int_var ctx "b" in + let c = mk_int_var ctx "c" in + let d = mk_int_var ctx "d" in + let f = Z3.mk_func_decl ctx (Z3.mk_string_symbol ctx "f") [| int_ty |] int_ty in + let fa = Z3.mk_app ctx f [| a |] in + let fb = Z3.mk_app ctx f [| b |] in + let fc = Z3.mk_app ctx f [| c |] in + let terms = [| a; b; c; d; fa; fb; fc |] in + Z3.assert_cnstr ctx (Z3.mk_eq ctx a b); + Z3.assert_cnstr ctx (Z3.mk_eq ctx b c); + Z3.assert_cnstr ctx (Z3.mk_le ctx fc b); + Z3.assert_cnstr ctx (Z3.mk_le ctx b fa); + let is_sat, class_ids = Z3.get_implied_equalities ctx terms in + for i = 0 to 6 do + printf "Class %s |-> %d\n" (Z3.ast_to_string ctx (terms.(i))) (class_ids.(i)); + done; + printf "asserting f(a) <= b\n"; + Z3.assert_cnstr ctx (Z3.mk_le ctx fa b); + let is_sat, class_ids = Z3.get_implied_equalities ctx terms in + for i = 0 to 6 do + printf "Class %s |-> %d\n" (Z3.ast_to_string ctx (terms.(i))) (class_ids.(i)); + done; + (* delete logical context *) + Z3.del_context(ctx) + end;; + +let main() = + begin + ignore (Z3.open_log("ml.log")); + display_version(); + simple_example(); + demorgan(); + find_model_example1(); + find_model_example2(); + prove_example1(); + prove_example2(); + push_pop_example1(); + quantifier_example1(); + array_example1(); + array_example2(); + array_example3(); + tuple_example1(); + bitvector_example1(); + bitvector_example2(); + eval_example1(); + two_contexts_example1(); + error_code_example1(); + error_code_example2(); + parser_example1(); + parser_example2(); + parser_example3(); + parser_example4(); + parser_example5(); +(* numeral_example(); *) + ite_example(); +(* list_example(); *) +(* tree_example(); *) +(* forest_example(); *) +(* binary_tree_example(); *) + enum_example(); + unsat_core_and_proof_example(); + abstract_example(); + get_implied_equalities_example(); +(* incremental_example1(); *) +(* reference_counter_example(); *) +(* smt2parser_example(); *) +(* substitute_example(); *) +(* substitute_vars_example(); *) + end;; + +let _ = main();; diff --git a/ml/test_mlapiV3.regress.err b/ml/test_mlapiV3.regress.err new file mode 100644 index 000000000..0c383b409 --- /dev/null +++ b/ml/test_mlapiV3.regress.err @@ -0,0 +1,5 @@ +WARNING: invalid function application, sort mismatch on argument at position 1 +WARNING: (define iff Bool Bool Bool) applied to: +x of sort Int +y of sort Bool + diff --git a/ml/test_mlapiV3.regress.out b/ml/test_mlapiV3.regress.out new file mode 100644 index 000000000..56657a8ab --- /dev/null +++ b/ml/test_mlapiV3.regress.out @@ -0,0 +1,312 @@ +Z3 4.0.0.0 + +simple_example +CONTEXT: +(solver)END OF CONTEXT + +DeMorgan +DeMorgan is valid + +find_model_example1 +model for: x xor y +sat +y -> false +x -> true + + +find_model_example2 +model for: x < y + 1, x > 2 +sat +y -> 3 +x -> 3 + +model for: x < y + 1, x > 2, not(x = y) +sat +y -> 4 +x -> 3 + + +prove_example1 +prove: x = y implies g(x) = g(y) +valid +disprove: x = y implies g(g(x)) = g(y) +invalid +counterexample: +y -> U!val!0 +x -> U!val!0 +g -> { + U!val!0 -> U!val!1 + U!val!1 -> U!val!2 + else -> U!val!1 +} + + +prove_example2 +prove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < 0 +valid +disprove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < -1 +invalid +counterexample: +z -> -1 +y -> -7719 +x -> -7719 +g -> { + -7719 -> 0 + 0 -> 2 + -1 -> 3 + else -> 0 +} + + +push_pop_example1 +assert: x >= 'big number' +push +number of scopes: 1 +assert: x <= 3 +unsat +pop +number of scopes: 0 +sat +x = 1000000000000000000000000000000000000000000000000000000:int +function interpretations: +assert: y > x +sat +y = 1000000000000000000000000000000000000000000000000000001:int +x = 1000000000000000000000000000000000000000000000000000000:int +function interpretations: + +quantifier_example1 +pattern: {(f #0 #1)} + +assert axiom: +(forall (k!0 Int) (k!1 Int) (= (inv!0 (f k!1 k!0)) k!0) :pat {(f k!1 k!0)}) +prove: f(x, y) = f(w, v) implies y = v +valid +disprove: f(x, y) = f(w, v) implies x = w +that is: not(f(x, y) = f(w, v) implies x = w) is satisfiable +unknown +potential model: +w = 2:int +v = 1:int +y = 1:int +x = 0:int +function interpretations: +f = {(0:int, 1:int|->3:int), (2:int, 1:int|->3:int), (else|->3:int)} +inv!0 = {(3:int|->1:int), (else|->1:int)} +reason for last failure: 7 (7 = quantifiers) + +array_example1 +prove: store(a1, i1, v1) = store(a2, i2, v2) implies (i1 = i3 or i2 = i3 or select(a1, i3) = select(a2, i3)) +(implies (= (store a1 i1 v1) (store a2 i2 v2)) + (or (= i1 i3) (= i2 i3) (= (select a1 i3) (select a2 i3)))) +valid + +array_example2 +n = 2 +(distinct k!0 k!1) +sat +#0 = (define as-array[k!0] (Array Bool Bool)) +#1 = (define as-array[k!1] (Array Bool Bool)) +function interpretations: +#0 = {((define false Bool)|->(define true Bool)), (else|->(define true Bool))} +#1 = {((define false Bool)|->(define false Bool)), (else|->(define false Bool))} +n = 3 +(distinct k!0 k!1 k!2) +sat +#0 = (define as-array[k!0] (Array Bool Bool)) +#1 = (define as-array[k!1] (Array Bool Bool)) +#2 = (define as-array[k!2] (Array Bool Bool)) +function interpretations: +#0 = {((define true Bool)|->(define true Bool)), ((define false Bool)|->(define false Bool)), (else|->(define true Bool))} +#1 = {((define false Bool)|->(define true Bool)), (else|->(define true Bool))} +#2 = {((define true Bool)|->(define false Bool)), ((define false Bool)|->(define false Bool)), (else|->(define false Bool))} +n = 4 +(distinct k!0 k!1 k!2 k!3) +sat +#0 = (define as-array[k!0] (Array Bool Bool)) +#1 = (define as-array[k!1] (Array Bool Bool)) +#2 = (define as-array[k!2] (Array Bool Bool)) +#3 = (define as-array[k!3] (Array Bool Bool)) +function interpretations: +#0 = {((define true Bool)|->(define false Bool)), ((define false Bool)|->(define true Bool)), (else|->(define false Bool))} +#1 = {((define true Bool)|->(define true Bool)), ((define false Bool)|->(define false Bool)), (else|->(define true Bool))} +#2 = {((define true Bool)|->(define true Bool)), ((define false Bool)|->(define true Bool)), (else|->(define true Bool))} +#3 = {((define true Bool)|->(define false Bool)), ((define false Bool)|->(define false Bool)), (else|->(define false Bool))} +n = 5 +(distinct k!0 k!1 k!2 k!3 k!4) +unsat + +array_example3 +domain: int +range: bool + +tuple_example1 +tuple_sort: (real, real) +prove: get_x(mk_pair(x, y)) = 1 implies x = 1 +valid +disprove: get_x(mk_pair(x, y)) = 1 implies y = 1 +invalid +counterexample: +y -> 0 +x -> 1 + +prove: get_x(p1) = get_x(p2) and get_y(p1) = get_y(p2) implies p1 = p2 +valid +disprove: get_x(p1) = get_x(p2) implies p1 = p2 +invalid +counterexample: +p1 -> (mk_pair 1 0) +p2 -> (mk_pair 1 2) + +prove: p2 = update(p1, 0, 10) implies get_x(p2) = 10 +valid +disprove: p2 = update(p1, 0, 10) implies get_y(p2) = 10 +invalid +counterexample: +p2 -> (mk_pair 10 1) +p1 -> (mk_pair 0 1) + + +bitvector_example1 +disprove: x - 10 <= 0 IFF x <= 10 for (32-bit) machine integers +invalid +counterexample: +x -> bv2147483656[32] + + +bitvector_example2 +find values of x and y, such that x ^ y - 103 == x * y +sat +y -> bv3905735879[32] +x -> bv3787456528[32] + + +eval_example1 +MODEL: +y -> 4 +x -> 3 + +evaluating x+y +result = 7:int + +two_contexts_example1 +k!0 + +error_code_example1 +last call succeeded. +last call failed. + +error_code_example2 +before Z3_mk_iff +Z3 error: type error. + +parser_example1 +formula 0: (> x y) +formula 1: (> x 0) +sat +y -> 0 +x -> 1 + + +parser_example2 +formula: (> x y) +sat +y -> -1 +x -> 0 + + +parser_example3 +assert axiom: +(forall (x Int) (y Int) (= (g x y) (g y x)) :qid {k!1}) +formula: (forall (x Int) (y Int) (implies (= x y) (= (g x 0) (g 0 y))) :qid {k!1}) +valid + +parser_example4 +declaration 0: (define y Int) +declaration 1: (define sk_hack Bool Bool) +declaration 2: (define x Int) +assumption 0: (= x 20) +formula 0: (> x y) +formula 1: (> x 0) + +parser_example5 +Z3 error: parser error. +Error message: 'ERROR: line 1 column 41: could not find sort symbol 'y'. +'. + +ite_example +term: (if false 1 0) + +enum_example +(define apple[fruit:0] fruit) +(define banana[fruit:1] fruit) +(define orange[fruit:2] fruit) +(define is_apple[fruit:0] fruit Bool) +(define is_banana[fruit:1] fruit Bool) +(define is_orange[fruit:2] fruit Bool) +valid +valid +invalid +counterexample: + +valid +valid + +unsat_core_and_proof_example +unsat +proof: [unit-resolution + [def-axiom (or (or (not PredA) PredC (not PredB)) (not PredC))] + [unit-resolution + [def-axiom (or (or (not PredA) (not PredB) (not PredC)) PredC)] + [unit-resolution + [mp + [asserted (or (and PredA PredB PredC) P1)] + [monotonicity + [rewrite + (iff (and PredA PredB PredC) + (not (or (not PredA) (not PredB) (not PredC))))] + (iff (or (and PredA PredB PredC) P1) + (or (not (or (not PredA) (not PredB) (not PredC))) P1))] + (or (not (or (not PredA) (not PredB) (not PredC))) P1)] + [asserted (not P1)] + (not (or (not PredA) (not PredB) (not PredC)))] + PredC] + [unit-resolution + [mp + [asserted (or (and PredA (not PredC) PredB) P2)] + [monotonicity + [rewrite + (iff (and PredA (not PredC) PredB) + (not (or (not PredA) PredC (not PredB))))] + (iff (or (and PredA (not PredC) PredB) P2) + (or (not (or (not PredA) PredC (not PredB))) P2))] + (or (not (or (not PredA) PredC (not PredB))) P2)] + [asserted (not P2)] + (not (or (not PredA) PredC (not PredB)))] + false] + +core: +(not P2) +(not P1) + + +abstract_example +formula: (> x y) +abstracted formula: (> #0 y) + +get_implied_equalities example +Class a |-> 0 +Class b |-> 0 +Class c |-> 0 +Class d |-> 3 +Class (f a) |-> 0 +Class (f b) |-> 0 +Class (f c) |-> 0 +asserting f(a) <= b +Class a |-> 0 +Class b |-> 0 +Class c |-> 0 +Class d |-> 3 +Class (f a) |-> 0 +Class (f b) |-> 0 +Class (f c) |-> 0 diff --git a/ml/test_theory.ml b/ml/test_theory.ml new file mode 100644 index 000000000..8732bf220 --- /dev/null +++ b/ml/test_theory.ml @@ -0,0 +1,42 @@ +module Z3 = Z3.V3 + +let print_lbool lb = + match lb with + | Z3.L_FALSE -> Printf.printf "false\n" + | Z3.L_TRUE -> Printf.printf "true\n" + | Z3.L_UNDEF -> Printf.printf "undef\n" + +(* simple sanity test of theory plugin *) +let test_theory() = + let ctx = Z3.mk_context_x [| |] in + let th = Z3.mk_theory ctx "test-theory" in + let _ = Z3.set_push_callback th (fun () -> Printf.printf "push\n") in + let _ = Z3.set_pop_callback th (fun () -> Printf.printf "pop\n") in + let _ = Z3.set_delete_callback th (fun () -> Printf.printf "delete\n") in + let _ = Z3.set_final_check_callback th (fun () -> (Printf.printf "final\n"; true)) in + let _ = Z3.set_delete_callback th (fun () -> Printf.printf "deleted\n") in + let f_sym = Z3.mk_string_symbol ctx "f" in + let a_sym = Z3.mk_string_symbol ctx "a" in + let b_sym = Z3.mk_string_symbol ctx "b" in + let int_sort = Z3.mk_int_sort ctx in + let f = Z3.theory_mk_func_decl ctx th f_sym [|int_sort |] int_sort in + let a = Z3.theory_mk_constant ctx th a_sym int_sort in + let b = Z3.theory_mk_constant ctx th b_sym int_sort in + let reduce_f g args = + Printf.printf "reduce %s\n" (Z3.func_decl_to_string ctx g); + match g, args with + | _, [| a' |] when Z3.is_eq_func_decl ctx g f && Z3.is_eq_ast ctx a' a -> Some b + | _, _ -> None + in + let _ = Z3.set_reduce_app_callback th reduce_f in + (* b != f(b) is consistent *) + let _ = Z3.assert_cnstr ctx (Z3.mk_not ctx (Z3.mk_eq ctx b (Z3.mk_app ctx f [| b |]))) in + let res = Z3.check ctx in + print_lbool res; + (* b != f(a) is not consistent *) + let _ = Z3.assert_cnstr ctx (Z3.mk_not ctx (Z3.mk_eq ctx b (Z3.mk_app ctx f [| a |]))) in + let res = Z3.check ctx in + print_lbool res; + Z3.del_context ctx + +let _ = test_theory() diff --git a/ml/update-ml-doc.cmd b/ml/update-ml-doc.cmd new file mode 100644 index 000000000..9d2409153 --- /dev/null +++ b/ml/update-ml-doc.cmd @@ -0,0 +1,36 @@ +@echo off +SETLOCAL + +call ..\tools\ocaml\win32\setup.cmd + +rd 2>NUL /s /q doc +md doc +cd doc +set MLDIR=.. +set DOCDIR=..\%1 + +ocamldoc.opt.exe -hide Z3,Z3.V3,Test_mlapi -html -css-style z3_ml.css -I %MLDIR% %MLDIR%\test_mlapi.ml %MLDIR%\z3.mli + +..\sed.exe "s|
val\(.*\)
|
val\1
|g;s|
type\(.*\)
|
type\1
|g;s|type\(.*\) = |
type\1 =
|g" Z3.html > Z3.new.html +move >NUL Z3.new.html Z3.html + +..\sed.exe "s|
val\(.*\)
|
val\1
|g" Test_mlapi.html > Test_mlapi.new.html +move >NUL Test_mlapi.new.html Test_mlapi.html + +..\sed.exe "s|

Index of values

|

OCaml: Index

|" Index_values.html > Index_values.new.html +move >NUL Index_values.new.html Index_values.html + +copy >NUL %DOCDIR%\tabs.css +copy >NUL %DOCDIR%\z3.png +copy >NUL %DOCDIR%\z3_ml.css + +..\sed.exe "1,23d" Test_mlapi.html | ..\sed.exe "$d" > Test_mlapi.new.html + +type 2>NUL %DOCDIR%\test_mlapi_header.html Test_mlapi.new.html %DOCDIR%\mldoc_footer.html >Test_mlapi.html + +..\sed.exe "1,37d" Z3.html > Z3.new.html + +type 2>NUL %DOCDIR%\z3_mlapi_header.html Z3.new.html >Z3.html + +exit /B 0 +ENDLOCAL diff --git a/ml/x3.ml b/ml/x3.ml new file mode 100644 index 000000000..6ca5d49eb --- /dev/null +++ b/ml/x3.ml @@ -0,0 +1,366 @@ +/* Copyright (c) Microsoft Corporation */ + +quote (ml," + +(* Internal auxiliary functions: *) +(* +(* Transform a pair of arrays into an array of pairs *) +let array_combine a b = + if Array.length a <> Array.length b then raise (Invalid_argument \"array_combine\"); + Array.init (Array.length a) (fun i -> (a.(i), b.(i))) + +(* [a |> b] is the pipeline operator for [b(a)] *) +let ( |> ) x f = f x +*) + +(* Find the index of an element in an array, raises Not_found is missing *) +let find equal x a = + let len = Array.length a in + let rec find_ i = + if i >= len then + raise Not_found + else + if equal x a.(i) then + i + else + find_ (i+1) + in + find_ 0 + + +(* Symbols *) + +let symbol_refine c s = + match get_symbol_kind c s with + | INT_SYMBOL -> Symbol_int (get_symbol_int c s) + | STRING_SYMBOL -> Symbol_string (get_symbol_string c s) + +let mk_symbol c = function + | Symbol_int(i) -> mk_int_symbol c i + | Symbol_string(s) -> mk_string_symbol c s + + +(* Sorts *) + +let get_datatype_sort c s = + Array.init (get_datatype_sort_num_constructors c s) (fun i -> + let constructor = get_datatype_sort_constructor c s i in + let recognizer = get_datatype_sort_recognizer c s i in + let accessors = + Array.init (get_domain_size c constructor) (fun j -> + get_datatype_sort_constructor_accessor c s i j + ) in + {constructor; recognizer; accessors} + ) + +let sort_refine c s = + match get_sort_kind c s with + | UNINTERPRETED_SORT -> Sort_uninterpreted (get_sort_name c s) + | BOOL_SORT -> Sort_bool + | INT_SORT -> Sort_int + | BV_SORT -> Sort_bv (get_bv_sort_size c s) + | FINITE_DOMAIN_SORT -> + (match get_finite_domain_sort_size c s with + | Some(sz) -> Sort_finite_domain (get_sort_name c s, sz) + | None -> failwith \"Z3.sort_refine: failed to get size of finite-domain sort\" + ) + | REAL_SORT -> Sort_real + | ARRAY_SORT -> Sort_array (get_array_sort_domain c s, get_array_sort_range c s) + | DATATYPE_SORT -> Sort_datatype (get_datatype_sort c s) + | RELATION_SORT -> Sort_relation (Array.init (get_relation_arity c s) (fun i -> get_relation_column c s i)) + | UNKNOWN_SORT -> Sort_unknown + +let mk_sort c = function + | Sort_uninterpreted(s) -> mk_uninterpreted_sort c s + | Sort_bool -> mk_bool_sort c + | Sort_int -> mk_int_sort c + | Sort_bv(size) -> mk_bv_sort c size + | Sort_finite_domain(name,size) -> mk_finite_domain_sort c name size + | Sort_real -> mk_real_sort c + | Sort_array(domain,range) -> mk_array_sort c domain range + | Sort_datatype(constructors) -> get_range c constructors.(0).constructor + | Sort_relation(_) -> invalid_arg \"Z3.mk_sort: cannot construct relation sorts\" + | Sort_unknown(_) -> invalid_arg \"Z3.mk_sort: cannot construct unknown sorts\" + + +(* Replacement datatypes creation API *) + +let mk_datatypes ctx generator = + let usort0 = mk_uninterpreted_sort ctx (mk_int_symbol ctx 0) + in + let rec find_num_sorts i = + if i = max_int then invalid_arg \"mk_datatypes: too many sorts\" + else + match generator (Array.make i usort0) with + | None -> find_num_sorts (i+1) + | Some(a) when Array.length a = i -> i + | Some _ -> invalid_arg \"mk_datatypes: number of sorts and datatype descriptors must be equal\" + in + let num_sorts = find_num_sorts 0 + in + let sorts0 = Array.init num_sorts (fun i -> mk_uninterpreted_sort ctx (mk_int_symbol ctx i)) + in + let ctorss_descriptors = + match generator sorts0 with + | Some(ctorss_descriptors) -> ctorss_descriptors + | None -> invalid_arg \"mk_datatypes: generator failed\" + in + let names = Array.map fst ctorss_descriptors + in + let ctorss = + Array.map (fun (_, ctors_descriptor) -> + Array.map (fun {constructor_desc; recognizer_desc; accessor_descs} -> + let field_names = Array.map fst accessor_descs + in + let sort_refs = Array.make (Array.length accessor_descs) 0 + in + let field_sorts = + Array.mapi (fun i (_, sort) -> + try + let j = find (fun s t -> is_eq_sort ctx s t) sort sorts0 in + sort_refs.(i) <- j ; + None + with Not_found -> + Some(sort) + ) accessor_descs + in + mk_constructor ctx constructor_desc recognizer_desc field_names field_sorts sort_refs + ) ctors_descriptor + ) ctorss_descriptors + in + let constructor_lists = Array.map (mk_constructor_list ctx) ctorss + in + let sorts,_ = mk_datatypes ctx names constructor_lists + in + let datatypes = + Array.mapi (fun i sort -> + (sort, + Array.mapi (fun j ctor -> + let num_fields = Array.length (snd ctorss_descriptors.(i)).(j).accessor_descs in + let constructor, recognizer, accessors = query_constructor ctx ctor num_fields in + {constructor; recognizer; accessors} + ) ctorss.(i)) + ) sorts + in + Array.iter (fun ctor_list -> + del_constructor_list ctx ctor_list + ) constructor_lists + ; + Array.iter (fun ctors -> + Array.iter (fun ctor -> + del_constructor ctx ctor + ) ctors + ) ctorss + ; + datatypes + + +(* Numerals *) + +let rec numeral_refine c t = + assert( get_ast_kind c t = NUMERAL_AST ); + let sort = get_sort c t in + let is_int, i = get_numeral_int c t in + if is_int then + Numeral_int (i, sort) + else + let is_int64, i = get_numeral_int64 c t in + if is_int64 then + Numeral_int64 (i, sort) + else + if get_sort_kind c sort <> REAL_SORT then + Numeral_large (get_numeral_string c t, sort) + else + let n = numeral_refine c (get_numerator c t) in + let d = numeral_refine c (get_denominator c t) in + Numeral_rational (n, d) + + +let to_real c x = + if get_sort_kind c (get_sort c x) = REAL_SORT then + x + else + mk_int2real c x + +let rec embed_numeral c = function + | Numeral_int (i, s) -> mk_int c i s + | Numeral_int64 (i, s) -> mk_int64 c i s + | Numeral_large (l, s) -> mk_numeral c l s + | Numeral_rational (Numeral_int(n,_), Numeral_int(d,_)) -> mk_real c n d + | Numeral_rational (n, d) -> + mk_div c (to_real c (embed_numeral c n)) (to_real c (embed_numeral c d)) + (* Or should the following be used instead? + let n_str = get_numeral_string c (embed_numeral c n) in + let d_str = get_numeral_string c (embed_numeral c d) in + mk_numeral c (n_str ^ \" / \" ^ d_str) (mk_real_sort c) + *) + +(* Terms *) + +let get_app_args c a = + Array.init (get_app_num_args c a) (get_app_arg c a);; + +let get_domains c d = + Array.init (get_domain_size c d) (get_domain c d);; + + +let get_pattern_terms c p = + Array.init (get_pattern_num_terms c p) (get_pattern c p) + + +let term_refine c t = + match get_ast_kind c t with + | NUMERAL_AST -> + Term_numeral (numeral_refine c t) + | APP_AST -> + let t' = to_app c t in + let f = get_app_decl c t' in + let num_args = get_app_num_args c t' in + let args = Array.init num_args (get_app_arg c t') in + let k = get_decl_kind c f in + Term_app (k, f, args) + | QUANTIFIER_AST -> + let bt = if is_quantifier_forall c t then Forall else Exists in + let w = get_quantifier_weight c t in + let np = get_quantifier_num_patterns c t in + let pats = Array.init np (get_quantifier_pattern_ast c t) in + let pats = Array.map (get_pattern_terms c) pats in + let nb = get_quantifier_num_bound c t in + let bound = + Array.init nb (fun i -> + (get_quantifier_bound_name c t i, get_quantifier_bound_sort c t i) + ) in + let body = get_quantifier_body c t in + Term_quantifier (bt, w, pats, bound, body) + | VAR_AST -> + Term_var (get_index_value c t, get_sort c t) + | _ -> + assert false + + +(* let mk_term c = function *) +(* | Term_numeral (numeral, sort) -> mk_numeral c numeral sort *) +(* | Term_app (kind, decl, args) -> *) +(* | Term_quantifier (strength, weight, pats, bound, body) -> *) +(* | Term_var (index, sort) -> *) + + + +(* Refined model API *) + +let model_refine c m = + let num_sorts = model_get_num_sorts c m in + let sorts = Hashtbl.create num_sorts in + for i = 0 to num_sorts - 1 do + let sort = model_get_sort c m i in + let universe = model_get_sort_universe c m sort in + Hashtbl.add sorts sort universe + done; + let num_consts = model_get_num_consts c m in + let consts = Hashtbl.create num_consts in + let arrays = Hashtbl.create 0 in + for i = 0 to num_consts - 1 do + let const_decl = model_get_const_decl c m i in + match model_get_const_interp c m const_decl with + | Some(const_interp) -> + if is_as_array c const_interp then + let array_decl = get_as_array_func_decl c const_interp in + match model_get_func_interp c m array_decl with + | Some(array_interp) -> + let num_entries = func_interp_get_num_entries c array_interp in + let tbl = Hashtbl.create num_entries in + for i = 0 to num_entries - 1 do + let entry = func_interp_get_entry c array_interp i in + assert( func_entry_get_num_args c entry = 1 ); + let arg = func_entry_get_arg c entry 0 in + let value = func_entry_get_value c entry in + Hashtbl.add tbl arg value + done; + let default = func_interp_get_else c array_interp in + Hashtbl.add arrays const_decl (tbl, default) + | None -> + () + else + Hashtbl.add consts const_decl const_interp + | None -> + () + done; + let num_funcs = model_get_num_funcs c m in + let funcs = Hashtbl.create num_funcs in + for i = 0 to num_funcs - 1 do + let func_decl = model_get_func_decl c m i in + if not (Hashtbl.mem arrays func_decl) then + match model_get_func_interp c m func_decl with + | Some(func_interp) -> + let num_entries = func_interp_get_num_entries c func_interp in + let tbl = Hashtbl.create num_entries in + for i = 0 to num_entries - 1 do + let entry = func_interp_get_entry c func_interp i in + let num_args = func_entry_get_num_args c entry in + let args = Array.init num_args (fun i -> func_entry_get_arg c entry i) in + let value = func_entry_get_value c entry in + Hashtbl.add tbl args value + done; + let default = func_interp_get_else c func_interp in + Hashtbl.add funcs func_decl (tbl, default) + | None -> + () + done; + {sorts; consts; arrays; funcs} + + +(* Extended parser API *) + +let get_smtlib_formulas c = + Array.init (get_smtlib_num_formulas c) (get_smtlib_formula c) + +let get_smtlib_assumptions c = + Array.init (get_smtlib_num_assumptions c) (get_smtlib_assumption c) + +let get_smtlib_decls c = + Array.init (get_smtlib_num_decls c) (get_smtlib_decl c) + +let get_smtlib_parse_results c = + (get_smtlib_formulas c, get_smtlib_assumptions c, get_smtlib_decls c) + +let parse_smtlib_string_x c a1 a2 a3 a4 a5 = + parse_smtlib_string c a1 a2 a3 a4 a5 ; + get_smtlib_parse_results c + +let parse_smtlib_file_x c a1 a2 a3 a4 a5 = + parse_smtlib_file c a1 a2 a3 a4 a5 ; + get_smtlib_parse_results c + +let parse_smtlib_string_formula c a1 a2 a3 a4 a5 = + parse_smtlib_string c a1 a2 a3 a4 a5 ; + match get_smtlib_formulas c with [|f|] -> f | _ -> failwith \"Z3: parse_smtlib_string_formula\" + +let parse_smtlib_file_formula c a1 a2 a3 a4 a5 = + parse_smtlib_file c a1 a2 a3 a4 a5 ; + match get_smtlib_formulas c with [|f|] -> f | _ -> failwith \"Z3: parse_smtlib_file_formula\" + + +(* Error handling *) + +let get_error_msg c e = + match e with + | PARSER_ERROR -> (get_error_msg_ex c e) ^ \": \" ^ (get_smtlib_error c) + | _ -> get_error_msg_ex c e + + +(* Refined stats API *) + +let stats_refine c s = + let num_stats = stats_size c s in + let tbl = Hashtbl.create num_stats in + for i = 0 to num_stats - 1 do + let key = stats_get_key c s i in + let datum = + if stats_is_uint c s i then + Stat_int(stats_get_uint_value c s i) + else + Stat_float(stats_get_double_value c s i) in + Hashtbl.add tbl key datum + done; + tbl +"); diff --git a/ml/x3V3.ml b/ml/x3V3.ml new file mode 100644 index 000000000..96156f0a8 --- /dev/null +++ b/ml/x3V3.ml @@ -0,0 +1,378 @@ +quote (ml," + + +(* Internal auxillary functions: *) + +(* Transform a pair of arrays into an array of pairs *) +let array_combine a b = + if Array.length a <> Array.length b then raise (Invalid_argument \"array_combine\"); + Array.init (Array.length a) (fun i->(a.(i),b.(i)));; + +(* [a |> b] is the pipeline operator for [b(a)] *) +let ( |> ) x f = f x;; + + +(* Extensions, except for refinement: *) +let mk_context_x configs = + let config = mk_config() in + let f(param_id,param_value) = set_param_value config param_id param_value in + Array.iter f configs; + let context = mk_context config in + del_config config; + context;; + +let get_app_args c a = + Array.init (get_app_num_args c a) (get_app_arg c a);; + +let get_domains c d = + Array.init (get_domain_size c d) (get_domain c d);; + +let get_array_sort c t = (get_array_sort_domain c t, get_array_sort_range c t);; + +let get_tuple_sort c ty = + (get_tuple_sort_mk_decl c ty, + Array.init (get_tuple_sort_num_fields c ty) (get_tuple_sort_field_decl c ty));; + +type datatype_constructor_refined = { + constructor : func_decl; + recognizer : func_decl; + accessors : func_decl array +} + +let get_datatype_sort c ty = + Array.init (get_datatype_sort_num_constructors c ty) + (fun idx_c -> + let constr = get_datatype_sort_constructor c ty idx_c in + let recog = get_datatype_sort_recognizer c ty idx_c in + let num_acc = get_domain_size c constr in + { constructor = constr; + recognizer = recog; + accessors = Array.init num_acc (get_datatype_sort_constructor_accessor c ty idx_c); + }) + +let get_model_constants c m = + Array.init (get_model_num_constants c m) (get_model_constant c m);; + + +let get_model_func_entry c m i j = + (Array.init + (get_model_func_entry_num_args c m i j) + (get_model_func_entry_arg c m i j), + get_model_func_entry_value c m i j);; + +let get_model_func_entries c m i = + Array.init (get_model_func_num_entries c m i) (get_model_func_entry c m i);; + +let get_model_funcs c m = + Array.init (get_model_num_funcs c m) + (fun i->(get_model_func_decl c m i |> get_decl_name c, + get_model_func_entries c m i, + get_model_func_else c m i));; + +let get_smtlib_formulas c = + Array.init (get_smtlib_num_formulas c) (get_smtlib_formula c);; + +let get_smtlib_assumptions c = + Array.init (get_smtlib_num_assumptions c) (get_smtlib_assumption c);; + +let get_smtlib_decls c = + Array.init (get_smtlib_num_decls c) (get_smtlib_decl c);; + +let get_smtlib_parse_results c = + (get_smtlib_formulas c, get_smtlib_assumptions c, get_smtlib_decls c);; + +let parse_smtlib_string_formula c a1 a2 a3 a4 a5 = + (parse_smtlib_string c a1 a2 a3 a4 a5; + match get_smtlib_formulas c with [|f|] -> f | _ -> failwith \"Z3: parse_smtlib_string_formula\");; + +let parse_smtlib_file_formula c a1 a2 a3 a4 a5 = + (parse_smtlib_file c a1 a2 a3 a4 a5; + match get_smtlib_formulas c with [|f|] -> f | _ -> failwith \"Z3: parse_smtlib_file_formula\");; + +let parse_smtlib_string_x c a1 a2 a3 a4 a5 = + (parse_smtlib_string c a1 a2 a3 a4 a5; get_smtlib_parse_results c);; + +let parse_smtlib_file_x c a1 a2 a3 a4 a5 = + (parse_smtlib_file c a1 a2 a3 a4 a5; get_smtlib_parse_results c);; + +(* Refinement: *) + +type symbol_refined = + | Symbol_int of int + | Symbol_string of string + | Symbol_unknown;; + +let symbol_refine c s = + match get_symbol_kind c s with + | INT_SYMBOL -> Symbol_int (get_symbol_int c s) + | STRING_SYMBOL -> Symbol_string (get_symbol_string c s);; + +type sort_refined = + | Sort_uninterpreted of symbol + | Sort_bool + | Sort_int + | Sort_real + | Sort_bv of int + | Sort_array of (sort * sort) + | Sort_datatype of datatype_constructor_refined array + | Sort_relation + | Sort_finite_domain + | Sort_unknown of symbol;; + +let sort_refine c ty = + match get_sort_kind c ty with + | UNINTERPRETED_SORT -> Sort_uninterpreted (get_sort_name c ty) + | BOOL_SORT -> Sort_bool + | INT_SORT -> Sort_int + | REAL_SORT -> Sort_real + | BV_SORT -> Sort_bv (get_bv_sort_size c ty) + | ARRAY_SORT -> Sort_array (get_array_sort_domain c ty, get_array_sort_range c ty) + | DATATYPE_SORT -> Sort_datatype (get_datatype_sort c ty) + | RELATION_SORT -> Sort_relation + | FINITE_DOMAIN_SORT -> Sort_finite_domain + | UNKNOWN_SORT -> Sort_unknown (get_sort_name c ty);; + +let get_pattern_terms c p = + Array.init (get_pattern_num_terms c p) (get_pattern c p) + +type binder_type = | Forall | Exists + +type numeral_refined = + | Numeral_small of int64 * int64 + | Numeral_large of string + +type term_refined = + | Term_app of decl_kind * func_decl * ast array + | Term_quantifier of binder_type * int * ast array array * (symbol *sort) array * ast + | Term_numeral of numeral_refined * sort + | Term_var of int * sort + +let term_refine c t = + match get_ast_kind c t with + | NUMERAL_AST -> + let (is_small, n, d) = get_numeral_small c t in + if is_small then + Term_numeral(Numeral_small(n,d), get_sort c t) + else + Term_numeral(Numeral_large(get_numeral_string c t), get_sort c t) + | APP_AST -> + let t' = to_app c t in + let f = get_app_decl c t' in + let num_args = get_app_num_args c t' in + let args = Array.init num_args (get_app_arg c t') in + let k = get_decl_kind c f in + Term_app (k, f, args) + | QUANTIFIER_AST -> + let bt = if is_quantifier_forall c t then Forall else Exists in + let w = get_quantifier_weight c t in + let np = get_quantifier_num_patterns c t in + let pats = Array.init np (get_quantifier_pattern_ast c t) in + let pats = Array.map (get_pattern_terms c) pats in + let nb = get_quantifier_num_bound c t in + let bound = Array.init nb + (fun i -> (get_quantifier_bound_name c t i, get_quantifier_bound_sort c t i)) in + let body = get_quantifier_body c t in + Term_quantifier(bt, w, pats, bound, body) + | VAR_AST -> + Term_var(get_index_value c t, get_sort c t) + | _ -> assert false + +type theory_callbacks = + { + mutable delete_theory : unit -> unit; + mutable reduce_eq : ast -> ast -> ast option; + mutable reduce_app : func_decl -> ast array -> ast option; + mutable reduce_distinct : ast array -> ast option; + mutable final_check : unit -> bool; + mutable new_app : ast -> unit; + mutable new_elem : ast -> unit; + mutable init_search: unit -> unit; + mutable push: unit -> unit; + mutable pop: unit -> unit; + mutable restart : unit -> unit; + mutable reset: unit -> unit; + mutable new_eq : ast -> ast -> unit; + mutable new_diseq : ast -> ast -> unit; + mutable new_assignment: ast -> bool -> unit; + mutable new_relevant : ast -> unit; + } + +let mk_theory_callbacks() = + { + delete_theory = (fun () -> ()); + reduce_eq = (fun _ _ -> None); + reduce_app = (fun _ _ -> None); + reduce_distinct = (fun _ -> None); + final_check = (fun _ -> true); + new_app = (fun _ -> ()); + new_elem = (fun _ -> ()); + init_search= (fun () -> ()); + push= (fun () -> ()); + pop= (fun () -> ()); + restart = (fun () -> ()); + reset= (fun () -> ()); + new_eq = (fun _ _ -> ()); + new_diseq = (fun _ _ -> ()); + new_assignment = (fun _ _ -> ()); + new_relevant = (fun _ -> ()); + } + + +external get_theory_callbacks : theory -> theory_callbacks = \"get_theory_callbacks\" +external mk_theory_register : context -> string -> theory_callbacks -> theory = \"mk_theory_register\" +external set_delete_callback_register : theory -> unit = \"set_delete_callback_register\" +external set_reduce_app_callback_register : theory -> unit = \"set_reduce_app_callback_register\" +external set_reduce_eq_callback_register : theory -> unit = \"set_reduce_eq_callback_register\" +external set_reduce_distinct_callback_register : theory -> unit = \"set_reduce_distinct_callback_register\" +external set_new_app_callback_register : theory -> unit = \"set_new_app_callback_register\" +external set_new_elem_callback_register : theory -> unit = \"set_new_elem_callback_register\" +external set_init_search_callback_register : theory -> unit = \"set_init_search_callback_register\" +external set_push_callback_register : theory -> unit = \"set_push_callback_register\" +external set_pop_callback_register : theory -> unit = \"set_pop_callback_register\" +external set_restart_callback_register : theory -> unit = \"set_restart_callback_register\" +external set_reset_callback_register : theory -> unit = \"set_reset_callback_register\" +external set_final_check_callback_register : theory -> unit = \"set_final_check_callback_register\" +external set_new_eq_callback_register : theory -> unit = \"set_new_eq_callback_register\" +external set_new_diseq_callback_register : theory -> unit = \"set_new_diseq_callback_register\" +external set_new_assignment_callback_register : theory -> unit = \"set_new_assignment_callback_register\" +external set_new_relevant_callback_register : theory -> unit = \"set_new_relevant_callback_register\" + +let is_some opt = + match opt with + | Some v -> true + | None -> false + +let get_some opt = + match opt with + | Some v -> v + | None -> failwith \"None unexpected\" + + + + +let apply_delete (th:theory_callbacks) = th.delete_theory () +let set_delete_callback th cb = + let cbs = get_theory_callbacks th in + cbs.delete_theory <- cb; + set_delete_callback_register th + +let mk_theory context name = + Callback.register \"is_some\" is_some; + Callback.register \"get_some\" get_some; + Callback.register \"apply_delete\" apply_delete; + let cbs = mk_theory_callbacks() in + mk_theory_register context name cbs + + +let apply_reduce_app (th:theory_callbacks) f args = th.reduce_app f args +let set_reduce_app_callback th cb = + Callback.register \"apply_reduce_app\" apply_reduce_app; + let cbs = get_theory_callbacks th in + cbs.reduce_app <- cb; + set_reduce_app_callback_register th + +let apply_reduce_eq (th:theory_callbacks) a b = th.reduce_eq a b +let set_reduce_eq_callback th cb = + Callback.register \"apply_reduce_eq\" apply_reduce_eq; + let cbs = get_theory_callbacks th in + cbs.reduce_eq <- cb; + set_reduce_eq_callback_register th + +let apply_reduce_distinct (th:theory_callbacks) args = th.reduce_distinct args +let set_reduce_distinct_callback th cb = + Callback.register \"apply_reduce_distinct\" apply_reduce_distinct; + let cbs = get_theory_callbacks th in + cbs.reduce_distinct <- cb; + set_reduce_distinct_callback_register th + + +let apply_new_app (th:theory_callbacks) a = th.new_app a +let set_new_app_callback th cb = + Callback.register \"apply_new_app\" apply_new_app; + let cbs = get_theory_callbacks th in + cbs.new_app <- cb; + set_new_app_callback_register th + +let apply_new_elem (th:theory_callbacks) a = th.new_elem a +let set_new_elem_callback th cb = + Callback.register \"apply_new_elem\" apply_new_elem; + let cbs = get_theory_callbacks th in + cbs.new_elem <- cb; + set_new_elem_callback_register th + + +let apply_init_search (th:theory_callbacks) = th.init_search() +let set_init_search_callback th cb = + Callback.register \"apply_init_search\" apply_init_search; + let cbs = get_theory_callbacks th in + cbs.init_search <- cb; + set_init_search_callback_register th + + +let apply_push (th:theory_callbacks) = th.push() +let set_push_callback th cb = + Callback.register \"apply_push\" apply_push; + let cbs = get_theory_callbacks th in + cbs.push <- cb; + set_push_callback_register th + +let apply_pop (th:theory_callbacks) = th.pop() +let set_pop_callback th cb = + Callback.register \"apply_pop\" apply_pop; + let cbs = get_theory_callbacks th in + cbs.pop <- cb; + set_pop_callback_register th + + +let apply_restart (th:theory_callbacks) = th.restart() +let set_restart_callback th cb = + Callback.register \"apply_restart\" apply_restart; + let cbs = get_theory_callbacks th in + cbs.restart <- cb; + set_restart_callback_register th + + +let apply_reset (th:theory_callbacks) = th.reset() +let set_reset_callback th cb = + Callback.register \"apply_reset\" apply_reset; + let cbs = get_theory_callbacks th in + cbs.reset <- cb; + set_reset_callback_register th + +let apply_final_check (th:theory_callbacks) = th.final_check() +let set_final_check_callback th cb = + Callback.register \"apply_final_check\" apply_final_check; + let cbs = get_theory_callbacks th in + cbs.final_check <- cb; + set_final_check_callback_register th + +let apply_new_eq (th:theory_callbacks) a b = th.new_eq a b +let set_new_eq_callback th cb = + Callback.register \"apply_new_eq\" apply_new_eq; + let cbs = get_theory_callbacks th in + cbs.new_eq <- cb; + set_new_eq_callback_register th + + +let apply_new_diseq (th:theory_callbacks) a b = th.new_diseq a b +let set_new_diseq_callback th cb = + Callback.register \"apply_new_diseq\" apply_new_diseq; + let cbs = get_theory_callbacks th in + cbs.new_diseq <- cb; + set_new_diseq_callback_register th + +let apply_new_assignment (th:theory_callbacks) a b = th.new_assignment a b +let set_new_assignment_callback th cb = + Callback.register \"apply_new_assignment\" apply_new_assignment; + let cbs = get_theory_callbacks th in + cbs.new_assignment <- cb; + set_new_assignment_callback_register th + +let apply_new_relevant (th:theory_callbacks) a = th.new_relevant a +let set_new_relevant_callback th cb = + Callback.register \"apply_new_relevant\" apply_new_relevant; + let cbs = get_theory_callbacks th in + cbs.new_relevant <- cb; + set_new_relevant_callback_register th + +"); diff --git a/ml/x3V3.mli b/ml/x3V3.mli new file mode 100644 index 000000000..2aa2ba4e7 --- /dev/null +++ b/ml/x3V3.mli @@ -0,0 +1,361 @@ + +quote (mli," + +(** {2 {L ML Extensions}} *) + +(** + \[ [ mk_context_x configs] \] is a shorthand for the context with configurations in [configs]. +*) +val mk_context_x: (string * string) array -> context;; + +(** + \[ [ get_app_args c a ] \] is the array of arguments of an application. If [t] is a constant, then the array is empty. + + - {b See also}: {!Z3.get_app_num_args} + - {b See also}: {!Z3.get_app_arg} +*) +val get_app_args: context -> app -> ast array + +(** + \[ [ get_app_args c d ] \] is the array of parameters of [d]. + + - {b See also}: {!Z3.get_domain_size} + - {b See also}: {!Z3.get_domain} +*) +val get_domains: context -> func_decl -> sort array + +(** + \[ [ get_array_sort c t ] \] is the domain and the range of [t]. + + - {b See also}: {!Z3.get_array_sort_domain} + - {b See also}: {!Z3.get_array_sort_range} +*) +val get_array_sort: context -> sort -> sort * sort + +(** + \[ [ get_tuple_sort c ty ] \] is the pair [(mk_decl, fields)] where [mk_decl] is the constructor declaration of [ty], and [fields] is the array of fields in [ty]. + + - {b See also}: {!Z3.get_tuple_sort_mk_decl} + - {b See also}: {!Z3.get_tuple_sort_num_fields} + - {b See also}: {!Z3.get_tuple_sort_field_decl} +*) +val get_tuple_sort: context -> sort -> (func_decl * func_decl array) + +(** + \[ [ datatype_constructor_refined ] \] is the refinement of a datatype constructor. + + It contains the constructor declaration, recognizer, and list of accessor functions. +*) +type datatype_constructor_refined = { + constructor : func_decl; + recognizer : func_decl; + accessors : func_decl array +} + +(** + \[ [ get_datatype_sort c ty ] \] is the array of triples [(constructor, recognizer, fields)] where [constructor] is the constructor declaration of [ty], [recognizer] is the recognizer for the [constructor], and [fields] is the array of fields in [ty]. + + - {b See also}: {!Z3.get_datatype_sort_num_constructors} + - {b See also}: {!Z3.get_datatype_sort_constructor} + - {b See also}: {!Z3.get_datatype_sort_recognizer} + - {b See also}: {!Z3.get_datatype_sort_constructor_accessor} +*) + + +val get_datatype_sort: context -> sort -> datatype_constructor_refined array + +(** + \[ [ get_model_constants c m ] \] is the array of constants in the model [m]. + + - {b See also}: {!Z3.get_model_num_constants} + - {b See also}: {!Z3.get_model_constant} +*) +val get_model_constants: context -> model -> func_decl array + + +(** + \[ [ get_model_func_entry c m i j ] \] is the [j]'th entry in the [i]'th function in the model [m]. + + - {b See also}: {!Z3.get_model_func_entry_num_args} + - {b See also}: {!Z3.get_model_func_entry_arg} + - {b See also}: {!Z3.get_model_func_entry_value} +*) +val get_model_func_entry: context -> model -> int -> int -> (ast array * ast);; + +(** + \[ [ get_model_func_entries c m i ] \] is the array of entries in the [i]'th function in the model [m]. + + - {b See also}: {!Z3.get_model_func_num_entries} + - {b See also}: {!Z3.get_model_func_entry} +*) +val get_model_func_entries: context -> model -> int -> (ast array * ast) array;; + +(** + \[ [ get_model_funcs c m ] \] is the array of functions in the model [m]. Each function is represented by the triple [(decl, entries, else)], where [decl] is the declaration name for the function, [entries] is the array of entries in the function, and [else] is the default (else) value for the function. + + - {b See also}: {!Z3.get_model_num_funcs} + - {b See also}: {!Z3.get_model_func_decl} + - {b See also}: {!Z3.get_model_func_entries} + - {b See also}: {!Z3.get_model_func_else} +*) +val get_model_funcs: context -> model -> + (symbol * + (ast array * ast) array * + ast) array + +(** + \[ [ get_smtlib_formulas c ] \] is the array of formulas created by a preceding call to {!Z3.parse_smtlib_string} or {!Z3.parse_smtlib_file}. + + Recommend use {!Z3.parse_smtlib_string_x} or {!Z3.parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. + + - {b See also}: {!Z3.parse_smtlib_string_x} + - {b See also}: {!Z3.parse_smtlib_file_x} + - {b See also}: {!Z3.parse_smtlib_string} + - {b See also}: {!Z3.parse_smtlib_file} + - {b See also}: {!Z3.get_smtlib_num_formulas} + - {b See also}: {!Z3.get_smtlib_formula} +*) +val get_smtlib_formulas: context -> ast array + +(** + \[ [get_smtlib_assumptions c] \] is the array of assumptions created by a preceding call to {!Z3.parse_smtlib_string} or {!Z3.parse_smtlib_file}. + + Recommend use {!Z3.parse_smtlib_string_x} or {!Z3.parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. + + + - {b See also}: {!Z3.parse_smtlib_string_x} + - {b See also}: {!Z3.parse_smtlib_file_x} + - {b See also}: {!Z3.parse_smtlib_string} + - {b See also}: {!Z3.parse_smtlib_file} + - {b See also}: {!Z3.get_smtlib_num_assumptions} + - {b See also}: {!Z3.get_smtlib_assumption} +*) +val get_smtlib_assumptions: context -> ast array + +(** + \[ [ get_smtlib_decls c ] \] is the array of declarations created by a preceding call to {!Z3.parse_smtlib_string} or {!Z3.parse_smtlib_file}. + + Recommend use {!Z3.parse_smtlib_string_x} or {!Z3.parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. + + + - {b See also}: {!Z3.parse_smtlib_string_x} + - {b See also}: {!Z3.parse_smtlib_file_x} + - {b See also}: {!Z3.parse_smtlib_string} + - {b See also}: {!Z3.parse_smtlib_file} + - {b See also}: {!Z3.get_smtlib_num_decls} + - {b See also}: {!Z3.get_smtlib_decl} +*) +val get_smtlib_decls: context -> func_decl array + +(** + \[ [ get_smtlib_parse_results c ] \] is the triple [(get_smtlib_formulas c, get_smtlib_assumptions c, get_smtlib_decls c)]. + + Recommend use {!Z3.parse_smtlib_string_x} or {!Z3.parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. + + + - {b See also}: {!Z3.parse_smtlib_string_x} + - {b See also}: {!Z3.parse_smtlib_file_x} + - {b See also}: {!Z3.parse_smtlib_string} + - {b See also}: {!Z3.parse_smtlib_file} + - {b See also}: {!Z3.get_smtlib_formulas} + - {b See also}: {!Z3.get_smtlib_assumptions} + - {b See also}: {!Z3.get_smtlib_decls} +*) +val get_smtlib_parse_results: context -> (ast array * ast array * func_decl array) + +(** + \[ [ parse_smtlib_string_formula c ... ] \] calls [(parse_smtlib_string c ...)] and returns the single formula produced. + + Recommended for functional style interface to the SMT-LIB parser. + + - {b See also}: {!Z3.parse_smtlib_file_formula} + - {b See also}: {!Z3.parse_smtlib_string_x} +*) +val parse_smtlib_string_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + +(** + \[ [ parse_smtlib_file_formula c ... ] \] calls [(parse_smtlib_file c ...)] and returns the single formula produced. + + Recommended for functional style interface to the SMT-LIB parser. + + - {b See also}: {!Z3.parse_smtlib_file_formula} + - {b See also}: {!Z3.parse_smtlib_file_x} +*) +val parse_smtlib_file_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + +(** + \[ [ parse_smtlib_string_x c ... ] \] is [(parse_smtlib_string c ...; get_smtlib_parse_results c)] + + Recommended for functional style interface to the SMT-LIB parser. + + - {b See also}: {!Z3.parse_smtlib_file_x} + - {b See also}: {!Z3.parse_smtlib_string} + - {b See also}: {!Z3.get_smtlib_parse_results} +*) +val parse_smtlib_string_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) + +(** + \[ [ parse_smtlib_file_x c ... ] \] is [(parse_smtlib_file c ...; get_smtlib_parse_results c)] + + Recommended for functional style interface to the SMT-LIB parser. + + - {b See also}: {!Z3.parse_smtlib_string_x} + - {b See also}: {!Z3.parse_smtlib_file} + - {b See also}: {!Z3.get_smtlib_parse_results} +*) +val parse_smtlib_file_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) + +(** + \[ [ symbol_refined ] \] is the refinement of a {!Z3.symbol} . + + - {b See also}: {!Z3.symbol_refine} + - {b See also}: {!Z3.get_symbol_kind} +*) +type symbol_refined = + | Symbol_int of int + | Symbol_string of string + | Symbol_unknown;; + +(** + \[ [ symbol_refine c s ] \] is the refined symbol of [s]. + + - {b See also}: {!Z3.symbol_refined} + - {b See also}: {!Z3.get_symbol_kind} +*) +val symbol_refine: context -> symbol -> symbol_refined;; + +(** + \[ [ sort_refined ] \] is the refinement of a {!Z3.sort} . + + - {b See also}: {!Z3.sort_refine} + - {b See also}: {!Z3.get_sort_kind} +*) + + +type sort_refined = + | Sort_uninterpreted of symbol + | Sort_bool + | Sort_int + | Sort_real + | Sort_bv of int + | Sort_array of (sort * sort) + | Sort_datatype of datatype_constructor_refined array + | Sort_relation + | Sort_finite_domain + | Sort_unknown of symbol + +(** + \[ [ sort_refine c t ] \] is the refined sort of [t]. + + - {b See also}: {!Z3.sort_refined} + - {b See also}: {!Z3.get_sort_kind} +*) +val sort_refine: context -> sort -> sort_refined;; + +(** + \[ [ binder_type ] \] is a universal or existential quantifier. + + - {b See also}: {!Z3.term_refined} +*) +type binder_type = | Forall | Exists + +(** + \[ [ numeral_refined ] \] is the refinement of a numeral . + + Numerals whose fractional representation can be fit with + 64 bit integers are treated as small. + +*) +type numeral_refined = + | Numeral_small of int64 * int64 + | Numeral_large of string + +(** + \[ [ term_refined ] \] is the refinement of a {!Z3.ast} . + + - {b See also}: {!Z3.term_refine} +*) +type term_refined = + | Term_app of decl_kind * func_decl * ast array + | Term_quantifier of binder_type * int * ast array array * (symbol * sort) array * ast + | Term_numeral of numeral_refined * sort + | Term_var of int * sort + +(** + \[ [ term_refine c a ] \] is the refined term of [a]. + + - {b See also}: {!Z3.term_refined} +*) +val term_refine : context -> ast -> term_refined + +(** + \[ [mk_theory c name ] \] create a custom theory. + +*) +val mk_theory : context -> string -> theory + +(** + \[ [set_delete_callback th cb] \] set callback when theory gets deleted. +*) +val set_delete_callback : theory -> (unit -> unit) -> unit + +(** + \[ [set_reduce_app_callback th cb] \] set callback for simplifying theory terms. +*) +val set_reduce_app_callback : theory -> (func_decl -> ast array -> ast option) -> unit + +(** + \[ [set_reduce_eq_callback th cb] \] set callback for simplifying equalities over theory terms. +*) +val set_reduce_eq_callback : theory -> (ast -> ast -> ast option) -> unit + +(** + \[ [set_reduce_distinct_callback th cb] \] set callback for simplifying disequalities over theory terms. +*) +val set_reduce_distinct_callback : theory -> (ast array -> ast option) -> unit + +(** + \[ [set_new_app_callback th cb] \] set callback for registering new application. +*) +val set_new_app_callback : theory -> (ast -> unit) -> unit + +(** + \[ [set_new_elem_callback th cb] \] set callback for registering new element. + + - {b See also}: the help for the corresponding C API function. +*) +val set_new_elem_callback : theory -> (ast -> unit) -> unit + +(** + \[ [set_init_search_callback th cb] \] set callback when Z3 starts searching for a satisfying assignment. +*) +val set_init_search_callback : theory -> (unit -> unit) -> unit + +(** + \[ [set_push_callback th cb] \] set callback for a logical context push. +*) +val set_push_callback : theory -> (unit -> unit) -> unit + +(** + \[ [set_pop_callback th cb] \] set callback for a logical context pop. +*) +val set_pop_callback : theory -> (unit -> unit) -> unit + +(** + \[ [set_restart_callback th cb] \] set callback for search restart. +*) +val set_restart_callback : theory -> (unit -> unit) -> unit + +val set_reset_callback : theory -> (unit -> unit) -> unit + +val set_final_check_callback : theory -> (unit -> bool) -> unit + +val set_new_eq_callback : theory -> (ast -> ast -> unit) -> unit + +val set_new_diseq_callback : theory -> (ast -> ast -> unit) -> unit + +val set_new_assignment_callback : theory -> (ast -> bool -> unit) -> unit + +val set_new_relevant_callback : theory -> (ast -> unit) -> unit + +"); diff --git a/ml/z3.idl b/ml/z3.idl new file mode 100644 index 000000000..2450e387d --- /dev/null +++ b/ml/z3.idl @@ -0,0 +1,607 @@ +/*++ +Copyright (c) Microsoft Corporation + +Module Name: + + Z3 + +Abstract: + + OCaml API for Z3. + + The following design is used for the treatment of reference counting: + + - The conversion of Z3_context from ML to C remembers the Z3 context, and + registers a finalizer using Gc.finalize that calls Z3_del_context. + + - The conversion of Z3_ast and other reference counted types from C to ML: + + + stores the last translated context with the Z3_ast in the wrapper + object; + + + registers a finalizer using Gc.finalize that decrements the reference + counter of the Z3_ast; + + + increments the reference count of the Z3_ast. + + The finalizers are registered using (the C interface to) Gc.finalize, + not attaching a finalizer to a custom block. The finalizers registered + by Gc.finalize are guaranteed to be called in reverse + registration-order, which is necessary to ensure that Z3_context's are + finalized only after all the Z3_ast's within them. + + - ML Z3.ast (and subtypes) are given generic hash and comparison + operations using Z3_get_ast_hash and Z3_get_ast_id. Other types could + be handled similarly if analogous hash and id operations were exported + by the C API. + + - The wrapper for Z3_mk_context is customized (using quote(call,...) in + z3_api.patched.h) to call Z3_mk_context_rc, and the ML API does not + include mk_context_rc. + + This scheme relies on the property that all reference counted values + returned from C to ML are in the Z3_context that was last sent from ML to + C. This is normally straightforward, but note that it depends on the + argument order of e.g. the Z3_*translate functions. + + Non-reference counted Z3 types that have delete operations have finalizers + that call the delete operations. The exposed delete operations are + shadowed by nop functions. The types whose delete operation accepts a + context use Gc.finalize while those that do not use custom block + finalizers. + + Custom c2ml functions check the Z3 error code prior to allocating ML + values or registering finalizers. Other functions check the Z3 error code + after making a Z3 library call. + + Some operations return NULL pointers when operations fail, or accept NULL + pointers. To handle these cases Z3_{ast,func_interp,sort}_opt types are + introduced. These are synonyms of Z3_{ast,func_interp,sort} but are + translated into OCaml option types. If the NULL pointers were passed to + ML, even if the user does not access them, they will have finalizers + registered, so when they die the OCaml GC will crash trying to call + dec_ref on NULL. + + There is an alternate implementation, enabled by setting LEAK_CONTEXTS, + that avoids the overhead of Gc.finalize finalizers, but at the price of + leaking Z3_context objects. + +Notes: + + OCaml does not support unsigned types, so CamlIDL conflates signed and + unsigned types of the same size. Therefore, functions in the C API + operating on unsigned values that become redundant after this conflation + are excluded from the ML API using [#ifndef CAMLIDL] in z3_api.h. + + CamlIDL does not support function pointers, so functions in the C API with + function pointer arguments are handled manually. + +Author: + + Jakob Lichtenberg (JakobL) 2007-08-08 + Josh Berdine (jjb) 2012-03-21 + +--*/ + + +// cpp trick to include expanded macro arguments in string literals +#define xstr(s) str(s) +#define str(s) #s +quote(c,"#define xstr(s) str(s)"); +quote(c,"#define str(s) #s"); + + +// CamlIDL (1.05) has a bug where it does not accept [unsigned] as a type, +// only as a specifier, so unsigned is defined to be unsigned int. +#define unsigned unsigned int + + +// Suppress "warning C4090: 'function' : different 'const' qualifiers" as +// CamlIDL does not seem to get this right. +quote(c,"#pragma warning(disable:4090)"); + + +#ifndef MLAPIV3 + +#define DEFINE_TYPE(T) typedef [abstract] void* T +#define DEFINE_VOID(T) typedef [abstract] void* T + +#define BEGIN_MLAPI_EXCLUDE quote(mli,"(*"); +#define END_MLAPI_EXCLUDE quote(mli,"*)"); + +#ifdef LEAK_CONTEXTS + + // Declare pointer type with custom conversion functions. + #define DEFINE_CUST_TYPE(T) \ + typedef [abstract, ml2c(ml2c_Z3_ ## T), c2ml(c2ml_Z3_ ## T)] void* Z3_ ## T + +#else + + // Declare pointer type with custom conversion functions. + // Register an OCaml closure that just calls a C finalization function. + #define DEFINE_CUST_TYPE(T) \ + quote(ml,xstr(\ + external finalize_Z3_ ## T : T -> unit = xstr(finalize_Z3_ ## T);; \ + let _ = Callback.register xstr(finalize_Z3_ ## T) finalize_Z3_ ## T \ + )); \ + typedef [abstract, ml2c(ml2c_Z3_ ## T), c2ml(c2ml_Z3_ ## T)] void* Z3_ ## T + +#endif + + +// Z3_context +quote(c," +void check_error_code (Z3_context c); + +Z3_context last_ctx; +"); + +#ifdef LEAK_CONTEXTS + + quote(c," + value c2ml_Z3_context(Z3_context* c) + { + value v; + v = caml_alloc_small(1, Abstract_tag); + *((Z3_context *) Bp_val(v)) = *c; + return v; + } + + void ml2c_Z3_context(value v, Z3_context* c) + { + *c = *((Z3_context *) Bp_val(v)); + last_ctx = *c; + } + "); + +#else + + quote(c," + // caml_final_register is the implementation of Gc.finalize + value caml_final_register (value f, value v); + + void register_finalizer(value** closure, char* name, Z3_context ctx, value v) + { + if (*closure == NULL) { + *closure = caml_named_value(name); + if (*closure == NULL) { + Z3_set_error(ctx, Z3_INTERNAL_FATAL); + return; + } + } + caml_final_register(**closure, v); + } + + value c2ml_Z3_context (Z3_context* c) + { + static value* finalize_Z3_context_closure = NULL; + value v; + v = caml_alloc_small(1, Abstract_tag); + Field(v, 0) = (value) *c; + register_finalizer(&finalize_Z3_context_closure, \"finalize_Z3_context\", + (Z3_context) *c, v); + return v; + } + + void ml2c_Z3_context (value v, Z3_context* c) + { + *c = (Z3_context) Field(v, 0); + last_ctx = *c; + } + + value finalize_Z3_context (value v) + { + Z3_context c; + c = (Z3_context) Field(v, 0); + Z3_del_context(c); + return Val_unit; + } + "); + +#endif + +DEFINE_CUST_TYPE(context); + + +// Z3_symbol +typedef [abstract] void* Z3_symbol; + + +// Z3_ast: reference counted type with hashing and comparison +quote(c," +typedef struct _Z3_ast_context { + Z3_ast ast; + Z3_context ctx; +} Z3_ast_context; + +void ml2c_Z3_ast (value v, Z3_ast* c) +{ + *c = ((Z3_ast_context*) Data_custom_val(v))->ast; +} + +static int compare_Z3_ast (value v1, value v2) +{ + Z3_ast_context* ac1; + Z3_ast_context* ac2; + unsigned id1, id2; + ac1 = Data_custom_val(v1); + ac2 = Data_custom_val(v2); + id1 = Z3_get_ast_id(ac1->ctx, ac1->ast); + check_error_code(ac1->ctx); + id2 = Z3_get_ast_id(ac2->ctx, ac2->ast); + check_error_code(ac2->ctx); + return id2 - id1; +} + +static intnat hash_Z3_ast (value v) +{ + Z3_ast_context* ac; + unsigned hash; + ac = Data_custom_val(v); + hash = Z3_get_ast_hash(ac->ctx, ac->ast); + check_error_code(ac->ctx); + return hash; +} +"); + +#ifdef LEAK_CONTEXTS + + quote(c," + static void finalize_Z3_ast (value v) + { + Z3_ast_context* ac; + ac = Data_custom_val(v); + Z3_dec_ref(ac->ctx, ac->ast); + check_error_code(ac->ctx); + } + + static struct custom_operations cops_Z3_ast = { + NULL, + finalize_Z3_ast, + compare_Z3_ast, + hash_Z3_ast, + custom_serialize_default, + custom_deserialize_default + }; + + value c2ml_Z3_ast (Z3_ast* c) + { + value v; + Z3_ast_context* ac; + check_error_code(last_ctx); + v = alloc_custom(&cops_Z3_ast, sizeof(Z3_ast_context), 0, 1); + ac = Data_custom_val(v); + ac->ctx = last_ctx; + ac->ast = *c; + Z3_inc_ref(ac->ctx, ac->ast); + return v; + } + "); + +#else + + quote(c," + value finalize_Z3_ast (value v) + { + Z3_ast_context* ac; + ac = Data_custom_val(v); + Z3_dec_ref(ac->ctx, ac->ast); + check_error_code(ac->ctx); + return Val_unit; + } + + static struct custom_operations cops_Z3_ast = { + NULL, + custom_finalize_default, + compare_Z3_ast, + hash_Z3_ast, + custom_serialize_default, + custom_deserialize_default + }; + + value c2ml_Z3_ast (Z3_ast* c) + { + static value* finalize_Z3_ast_closure = NULL; + value v; + Z3_ast_context* ac; + check_error_code(last_ctx); + v = caml_alloc_custom(&cops_Z3_ast, sizeof(Z3_ast_context), 0, 1); + ac = Data_custom_val(v); + ac->ast = *c; + ac->ctx = last_ctx; + register_finalizer(&finalize_Z3_ast_closure, \"finalize_Z3_ast\", + (Z3_context) *c, v); + Z3_inc_ref(last_ctx, *c); + return v; + } + "); + +#endif + +DEFINE_CUST_TYPE(ast); + + +// subtypes of Z3_ast +quote(c,"\ +#define DEFINE_SUBAST_OPS(T) \ + void ml2c_ ## T (value v, T * a) \ + { \ + ml2c_Z3_ast(v, (Z3_ast*) a); \ + } \ + \ + value c2ml_ ## T (T * a) \ + { \ + return c2ml_Z3_ast((Z3_ast*) a); \ + } \ +"); + +#define DEFINE_SUBAST(T) \ + typedef [mltype("private ast"), ml2c(ml2c_ ## T), c2ml(c2ml_ ## T)] Z3_ast T + +quote(c,"DEFINE_SUBAST_OPS(Z3_sort)"); DEFINE_SUBAST(Z3_sort); +quote(c,"DEFINE_SUBAST_OPS(Z3_func_decl)"); DEFINE_SUBAST(Z3_func_decl); +quote(c,"DEFINE_SUBAST_OPS(Z3_app)"); DEFINE_SUBAST(Z3_app); +quote(c,"DEFINE_SUBAST_OPS(Z3_pattern)"); DEFINE_SUBAST(Z3_pattern); + + +// reference counted types without hashing and comparison +#ifdef LEAK_CONTEXTS + + quote(c,"\ + #define DEFINE_RC_OPS(T) \ + typedef struct _ ## T ## _context { \ + T dat; \ + Z3_context ctx; \ + } T ## _context; \ + \ + static void finalize_ ## T (value v) \ + { \ + T ## _context* ac; \ + ac = Data_custom_val(v); \ + T ## _dec_ref(ac->ctx, ac->dat); \ + check_error_code(ac->ctx); \ + } \ + \ + static struct custom_operations cops_ ## T = { \ + NULL, \ + finalize_ ## T, \ + custom_compare_default, \ + custom_hash_default, \ + custom_serialize_default, \ + custom_deserialize_default \ + }; \ + \ + value c2ml_ ## T (T * c) \ + { \ + value v; \ + T ## _context* ac; \ + check_error_code(last_ctx); \ + v = alloc_custom(&cops_ ## T, sizeof(T ## _context), 0, 1); \ + ac = Data_custom_val(v); \ + ac->dat = *c; \ + ac->ctx = last_ctx; \ + T ## _inc_ref(ac->ctx, ac->dat); \ + return v; \ + } \ + \ + void ml2c_ ## T (value v, T * c) \ + { \ + *c = ((T ## _context*) Data_custom_val(v))->dat; \ + } \ + "); + +#else + + quote(c,"\ + #define DEFINE_RC_OPS(T) \ + value c2ml_ ## T (T * c) \ + { \ + static value* finalize_ ## T ## _closure = NULL; \ + value v; \ + check_error_code(last_ctx); \ + v = caml_alloc_small(2, Abstract_tag); \ + Field(v, 0) = (value) *c; \ + Field(v, 1) = (value) last_ctx; \ + register_finalizer(&finalize_ ## T ## _closure, xstr(finalize_ ## T), \ + (Z3_context) *c, v); \ + T ## _inc_ref(last_ctx, *c); \ + return v; \ + } \ + \ + void ml2c_ ## T (value v, T * c) \ + { \ + *c = (T) Field(v, 0); \ + } \ + \ + value finalize_ ## T (value v) \ + { \ + Z3_context c; \ + c = (Z3_context) Field(v, 1); \ + T ## _dec_ref(c, (T) Field(v, 0)); \ + check_error_code(c); \ + return Val_unit; \ + } \ + "); + +#endif + +quote(c,"DEFINE_RC_OPS(Z3_params)"); DEFINE_CUST_TYPE(params); +quote(c,"DEFINE_RC_OPS(Z3_param_descrs)"); DEFINE_CUST_TYPE(param_descrs); +quote(c,"DEFINE_RC_OPS(Z3_model)"); DEFINE_CUST_TYPE(model); +quote(c,"DEFINE_RC_OPS(Z3_func_interp)"); DEFINE_CUST_TYPE(func_interp); +quote(c,"DEFINE_RC_OPS(Z3_func_entry)"); DEFINE_CUST_TYPE(func_entry); +quote(c,"DEFINE_RC_OPS(Z3_fixedpoint)"); DEFINE_CUST_TYPE(fixedpoint); +quote(c,"DEFINE_RC_OPS(Z3_ast_vector)"); DEFINE_CUST_TYPE(ast_vector); +quote(c,"DEFINE_RC_OPS(Z3_ast_map)"); DEFINE_CUST_TYPE(ast_map); +quote(c,"DEFINE_RC_OPS(Z3_goal)"); DEFINE_CUST_TYPE(goal); +quote(c,"DEFINE_RC_OPS(Z3_tactic)"); DEFINE_CUST_TYPE(tactic); +quote(c,"DEFINE_RC_OPS(Z3_probe)"); DEFINE_CUST_TYPE(probe); +quote(c,"DEFINE_RC_OPS(Z3_apply_result)"); DEFINE_CUST_TYPE(apply_result); +quote(c,"DEFINE_RC_OPS(Z3_solver)"); DEFINE_CUST_TYPE(solver); +quote(c,"DEFINE_RC_OPS(Z3_stats)"); DEFINE_CUST_TYPE(stats); + + +// possibly-NULL pointer types, translated to OCaml option types +quote(c,"\ +#define DEFINE_OPT_OPS(T) \ + void ml2c_ ## T ## _opt (value v, T* c) \ + { \ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; \ + camlidl_ctx _ctx = &_ctxs; \ + if (v != Val_int(0)) { \ + camlidl_ml2c_z3_ ## T(Field(v, 0), c, _ctx); \ + } else { \ + *c = NULL; \ + } \ + } \ + \ + value c2ml_ ## T ## _opt (T* c) \ + { \ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; \ + camlidl_ctx _ctx = &_ctxs; \ + value v; \ + value a; \ + if (*c) { \ + a = camlidl_c2ml_z3_ ## T(c, _ctx); \ + Begin_root(a) \ + v = caml_alloc_small(1, 0); \ + Field(v, 0) = a; \ + End_roots(); \ + } else { \ + v = Val_int(0); \ + } \ + return v; \ + } +"); + +#define DEFINE_OPT_TYPE(T) \ + typedef [mltype(xstr(T option)), \ + ml2c(ml2c_Z3_ ## T ## _opt), \ + c2ml(c2ml_Z3_ ## T ## _opt) \ + ] Z3_ ## T Z3_ ## T ## _opt + +quote(c,"DEFINE_OPT_OPS(Z3_ast)"); +DEFINE_OPT_TYPE(ast); + +quote(c,"DEFINE_OPT_OPS(Z3_sort)"); +DEFINE_OPT_TYPE(sort); + +quote(c,"DEFINE_OPT_OPS(Z3_func_interp)"); +DEFINE_OPT_TYPE(func_interp); + + +// ToDo: these unnecessarily appear in the API documentation +DEFINE_TYPE(Z3_constructor); +DEFINE_TYPE(Z3_constructor_list); + + +// shadow delete operations with nops +quote(ml," +let del_constructor _ _ = () +let del_constructor_list _ _ = () +let del_model _ _ = () +let del_context _ = () +let reset_memory () = () +"); + + +#else // MLAPIV3 + +// Provide custom error handler: +quote (c,"Z3_error_handler caml_z3_error_handler;"); +quote (c,"void caml_z3_error_handler(Z3_context c, Z3_error_code e) { static char buffer[128]; char * msg = Z3_get_error_msg_ex(c, e); if (strlen(msg) > 100) { failwith(\"Z3: error message is too big to fit in buffer\"); } else { sprintf(buffer, \"Z3: %s\", msg); failwith(buffer); } }"); + + +#define DEFINE_TYPE(T) typedef [abstract] void* T +#define DEFINE_VOID(T) typedef [abstract] void* T + +#define BEGIN_MLAPI_EXCLUDE +#define END_MLAPI_EXCLUDE + +#endif // MLAPIV3 + + + +#ifndef __in +#define __in [in] +#endif + +#ifndef __out +#define __out [out] +#endif + +#ifndef __out_opt +#define __out_opt [out,unique] +#endif + +#ifndef __ecount +#define __ecount(num_args) [NOT_SUPPORTED] +#endif + +#ifndef __in_ecount +#define __in_ecount(num_args) [in, size_is(num_args), length_is(num_args)] +#endif + +#ifndef __out_ecount +#define __out_ecount(num_args) [out, size_is(num_args), length_is(num_args)] +#endif + +#ifndef __inout_ecount +#define __inout_ecount(num_args) [in, out, size_is(num_args), length_is(num_args)] +#endif + +#ifndef __inout +#define __inout [in, out] +#endif + +#ifndef Z3_bool_opt +#define Z3_bool_opt void +#endif + + +#define Z3_API + +#ifdef MLAPIV3 + +#include "z3V3_api.idl" +#include "x3V3.mli" +#include "x3V3.ml" + +#else + +#include "z3_api.idl" +#include "x3.ml" + +quote(ml," +let _ = + Printexc.register_printer (function + | Error(c,e) -> Some (\"Z3 \"^(get_error_msg c e)) + | _ -> None + ) +"); + + +quote(mli," +(** + {2 {L Legacy V3 API}} +*) + +module V3 : sig +(** + {2 {L Legacy V3 API}} +*) +"); + +quote(ml," +module V3 = struct +"); + +#endif + +#ifdef MLAPIV3 + +quote(mlmli," +end +"); + +#endif diff --git a/ml/z3.ml b/ml/z3.ml new file mode 100644 index 000000000..0a0ea0ccf --- /dev/null +++ b/ml/z3.ml @@ -0,0 +1,3498 @@ +(* File generated from z3.idl *) + +type context +and symbol +and ast +and sort = private ast +and func_decl = private ast +and app = private ast +and pattern = private ast +and params +and param_descrs +and model +and func_interp +and func_entry +and fixedpoint +and ast_vector +and ast_map +and goal +and tactic +and probe +and apply_result +and solver +and stats + + + +and constructor +and constructor_list + +and lbool = + | L_FALSE + | L_UNDEF + | L_TRUE + +and symbol_kind = + | INT_SYMBOL + | STRING_SYMBOL + +and parameter_kind = + | PARAMETER_INT + | PARAMETER_DOUBLE + | PARAMETER_RATIONAL + | PARAMETER_SYMBOL + | PARAMETER_SORT + | PARAMETER_AST + | PARAMETER_FUNC_DECL + +and sort_kind = + | UNINTERPRETED_SORT + | BOOL_SORT + | INT_SORT + | REAL_SORT + | BV_SORT + | ARRAY_SORT + | DATATYPE_SORT + | RELATION_SORT + | FINITE_DOMAIN_SORT + | UNKNOWN_SORT + +and ast_kind = + | NUMERAL_AST + | APP_AST + | VAR_AST + | QUANTIFIER_AST + | SORT_AST + | FUNC_DECL_AST + | UNKNOWN_AST + +and decl_kind = + | OP_TRUE + | OP_FALSE + | OP_EQ + | OP_DISTINCT + | OP_ITE + | OP_AND + | OP_OR + | OP_IFF + | OP_XOR + | OP_NOT + | OP_IMPLIES + | OP_OEQ + | OP_ANUM + | OP_AGNUM + | OP_LE + | OP_GE + | OP_LT + | OP_GT + | OP_ADD + | OP_SUB + | OP_UMINUS + | OP_MUL + | OP_DIV + | OP_IDIV + | OP_REM + | OP_MOD + | OP_TO_REAL + | OP_TO_INT + | OP_IS_INT + | OP_POWER + | OP_STORE + | OP_SELECT + | OP_CONST_ARRAY + | OP_ARRAY_MAP + | OP_ARRAY_DEFAULT + | OP_SET_UNION + | OP_SET_INTERSECT + | OP_SET_DIFFERENCE + | OP_SET_COMPLEMENT + | OP_SET_SUBSET + | OP_AS_ARRAY + | OP_BNUM + | OP_BIT1 + | OP_BIT0 + | OP_BNEG + | OP_BADD + | OP_BSUB + | OP_BMUL + | OP_BSDIV + | OP_BUDIV + | OP_BSREM + | OP_BUREM + | OP_BSMOD + | OP_BSDIV0 + | OP_BUDIV0 + | OP_BSREM0 + | OP_BUREM0 + | OP_BSMOD0 + | OP_ULEQ + | OP_SLEQ + | OP_UGEQ + | OP_SGEQ + | OP_ULT + | OP_SLT + | OP_UGT + | OP_SGT + | OP_BAND + | OP_BOR + | OP_BNOT + | OP_BXOR + | OP_BNAND + | OP_BNOR + | OP_BXNOR + | OP_CONCAT + | OP_SIGN_EXT + | OP_ZERO_EXT + | OP_EXTRACT + | OP_REPEAT + | OP_BREDOR + | OP_BREDAND + | OP_BCOMP + | OP_BSHL + | OP_BLSHR + | OP_BASHR + | OP_ROTATE_LEFT + | OP_ROTATE_RIGHT + | OP_EXT_ROTATE_LEFT + | OP_EXT_ROTATE_RIGHT + | OP_INT2BV + | OP_BV2INT + | OP_CARRY + | OP_XOR3 + | OP_PR_UNDEF + | OP_PR_TRUE + | OP_PR_ASSERTED + | OP_PR_GOAL + | OP_PR_MODUS_PONENS + | OP_PR_REFLEXIVITY + | OP_PR_SYMMETRY + | OP_PR_TRANSITIVITY + | OP_PR_TRANSITIVITY_STAR + | OP_PR_MONOTONICITY + | OP_PR_QUANT_INTRO + | OP_PR_DISTRIBUTIVITY + | OP_PR_AND_ELIM + | OP_PR_NOT_OR_ELIM + | OP_PR_REWRITE + | OP_PR_REWRITE_STAR + | OP_PR_PULL_QUANT + | OP_PR_PULL_QUANT_STAR + | OP_PR_PUSH_QUANT + | OP_PR_ELIM_UNUSED_VARS + | OP_PR_DER + | OP_PR_QUANT_INST + | OP_PR_HYPOTHESIS + | OP_PR_LEMMA + | OP_PR_UNIT_RESOLUTION + | OP_PR_IFF_TRUE + | OP_PR_IFF_FALSE + | OP_PR_COMMUTATIVITY + | OP_PR_DEF_AXIOM + | OP_PR_DEF_INTRO + | OP_PR_APPLY_DEF + | OP_PR_IFF_OEQ + | OP_PR_NNF_POS + | OP_PR_NNF_NEG + | OP_PR_NNF_STAR + | OP_PR_CNF_STAR + | OP_PR_SKOLEMIZE + | OP_PR_MODUS_PONENS_OEQ + | OP_PR_TH_LEMMA + | OP_RA_STORE + | OP_RA_EMPTY + | OP_RA_IS_EMPTY + | OP_RA_JOIN + | OP_RA_UNION + | OP_RA_WIDEN + | OP_RA_PROJECT + | OP_RA_FILTER + | OP_RA_NEGATION_FILTER + | OP_RA_RENAME + | OP_RA_COMPLEMENT + | OP_RA_SELECT + | OP_RA_CLONE + | OP_FD_LT + | OP_LABEL + | OP_LABEL_LIT + | OP_DT_CONSTRUCTOR + | OP_DT_RECOGNISER + | OP_DT_ACCESSOR + | OP_UNINTERPRETED + +and param_kind = + | PK_UINT + | PK_BOOL + | PK_DOUBLE + | PK_SYMBOL + | PK_STRING + | PK_OTHER + | PK_INVALID + +and search_failure = + | NO_FAILURE + | UNKNOWN + | TIMEOUT + | MEMOUT_WATERMARK + | CANCELED + | NUM_CONFLICTS + | THEORY + | QUANTIFIERS + +and ast_print_mode = + | PRINT_SMTLIB_FULL + | PRINT_LOW_LEVEL + | PRINT_SMTLIB_COMPLIANT + | PRINT_SMTLIB2_COMPLIANT + +and error_code = + | OK + | SORT_ERROR + | IOB + | INVALID_ARG + | PARSER_ERROR + | NO_PARSER + | INVALID_PATTERN + | MEMOUT_FAIL + | FILE_ACCESS_ERROR + | INTERNAL_FATAL + | INVALID_USAGE + | DEC_REF_ERROR + | EXCEPTION + +and goal_prec = + | GOAL_PRECISE + | GOAL_UNDER + | GOAL_OVER + | GOAL_UNDER_OVER + + +external finalize_Z3_context : context -> unit = "finalize_Z3_context";; let _ = Callback.register "finalize_Z3_context" finalize_Z3_context +external finalize_Z3_ast : ast -> unit = "finalize_Z3_ast";; let _ = Callback.register "finalize_Z3_ast" finalize_Z3_ast +external finalize_Z3_params : params -> unit = "finalize_Z3_params";; let _ = Callback.register "finalize_Z3_params" finalize_Z3_params +external finalize_Z3_param_descrs : param_descrs -> unit = "finalize_Z3_param_descrs";; let _ = Callback.register "finalize_Z3_param_descrs" finalize_Z3_param_descrs +external finalize_Z3_model : model -> unit = "finalize_Z3_model";; let _ = Callback.register "finalize_Z3_model" finalize_Z3_model +external finalize_Z3_func_interp : func_interp -> unit = "finalize_Z3_func_interp";; let _ = Callback.register "finalize_Z3_func_interp" finalize_Z3_func_interp +external finalize_Z3_func_entry : func_entry -> unit = "finalize_Z3_func_entry";; let _ = Callback.register "finalize_Z3_func_entry" finalize_Z3_func_entry +external finalize_Z3_fixedpoint : fixedpoint -> unit = "finalize_Z3_fixedpoint";; let _ = Callback.register "finalize_Z3_fixedpoint" finalize_Z3_fixedpoint +external finalize_Z3_ast_vector : ast_vector -> unit = "finalize_Z3_ast_vector";; let _ = Callback.register "finalize_Z3_ast_vector" finalize_Z3_ast_vector +external finalize_Z3_ast_map : ast_map -> unit = "finalize_Z3_ast_map";; let _ = Callback.register "finalize_Z3_ast_map" finalize_Z3_ast_map +external finalize_Z3_goal : goal -> unit = "finalize_Z3_goal";; let _ = Callback.register "finalize_Z3_goal" finalize_Z3_goal +external finalize_Z3_tactic : tactic -> unit = "finalize_Z3_tactic";; let _ = Callback.register "finalize_Z3_tactic" finalize_Z3_tactic +external finalize_Z3_probe : probe -> unit = "finalize_Z3_probe";; let _ = Callback.register "finalize_Z3_probe" finalize_Z3_probe +external finalize_Z3_apply_result : apply_result -> unit = "finalize_Z3_apply_result";; let _ = Callback.register "finalize_Z3_apply_result" finalize_Z3_apply_result +external finalize_Z3_solver : solver -> unit = "finalize_Z3_solver";; let _ = Callback.register "finalize_Z3_solver" finalize_Z3_solver +external finalize_Z3_stats : stats -> unit = "finalize_Z3_stats";; let _ = Callback.register "finalize_Z3_stats" finalize_Z3_stats + +let del_constructor _ _ = () +let del_constructor_list _ _ = () +let del_model _ _ = () +let del_context _ = () +let reset_memory () = () + + +(** Exceptions raised by Z3. It is safe to continue interacting with Z3 after + catching [Error] exceptions. + + - {b See also}: {!get_error_msg} +*) +exception Error of context * error_code + + + +let _ = Callback.register_exception "Z3.Error" (Error (Obj.magic None, OK)) + +external mk_context: (string * string) list -> context = "caml_z3_mk_context" + +external update_param_value : context -> string -> string -> unit + = "camlidl_z3_Z3_update_param_value" + +external get_param_value : context -> string -> string option + = "camlidl_z3_Z3_get_param_value" + +external interrupt : context -> unit + = "camlidl_z3_Z3_interrupt" + +external mk_params : context -> params + = "camlidl_z3_Z3_mk_params" + +external params_set_bool : context -> params -> symbol -> bool -> unit + = "camlidl_z3_Z3_params_set_bool" + +external params_set_uint : context -> params -> symbol -> int -> unit + = "camlidl_z3_Z3_params_set_uint" + +external params_set_double : context -> params -> symbol -> float -> unit + = "camlidl_z3_Z3_params_set_double" + +external params_set_symbol : context -> params -> symbol -> symbol -> unit + = "camlidl_z3_Z3_params_set_symbol" + +external params_to_string : context -> params -> string + = "camlidl_z3_Z3_params_to_string" + +external params_validate : context -> params -> param_descrs -> unit + = "camlidl_z3_Z3_params_validate" + +external param_descrs_get_kind : context -> param_descrs -> symbol -> param_kind + = "camlidl_z3_Z3_param_descrs_get_kind" + +external param_descrs_size : context -> param_descrs -> int + = "camlidl_z3_Z3_param_descrs_size" + +external param_descrs_get_name : context -> param_descrs -> int -> symbol + = "camlidl_z3_Z3_param_descrs_get_name" + + +(** + Refined view of a {!symbol}. + + - {b See also}: {!mk_symbol} + - {b See also}: {!symbol_refine} +*) +type symbol_refined = + | Symbol_int of int + | Symbol_string of string + +external mk_int_symbol : context -> int -> symbol + = "camlidl_z3_Z3_mk_int_symbol" + +external mk_string_symbol : context -> string -> symbol + = "camlidl_z3_Z3_mk_string_symbol" + + +(** + A datatype constructor descriptor. +*) +type datatype_constructor_desc = { + constructor_desc : symbol; (** name of the constructor function *) + recognizer_desc : symbol; (** name of the recognizer function *) + accessor_descs : (symbol * sort) array; (** names and sorts of the fields *) +} + +(** + A datatype is described by a name and constructor descriptors. +*) +type datatype_desc = symbol * datatype_constructor_desc array + +(** + A datatype constructor representation. +*) +type datatype_constructor = { + constructor : func_decl; (** constructor function *) + recognizer : func_decl; (** recognizer function *) + accessors : func_decl array; (** field accessor functions *) +} + +(** + A datatype is represented by a sort and constructors. +*) +type datatype = sort * datatype_constructor array + +(** + Refined view of a {!sort}. + + - {b See also}: {!mk_sort} + - {b See also}: {!sort_refine} +*) +type sort_refined = + | Sort_uninterpreted of symbol + | Sort_bool + | Sort_int + | Sort_bv of int + | Sort_finite_domain of symbol * int64 + | Sort_real + | Sort_array of sort * sort + | Sort_datatype of datatype_constructor array + | Sort_relation of sort array + | Sort_unknown + +external mk_uninterpreted_sort : context -> symbol -> sort + = "camlidl_z3_Z3_mk_uninterpreted_sort" + +external mk_bool_sort : context -> sort + = "camlidl_z3_Z3_mk_bool_sort" + +external mk_int_sort : context -> sort + = "camlidl_z3_Z3_mk_int_sort" + +external mk_real_sort : context -> sort + = "camlidl_z3_Z3_mk_real_sort" + +external mk_bv_sort : context -> int -> sort + = "camlidl_z3_Z3_mk_bv_sort" + +external mk_finite_domain_sort : context -> symbol -> int64 -> sort + = "camlidl_z3_Z3_mk_finite_domain_sort" + +external mk_array_sort : context -> sort -> sort -> sort + = "camlidl_z3_Z3_mk_array_sort" + +external mk_tuple_sort : context -> symbol -> symbol array -> sort array -> sort * func_decl * func_decl array + = "camlidl_z3_Z3_mk_tuple_sort" + +external mk_enumeration_sort : context -> symbol -> symbol array -> sort * func_decl array * func_decl array + = "camlidl_z3_Z3_mk_enumeration_sort" + +external mk_list_sort : context -> symbol -> sort -> sort * func_decl * func_decl * func_decl * func_decl * func_decl * func_decl + = "camlidl_z3_Z3_mk_list_sort" + +external mk_constructor : context -> symbol -> symbol -> symbol array -> sort option array -> int array -> constructor + = "camlidl_z3_Z3_mk_constructor_bytecode" "camlidl_z3_Z3_mk_constructor" + +external del_constructor : context -> constructor -> unit + = "camlidl_z3_Z3_del_constructor" + +external mk_datatype : context -> symbol -> constructor array -> sort * constructor array + = "camlidl_z3_Z3_mk_datatype" + +external mk_constructor_list : context -> constructor array -> constructor_list + = "camlidl_z3_Z3_mk_constructor_list" + +external del_constructor_list : context -> constructor_list -> unit + = "camlidl_z3_Z3_del_constructor_list" + +external mk_datatypes : context -> symbol array -> constructor_list array -> sort array * constructor_list array + = "camlidl_z3_Z3_mk_datatypes" + +external query_constructor : context -> constructor -> int -> func_decl * func_decl * func_decl array + = "camlidl_z3_Z3_query_constructor" + +external mk_func_decl : context -> symbol -> sort array -> sort -> func_decl + = "camlidl_z3_Z3_mk_func_decl" + +external mk_app : context -> func_decl -> ast array -> ast + = "camlidl_z3_Z3_mk_app" + +external mk_const : context -> symbol -> sort -> ast + = "camlidl_z3_Z3_mk_const" + +external mk_fresh_func_decl : context -> string -> sort array -> sort -> func_decl + = "camlidl_z3_Z3_mk_fresh_func_decl" + +external mk_fresh_const : context -> string -> sort -> ast + = "camlidl_z3_Z3_mk_fresh_const" + +external mk_true : context -> ast + = "camlidl_z3_Z3_mk_true" + +external mk_false : context -> ast + = "camlidl_z3_Z3_mk_false" + +external mk_eq : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_eq" + +external mk_distinct : context -> ast array -> ast + = "camlidl_z3_Z3_mk_distinct" + +external mk_not : context -> ast -> ast + = "camlidl_z3_Z3_mk_not" + +external mk_ite : context -> ast -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_ite" + +external mk_iff : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_iff" + +external mk_implies : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_implies" + +external mk_xor : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_xor" + +external mk_and : context -> ast array -> ast + = "camlidl_z3_Z3_mk_and" + +external mk_or : context -> ast array -> ast + = "camlidl_z3_Z3_mk_or" + +external mk_add : context -> ast array -> ast + = "camlidl_z3_Z3_mk_add" + +external mk_mul : context -> ast array -> ast + = "camlidl_z3_Z3_mk_mul" + +external mk_sub : context -> ast array -> ast + = "camlidl_z3_Z3_mk_sub" + +external mk_unary_minus : context -> ast -> ast + = "camlidl_z3_Z3_mk_unary_minus" + +external mk_div : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_div" + +external mk_mod : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_mod" + +external mk_rem : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_rem" + +external mk_power : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_power" + +external mk_lt : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_lt" + +external mk_le : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_le" + +external mk_gt : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_gt" + +external mk_ge : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_ge" + +external mk_int2real : context -> ast -> ast + = "camlidl_z3_Z3_mk_int2real" + +external mk_real2int : context -> ast -> ast + = "camlidl_z3_Z3_mk_real2int" + +external mk_is_int : context -> ast -> ast + = "camlidl_z3_Z3_mk_is_int" + +external mk_bvnot : context -> ast -> ast + = "camlidl_z3_Z3_mk_bvnot" + +external mk_bvredand : context -> ast -> ast + = "camlidl_z3_Z3_mk_bvredand" + +external mk_bvredor : context -> ast -> ast + = "camlidl_z3_Z3_mk_bvredor" + +external mk_bvand : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvand" + +external mk_bvor : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvor" + +external mk_bvxor : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvxor" + +external mk_bvnand : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvnand" + +external mk_bvnor : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvnor" + +external mk_bvxnor : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvxnor" + +external mk_bvneg : context -> ast -> ast + = "camlidl_z3_Z3_mk_bvneg" + +external mk_bvadd : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvadd" + +external mk_bvsub : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsub" + +external mk_bvmul : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvmul" + +external mk_bvudiv : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvudiv" + +external mk_bvsdiv : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsdiv" + +external mk_bvurem : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvurem" + +external mk_bvsrem : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsrem" + +external mk_bvsmod : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsmod" + +external mk_bvult : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvult" + +external mk_bvslt : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvslt" + +external mk_bvule : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvule" + +external mk_bvsle : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsle" + +external mk_bvuge : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvuge" + +external mk_bvsge : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsge" + +external mk_bvugt : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvugt" + +external mk_bvsgt : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsgt" + +external mk_concat : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_concat" + +external mk_extract : context -> int -> int -> ast -> ast + = "camlidl_z3_Z3_mk_extract" + +external mk_sign_ext : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_sign_ext" + +external mk_zero_ext : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_zero_ext" + +external mk_repeat : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_repeat" + +external mk_bvshl : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvshl" + +external mk_bvlshr : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvlshr" + +external mk_bvashr : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvashr" + +external mk_rotate_left : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_rotate_left" + +external mk_rotate_right : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_rotate_right" + +external mk_ext_rotate_left : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_ext_rotate_left" + +external mk_ext_rotate_right : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_ext_rotate_right" + +external mk_int2bv : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_int2bv" + +external mk_bv2int : context -> ast -> bool -> ast + = "camlidl_z3_Z3_mk_bv2int" + +external mk_bvadd_no_overflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3_Z3_mk_bvadd_no_overflow" + +external mk_bvadd_no_underflow : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvadd_no_underflow" + +external mk_bvsub_no_overflow : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsub_no_overflow" + +external mk_bvsub_no_underflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3_Z3_mk_bvsub_no_underflow" + +external mk_bvsdiv_no_overflow : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsdiv_no_overflow" + +external mk_bvneg_no_overflow : context -> ast -> ast + = "camlidl_z3_Z3_mk_bvneg_no_overflow" + +external mk_bvmul_no_overflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3_Z3_mk_bvmul_no_overflow" + +external mk_bvmul_no_underflow : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvmul_no_underflow" + +external mk_select : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_select" + +external mk_store : context -> ast -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_store" + +external mk_const_array : context -> sort -> ast -> ast + = "camlidl_z3_Z3_mk_const_array" + +external mk_map : context -> func_decl -> int -> ast -> ast + = "camlidl_z3_Z3_mk_map" + +external mk_array_default : context -> ast -> ast + = "camlidl_z3_Z3_mk_array_default" + +external mk_set_sort : context -> sort -> sort + = "camlidl_z3_Z3_mk_set_sort" + +external mk_empty_set : context -> sort -> ast + = "camlidl_z3_Z3_mk_empty_set" + +external mk_full_set : context -> sort -> ast + = "camlidl_z3_Z3_mk_full_set" + +external mk_set_add : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_set_add" + +external mk_set_del : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_set_del" + +external mk_set_union : context -> ast array -> ast + = "camlidl_z3_Z3_mk_set_union" + +external mk_set_intersect : context -> ast array -> ast + = "camlidl_z3_Z3_mk_set_intersect" + +external mk_set_difference : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_set_difference" + +external mk_set_complement : context -> ast -> ast + = "camlidl_z3_Z3_mk_set_complement" + +external mk_set_member : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_set_member" + +external mk_set_subset : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_set_subset" + + +(** + Summary: \[ [ numeral_refined ] \] is the refined view of a numeral . +*) +type numeral_refined = + | Numeral_int of int * sort + | Numeral_int64 of int64 * sort + | Numeral_large of string * sort + | Numeral_rational of numeral_refined * numeral_refined + +external mk_numeral : context -> string -> sort -> ast + = "camlidl_z3_Z3_mk_numeral" + +external mk_real : context -> int -> int -> ast + = "camlidl_z3_Z3_mk_real" + +external mk_int : context -> int -> sort -> ast + = "camlidl_z3_Z3_mk_int" + +external mk_int64 : context -> int64 -> sort -> ast + = "camlidl_z3_Z3_mk_int64" + +external mk_pattern : context -> ast array -> pattern + = "camlidl_z3_Z3_mk_pattern" + +external mk_bound : context -> int -> sort -> ast + = "camlidl_z3_Z3_mk_bound" + +external mk_forall : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_forall_bytecode" "camlidl_z3_Z3_mk_forall" + +external mk_exists : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_exists_bytecode" "camlidl_z3_Z3_mk_exists" + +external mk_quantifier : context -> bool -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_bytecode" "camlidl_z3_Z3_mk_quantifier" + +external mk_quantifier_ex : context -> bool -> int -> symbol -> symbol -> pattern array -> ast array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_ex_bytecode" "camlidl_z3_Z3_mk_quantifier_ex" + +external mk_forall_const : context -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3_Z3_mk_forall_const" + +external mk_exists_const : context -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3_Z3_mk_exists_const" + +external mk_quantifier_const : context -> bool -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_const_bytecode" "camlidl_z3_Z3_mk_quantifier_const" + +external mk_quantifier_const_ex : context -> bool -> int -> symbol -> symbol -> app array -> pattern array -> ast array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_const_ex_bytecode" "camlidl_z3_Z3_mk_quantifier_const_ex" + +external get_symbol_kind : context -> symbol -> symbol_kind + = "camlidl_z3_Z3_get_symbol_kind" + +external get_symbol_int : context -> symbol -> int + = "camlidl_z3_Z3_get_symbol_int" + +external get_symbol_string : context -> symbol -> string + = "camlidl_z3_Z3_get_symbol_string" + +external get_sort_name : context -> sort -> symbol + = "camlidl_z3_Z3_get_sort_name" + +external get_sort_id : context -> sort -> int + = "camlidl_z3_Z3_get_sort_id" + +external sort_to_ast : context -> sort -> ast + = "camlidl_z3_Z3_sort_to_ast" + +external is_eq_sort : context -> sort -> sort -> bool + = "camlidl_z3_Z3_is_eq_sort" + +external get_sort_kind : context -> sort -> sort_kind + = "camlidl_z3_Z3_get_sort_kind" + +external get_bv_sort_size : context -> sort -> int + = "camlidl_z3_Z3_get_bv_sort_size" + +external get_finite_domain_sort_size : context -> sort -> int64 option + = "camlidl_z3_Z3_get_finite_domain_sort_size" + +external get_array_sort_domain : context -> sort -> sort + = "camlidl_z3_Z3_get_array_sort_domain" + +external get_array_sort_range : context -> sort -> sort + = "camlidl_z3_Z3_get_array_sort_range" + +external get_tuple_sort_mk_decl : context -> sort -> func_decl + = "camlidl_z3_Z3_get_tuple_sort_mk_decl" + +external get_tuple_sort_num_fields : context -> sort -> int + = "camlidl_z3_Z3_get_tuple_sort_num_fields" + +external get_tuple_sort_field_decl : context -> sort -> int -> func_decl + = "camlidl_z3_Z3_get_tuple_sort_field_decl" + +external get_datatype_sort_num_constructors : context -> sort -> int + = "camlidl_z3_Z3_get_datatype_sort_num_constructors" + +external get_datatype_sort_constructor : context -> sort -> int -> func_decl + = "camlidl_z3_Z3_get_datatype_sort_constructor" + +external get_datatype_sort_recognizer : context -> sort -> int -> func_decl + = "camlidl_z3_Z3_get_datatype_sort_recognizer" + +external get_datatype_sort_constructor_accessor : context -> sort -> int -> int -> func_decl + = "camlidl_z3_Z3_get_datatype_sort_constructor_accessor" + +external get_relation_arity : context -> sort -> int + = "camlidl_z3_Z3_get_relation_arity" + +external get_relation_column : context -> sort -> int -> sort + = "camlidl_z3_Z3_get_relation_column" + +external func_decl_to_ast : context -> func_decl -> ast + = "camlidl_z3_Z3_func_decl_to_ast" + +external is_eq_func_decl : context -> func_decl -> func_decl -> bool + = "camlidl_z3_Z3_is_eq_func_decl" + +external get_func_decl_id : context -> func_decl -> int + = "camlidl_z3_Z3_get_func_decl_id" + +external get_decl_name : context -> func_decl -> symbol + = "camlidl_z3_Z3_get_decl_name" + +external get_decl_kind : context -> func_decl -> decl_kind + = "camlidl_z3_Z3_get_decl_kind" + +external get_domain_size : context -> func_decl -> int + = "camlidl_z3_Z3_get_domain_size" + +external get_arity : context -> func_decl -> int + = "camlidl_z3_Z3_get_arity" + +external get_domain : context -> func_decl -> int -> sort + = "camlidl_z3_Z3_get_domain" + +external get_range : context -> func_decl -> sort + = "camlidl_z3_Z3_get_range" + +external get_decl_num_parameters : context -> func_decl -> int + = "camlidl_z3_Z3_get_decl_num_parameters" + +external get_decl_parameter_kind : context -> func_decl -> int -> parameter_kind + = "camlidl_z3_Z3_get_decl_parameter_kind" + +external get_decl_int_parameter : context -> func_decl -> int -> int + = "camlidl_z3_Z3_get_decl_int_parameter" + +external get_decl_double_parameter : context -> func_decl -> int -> float + = "camlidl_z3_Z3_get_decl_double_parameter" + +external get_decl_symbol_parameter : context -> func_decl -> int -> symbol + = "camlidl_z3_Z3_get_decl_symbol_parameter" + +external get_decl_sort_parameter : context -> func_decl -> int -> sort + = "camlidl_z3_Z3_get_decl_sort_parameter" + +external get_decl_ast_parameter : context -> func_decl -> int -> ast + = "camlidl_z3_Z3_get_decl_ast_parameter" + +external get_decl_func_decl_parameter : context -> func_decl -> int -> func_decl + = "camlidl_z3_Z3_get_decl_func_decl_parameter" + +external get_decl_rational_parameter : context -> func_decl -> int -> string + = "camlidl_z3_Z3_get_decl_rational_parameter" + +external app_to_ast : context -> app -> ast + = "camlidl_z3_Z3_app_to_ast" + +external get_app_decl : context -> app -> func_decl + = "camlidl_z3_Z3_get_app_decl" + +external get_app_num_args : context -> app -> int + = "camlidl_z3_Z3_get_app_num_args" + +external get_app_arg : context -> app -> int -> ast + = "camlidl_z3_Z3_get_app_arg" + + +(** + Summary: \[ [ binder_type ] \] is a universal or existential quantifier. + + - {b See also}: {!term_refined} +*) +type binder_type = Forall | Exists + +(** + Summary: \[ [ term_refined ] \] is the refinement of a {!ast} . + + - {b See also}: {!term_refine} +*) +type term_refined = + | Term_numeral of numeral_refined + | Term_app of decl_kind * func_decl * ast array + | Term_quantifier of binder_type * int * ast array array * (symbol * sort) array * ast + | Term_var of int * sort + +external is_eq_ast : context -> ast -> ast -> bool + = "camlidl_z3_Z3_is_eq_ast" + +external get_ast_id : context -> ast -> int + = "camlidl_z3_Z3_get_ast_id" + +external get_ast_hash : context -> ast -> int + = "camlidl_z3_Z3_get_ast_hash" + +external get_sort : context -> ast -> sort + = "camlidl_z3_Z3_get_sort" + +external is_well_sorted : context -> ast -> bool + = "camlidl_z3_Z3_is_well_sorted" + +external get_bool_value : context -> ast -> lbool + = "camlidl_z3_Z3_get_bool_value" + +external get_ast_kind : context -> ast -> ast_kind + = "camlidl_z3_Z3_get_ast_kind" + +external is_app : context -> ast -> bool + = "camlidl_z3_Z3_is_app" + +external is_numeral_ast : context -> ast -> bool + = "camlidl_z3_Z3_is_numeral_ast" + +external is_algebraic_number : context -> ast -> bool + = "camlidl_z3_Z3_is_algebraic_number" + +external to_app : context -> ast -> app + = "camlidl_z3_Z3_to_app" + +external to_func_decl : context -> ast -> func_decl + = "camlidl_z3_Z3_to_func_decl" + +external get_numeral_string : context -> ast -> string + = "camlidl_z3_Z3_get_numeral_string" + +external get_numeral_decimal_string : context -> ast -> int -> string + = "camlidl_z3_Z3_get_numeral_decimal_string" + +external get_numerator : context -> ast -> ast + = "camlidl_z3_Z3_get_numerator" + +external get_denominator : context -> ast -> ast + = "camlidl_z3_Z3_get_denominator" + +external get_numeral_small : context -> ast -> bool * int64 * int64 + = "camlidl_z3_Z3_get_numeral_small" + +external get_numeral_int : context -> ast -> bool * int + = "camlidl_z3_Z3_get_numeral_int" + +external get_numeral_int64 : context -> ast -> bool * int64 + = "camlidl_z3_Z3_get_numeral_int64" + +external get_numeral_rational_int64 : context -> ast -> bool * int64 * int64 + = "camlidl_z3_Z3_get_numeral_rational_int64" + +external get_algebraic_number_lower : context -> ast -> int -> ast + = "camlidl_z3_Z3_get_algebraic_number_lower" + +external get_algebraic_number_upper : context -> ast -> int -> ast + = "camlidl_z3_Z3_get_algebraic_number_upper" + +external pattern_to_ast : context -> pattern -> ast + = "camlidl_z3_Z3_pattern_to_ast" + +external get_pattern_num_terms : context -> pattern -> int + = "camlidl_z3_Z3_get_pattern_num_terms" + +external get_pattern : context -> pattern -> int -> ast + = "camlidl_z3_Z3_get_pattern" + +external get_index_value : context -> ast -> int + = "camlidl_z3_Z3_get_index_value" + +external is_quantifier_forall : context -> ast -> bool + = "camlidl_z3_Z3_is_quantifier_forall" + +external get_quantifier_weight : context -> ast -> int + = "camlidl_z3_Z3_get_quantifier_weight" + +external get_quantifier_num_patterns : context -> ast -> int + = "camlidl_z3_Z3_get_quantifier_num_patterns" + +external get_quantifier_pattern_ast : context -> ast -> int -> pattern + = "camlidl_z3_Z3_get_quantifier_pattern_ast" + +external get_quantifier_num_no_patterns : context -> ast -> int + = "camlidl_z3_Z3_get_quantifier_num_no_patterns" + +external get_quantifier_no_pattern_ast : context -> ast -> int -> ast + = "camlidl_z3_Z3_get_quantifier_no_pattern_ast" + +external get_quantifier_bound_name : context -> ast -> int -> symbol + = "camlidl_z3_Z3_get_quantifier_bound_name" + +external get_quantifier_bound_sort : context -> ast -> int -> sort + = "camlidl_z3_Z3_get_quantifier_bound_sort" + +external get_quantifier_body : context -> ast -> ast + = "camlidl_z3_Z3_get_quantifier_body" + +external get_quantifier_num_bound : context -> ast -> int + = "camlidl_z3_Z3_get_quantifier_num_bound" + +external simplify : context -> ast -> ast + = "camlidl_z3_Z3_simplify" + +external simplify_ex : context -> ast -> params -> ast + = "camlidl_z3_Z3_simplify_ex" + +external simplify_get_help : context -> string + = "camlidl_z3_Z3_simplify_get_help" + +external simplify_get_param_descrs : context -> param_descrs + = "camlidl_z3_Z3_simplify_get_param_descrs" + +external update_term : context -> ast -> ast array -> ast + = "camlidl_z3_Z3_update_term" + +external substitute : context -> ast -> ast array -> ast array -> ast + = "camlidl_z3_Z3_substitute" + +external substitute_vars : context -> ast -> ast array -> ast + = "camlidl_z3_Z3_substitute_vars" + +external translate : context -> ast -> context -> ast + = "camlidl_z3_Z3_translate" + + +(** + A model assigns uninterpreted sorts to finite universes of distinct values, constants to values, + and arrays and functions to finite maps from argument values to result values plus a default + value for all other arguments. +*) +type model_refined = { + sorts : (sort, ast_vector) Hashtbl.t; + consts : (func_decl, ast) Hashtbl.t; + arrays : (func_decl, (ast, ast) Hashtbl.t * ast) Hashtbl.t; + funcs : (func_decl, (ast array, ast) Hashtbl.t * ast) Hashtbl.t; +} + +external model_eval : context -> model -> ast -> bool -> ast option + = "camlidl_z3_Z3_model_eval" + +external model_get_const_interp : context -> model -> func_decl -> ast option + = "camlidl_z3_Z3_model_get_const_interp" + +external model_get_func_interp : context -> model -> func_decl -> func_interp option + = "camlidl_z3_Z3_model_get_func_interp" + +external model_get_num_consts : context -> model -> int + = "camlidl_z3_Z3_model_get_num_consts" + +external model_get_const_decl : context -> model -> int -> func_decl + = "camlidl_z3_Z3_model_get_const_decl" + +external model_get_num_funcs : context -> model -> int + = "camlidl_z3_Z3_model_get_num_funcs" + +external model_get_func_decl : context -> model -> int -> func_decl + = "camlidl_z3_Z3_model_get_func_decl" + +external model_get_num_sorts : context -> model -> int + = "camlidl_z3_Z3_model_get_num_sorts" + +external model_get_sort : context -> model -> int -> sort + = "camlidl_z3_Z3_model_get_sort" + +external model_get_sort_universe : context -> model -> sort -> ast_vector + = "camlidl_z3_Z3_model_get_sort_universe" + +external is_as_array : context -> ast -> bool + = "camlidl_z3_Z3_is_as_array" + +external get_as_array_func_decl : context -> ast -> func_decl + = "camlidl_z3_Z3_get_as_array_func_decl" + +external func_interp_get_num_entries : context -> func_interp -> int + = "camlidl_z3_Z3_func_interp_get_num_entries" + +external func_interp_get_entry : context -> func_interp -> int -> func_entry + = "camlidl_z3_Z3_func_interp_get_entry" + +external func_interp_get_else : context -> func_interp -> ast + = "camlidl_z3_Z3_func_interp_get_else" + +external func_interp_get_arity : context -> func_interp -> int + = "camlidl_z3_Z3_func_interp_get_arity" + +external func_entry_get_value : context -> func_entry -> ast + = "camlidl_z3_Z3_func_entry_get_value" + +external func_entry_get_num_args : context -> func_entry -> int + = "camlidl_z3_Z3_func_entry_get_num_args" + +external func_entry_get_arg : context -> func_entry -> int -> ast + = "camlidl_z3_Z3_func_entry_get_arg" + +external open_log : string -> bool + = "camlidl_z3_Z3_open_log" + +external append_log : string -> unit + = "camlidl_z3_Z3_append_log" + +external close_log : unit -> unit + = "camlidl_z3_Z3_close_log" + +external toggle_warning_messages : bool -> unit + = "camlidl_z3_Z3_toggle_warning_messages" + +external set_ast_print_mode : context -> ast_print_mode -> unit + = "camlidl_z3_Z3_set_ast_print_mode" + +external ast_to_string : context -> ast -> string + = "camlidl_z3_Z3_ast_to_string" + +external pattern_to_string : context -> pattern -> string + = "camlidl_z3_Z3_pattern_to_string" + +external sort_to_string : context -> sort -> string + = "camlidl_z3_Z3_sort_to_string" + +external func_decl_to_string : context -> func_decl -> string + = "camlidl_z3_Z3_func_decl_to_string" + +external model_to_string : context -> model -> string + = "camlidl_z3_Z3_model_to_string" + +external benchmark_to_smtlib_string : context -> string -> string -> string -> string -> ast array -> ast -> string + = "camlidl_z3_Z3_benchmark_to_smtlib_string_bytecode" "camlidl_z3_Z3_benchmark_to_smtlib_string" + +external parse_smtlib2_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + = "camlidl_z3_Z3_parse_smtlib2_string_bytecode" "camlidl_z3_Z3_parse_smtlib2_string" + +external parse_smtlib2_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + = "camlidl_z3_Z3_parse_smtlib2_file_bytecode" "camlidl_z3_Z3_parse_smtlib2_file" + +external parse_smtlib_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit + = "camlidl_z3_Z3_parse_smtlib_string_bytecode" "camlidl_z3_Z3_parse_smtlib_string" + +external parse_smtlib_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit + = "camlidl_z3_Z3_parse_smtlib_file_bytecode" "camlidl_z3_Z3_parse_smtlib_file" + +external get_smtlib_num_formulas : context -> int + = "camlidl_z3_Z3_get_smtlib_num_formulas" + +external get_smtlib_formula : context -> int -> ast + = "camlidl_z3_Z3_get_smtlib_formula" + +external get_smtlib_num_assumptions : context -> int + = "camlidl_z3_Z3_get_smtlib_num_assumptions" + +external get_smtlib_assumption : context -> int -> ast + = "camlidl_z3_Z3_get_smtlib_assumption" + +external get_smtlib_num_decls : context -> int + = "camlidl_z3_Z3_get_smtlib_num_decls" + +external get_smtlib_decl : context -> int -> func_decl + = "camlidl_z3_Z3_get_smtlib_decl" + +external get_smtlib_num_sorts : context -> int + = "camlidl_z3_Z3_get_smtlib_num_sorts" + +external get_smtlib_sort : context -> int -> sort + = "camlidl_z3_Z3_get_smtlib_sort" + +external get_smtlib_error : context -> string + = "camlidl_z3_Z3_get_smtlib_error" + +external parse_z3_string : context -> string -> ast + = "camlidl_z3_Z3_parse_z3_string" + +external parse_z3_file : context -> string -> ast + = "camlidl_z3_Z3_parse_z3_file" + +external set_error : context -> error_code -> unit + = "camlidl_z3_Z3_set_error" + +external get_error_msg_ex : context -> error_code -> string + = "camlidl_z3_Z3_get_error_msg_ex" + +external get_version : unit -> int * int * int * int + = "camlidl_z3_Z3_get_version" + +external mk_fixedpoint : context -> fixedpoint + = "camlidl_z3_Z3_mk_fixedpoint" + +external fixedpoint_add_rule : context -> fixedpoint -> ast -> symbol -> unit + = "camlidl_z3_Z3_fixedpoint_add_rule" + +external fixedpoint_add_fact : context -> fixedpoint -> func_decl -> int array -> unit + = "camlidl_z3_Z3_fixedpoint_add_fact" + +external fixedpoint_assert : context -> fixedpoint -> ast -> unit + = "camlidl_z3_Z3_fixedpoint_assert" + +external fixedpoint_query : context -> fixedpoint -> ast -> lbool + = "camlidl_z3_Z3_fixedpoint_query" + +external fixedpoint_query_relations : context -> fixedpoint -> func_decl array -> lbool + = "camlidl_z3_Z3_fixedpoint_query_relations" + +external fixedpoint_get_answer : context -> fixedpoint -> ast + = "camlidl_z3_Z3_fixedpoint_get_answer" + +external fixedpoint_get_reason_unknown : context -> fixedpoint -> string + = "camlidl_z3_Z3_fixedpoint_get_reason_unknown" + +external fixedpoint_update_rule : context -> fixedpoint -> ast -> symbol -> unit + = "camlidl_z3_Z3_fixedpoint_update_rule" + +external fixedpoint_get_num_levels : context -> fixedpoint -> func_decl -> int + = "camlidl_z3_Z3_fixedpoint_get_num_levels" + +external fixedpoint_get_cover_delta : context -> fixedpoint -> int -> func_decl -> ast + = "camlidl_z3_Z3_fixedpoint_get_cover_delta" + +external fixedpoint_add_cover : context -> fixedpoint -> int -> func_decl -> ast -> unit + = "camlidl_z3_Z3_fixedpoint_add_cover" + +external fixedpoint_get_statistics : context -> fixedpoint -> stats + = "camlidl_z3_Z3_fixedpoint_get_statistics" + +external fixedpoint_register_relation : context -> fixedpoint -> func_decl -> unit + = "camlidl_z3_Z3_fixedpoint_register_relation" + +external fixedpoint_set_predicate_representation : context -> fixedpoint -> func_decl -> symbol array -> unit + = "camlidl_z3_Z3_fixedpoint_set_predicate_representation" + +external fixedpoint_simplify_rules : context -> fixedpoint -> ast array -> func_decl array -> ast_vector + = "camlidl_z3_Z3_fixedpoint_simplify_rules" + +external fixedpoint_set_params : context -> fixedpoint -> params -> unit + = "camlidl_z3_Z3_fixedpoint_set_params" + +external fixedpoint_get_help : context -> fixedpoint -> string + = "camlidl_z3_Z3_fixedpoint_get_help" + +external fixedpoint_get_param_descrs : context -> fixedpoint -> param_descrs + = "camlidl_z3_Z3_fixedpoint_get_param_descrs" + +external fixedpoint_to_string : context -> fixedpoint -> ast array -> string + = "camlidl_z3_Z3_fixedpoint_to_string" + +external fixedpoint_push : context -> fixedpoint -> unit + = "camlidl_z3_Z3_fixedpoint_push" + +external fixedpoint_pop : context -> fixedpoint -> unit + = "camlidl_z3_Z3_fixedpoint_pop" + +external mk_ast_vector : context -> ast_vector + = "camlidl_z3_Z3_mk_ast_vector" + +external ast_vector_size : context -> ast_vector -> int + = "camlidl_z3_Z3_ast_vector_size" + +external ast_vector_get : context -> ast_vector -> int -> ast + = "camlidl_z3_Z3_ast_vector_get" + +external ast_vector_set : context -> ast_vector -> int -> ast -> unit + = "camlidl_z3_Z3_ast_vector_set" + +external ast_vector_resize : context -> ast_vector -> int -> unit + = "camlidl_z3_Z3_ast_vector_resize" + +external ast_vector_push : context -> ast_vector -> ast -> unit + = "camlidl_z3_Z3_ast_vector_push" + +external ast_vector_translate : context -> ast_vector -> context -> ast_vector + = "camlidl_z3_Z3_ast_vector_translate" + +external ast_vector_to_string : context -> ast_vector -> string + = "camlidl_z3_Z3_ast_vector_to_string" + +external mk_ast_map : context -> ast_map + = "camlidl_z3_Z3_mk_ast_map" + +external ast_map_contains : context -> ast_map -> ast -> bool + = "camlidl_z3_Z3_ast_map_contains" + +external ast_map_find : context -> ast_map -> ast -> ast + = "camlidl_z3_Z3_ast_map_find" + +external ast_map_insert : context -> ast_map -> ast -> ast -> unit + = "camlidl_z3_Z3_ast_map_insert" + +external ast_map_erase : context -> ast_map -> ast -> unit + = "camlidl_z3_Z3_ast_map_erase" + +external ast_map_reset : context -> ast_map -> unit + = "camlidl_z3_Z3_ast_map_reset" + +external ast_map_size : context -> ast_map -> int + = "camlidl_z3_Z3_ast_map_size" + +external ast_map_keys : context -> ast_map -> ast_vector + = "camlidl_z3_Z3_ast_map_keys" + +external ast_map_to_string : context -> ast_map -> string + = "camlidl_z3_Z3_ast_map_to_string" + +external mk_goal : context -> bool -> bool -> bool -> goal + = "camlidl_z3_Z3_mk_goal" + +external goal_precision : context -> goal -> goal_prec + = "camlidl_z3_Z3_goal_precision" + +external goal_assert : context -> goal -> ast -> unit + = "camlidl_z3_Z3_goal_assert" + +external goal_inconsistent : context -> goal -> bool + = "camlidl_z3_Z3_goal_inconsistent" + +external goal_depth : context -> goal -> int + = "camlidl_z3_Z3_goal_depth" + +external goal_reset : context -> goal -> unit + = "camlidl_z3_Z3_goal_reset" + +external goal_size : context -> goal -> int + = "camlidl_z3_Z3_goal_size" + +external goal_formula : context -> goal -> int -> ast + = "camlidl_z3_Z3_goal_formula" + +external goal_num_exprs : context -> goal -> int + = "camlidl_z3_Z3_goal_num_exprs" + +external goal_is_decided_sat : context -> goal -> bool + = "camlidl_z3_Z3_goal_is_decided_sat" + +external goal_is_decided_unsat : context -> goal -> bool + = "camlidl_z3_Z3_goal_is_decided_unsat" + +external goal_translate : context -> goal -> context -> goal + = "camlidl_z3_Z3_goal_translate" + +external goal_to_string : context -> goal -> string + = "camlidl_z3_Z3_goal_to_string" + +external mk_tactic : context -> string -> tactic + = "camlidl_z3_Z3_mk_tactic" + +external mk_probe : context -> string -> probe + = "camlidl_z3_Z3_mk_probe" + +external tactic_and_then : context -> tactic -> tactic -> tactic + = "camlidl_z3_Z3_tactic_and_then" + +external tactic_or_else : context -> tactic -> tactic -> tactic + = "camlidl_z3_Z3_tactic_or_else" + +external tactic_par_or : context -> tactic array -> tactic + = "camlidl_z3_Z3_tactic_par_or" + +external tactic_par_and_then : context -> tactic -> tactic -> tactic + = "camlidl_z3_Z3_tactic_par_and_then" + +external tactic_try_for : context -> tactic -> int -> tactic + = "camlidl_z3_Z3_tactic_try_for" + +external tactic_when : context -> probe -> tactic -> tactic + = "camlidl_z3_Z3_tactic_when" + +external tactic_cond : context -> probe -> tactic -> tactic -> tactic + = "camlidl_z3_Z3_tactic_cond" + +external tactic_repeat : context -> tactic -> int -> tactic + = "camlidl_z3_Z3_tactic_repeat" + +external tactic_skip : context -> tactic + = "camlidl_z3_Z3_tactic_skip" + +external tactic_fail : context -> tactic + = "camlidl_z3_Z3_tactic_fail" + +external tactic_fail_if : context -> probe -> tactic + = "camlidl_z3_Z3_tactic_fail_if" + +external tactic_fail_if_not_decided : context -> tactic + = "camlidl_z3_Z3_tactic_fail_if_not_decided" + +external tactic_using_params : context -> tactic -> params -> tactic + = "camlidl_z3_Z3_tactic_using_params" + +external probe_const : context -> float -> probe + = "camlidl_z3_Z3_probe_const" + +external probe_lt : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_lt" + +external probe_gt : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_gt" + +external probe_le : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_le" + +external probe_ge : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_ge" + +external probe_eq : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_eq" + +external probe_and : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_and" + +external probe_or : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_or" + +external probe_not : context -> probe -> probe + = "camlidl_z3_Z3_probe_not" + +external get_num_tactics : context -> int + = "camlidl_z3_Z3_get_num_tactics" + +external get_tactic_name : context -> int -> string + = "camlidl_z3_Z3_get_tactic_name" + +external get_num_probes : context -> int + = "camlidl_z3_Z3_get_num_probes" + +external get_probe_name : context -> int -> string + = "camlidl_z3_Z3_get_probe_name" + +external tactic_get_help : context -> tactic -> string + = "camlidl_z3_Z3_tactic_get_help" + +external tactic_get_param_descrs : context -> tactic -> param_descrs + = "camlidl_z3_Z3_tactic_get_param_descrs" + +external tactic_get_descr : context -> string -> string + = "camlidl_z3_Z3_tactic_get_descr" + +external probe_get_descr : context -> string -> string + = "camlidl_z3_Z3_probe_get_descr" + +external probe_apply : context -> probe -> goal -> float + = "camlidl_z3_Z3_probe_apply" + +external tactic_apply : context -> tactic -> goal -> apply_result + = "camlidl_z3_Z3_tactic_apply" + +external tactic_apply_ex : context -> tactic -> goal -> params -> apply_result + = "camlidl_z3_Z3_tactic_apply_ex" + +external apply_result_to_string : context -> apply_result -> string + = "camlidl_z3_Z3_apply_result_to_string" + +external apply_result_get_num_subgoals : context -> apply_result -> int + = "camlidl_z3_Z3_apply_result_get_num_subgoals" + +external apply_result_get_subgoal : context -> apply_result -> int -> goal + = "camlidl_z3_Z3_apply_result_get_subgoal" + +external apply_result_convert_model : context -> apply_result -> int -> model -> model + = "camlidl_z3_Z3_apply_result_convert_model" + +external mk_solver : context -> solver + = "camlidl_z3_Z3_mk_solver" + +external mk_simple_solver : context -> solver + = "camlidl_z3_Z3_mk_simple_solver" + +external mk_solver_for_logic : context -> symbol -> solver + = "camlidl_z3_Z3_mk_solver_for_logic" + +external mk_solver_from_tactic : context -> tactic -> solver + = "camlidl_z3_Z3_mk_solver_from_tactic" + +external solver_get_help : context -> solver -> string + = "camlidl_z3_Z3_solver_get_help" + +external solver_get_param_descrs : context -> solver -> param_descrs + = "camlidl_z3_Z3_solver_get_param_descrs" + +external solver_set_params : context -> solver -> params -> unit + = "camlidl_z3_Z3_solver_set_params" + +external solver_push : context -> solver -> unit + = "camlidl_z3_Z3_solver_push" + +external solver_pop : context -> solver -> int -> unit + = "camlidl_z3_Z3_solver_pop" + +external solver_reset : context -> solver -> unit + = "camlidl_z3_Z3_solver_reset" + +external solver_get_num_scopes : context -> solver -> int + = "camlidl_z3_Z3_solver_get_num_scopes" + +external solver_assert : context -> solver -> ast -> unit + = "camlidl_z3_Z3_solver_assert" + +external solver_get_assertions : context -> solver -> ast_vector + = "camlidl_z3_Z3_solver_get_assertions" + +external solver_check : context -> solver -> lbool + = "camlidl_z3_Z3_solver_check" + +external solver_check_assumptions : context -> solver -> ast array -> lbool + = "camlidl_z3_Z3_solver_check_assumptions" + +external solver_get_model : context -> solver -> model + = "camlidl_z3_Z3_solver_get_model" + +external solver_get_proof : context -> solver -> ast + = "camlidl_z3_Z3_solver_get_proof" + +external solver_get_unsat_core : context -> solver -> ast_vector + = "camlidl_z3_Z3_solver_get_unsat_core" + +external solver_get_reason_unknown : context -> solver -> string + = "camlidl_z3_Z3_solver_get_reason_unknown" + +external solver_get_statistics : context -> solver -> stats + = "camlidl_z3_Z3_solver_get_statistics" + +external solver_to_string : context -> solver -> string + = "camlidl_z3_Z3_solver_to_string" + + +type stat_datum = Stat_int of int | Stat_float of float +type stats_refined = (string, stat_datum) Hashtbl.t + +external stats_to_string : context -> stats -> string + = "camlidl_z3_Z3_stats_to_string" + +external stats_size : context -> stats -> int + = "camlidl_z3_Z3_stats_size" + +external stats_get_key : context -> stats -> int -> string + = "camlidl_z3_Z3_stats_get_key" + +external stats_is_uint : context -> stats -> int -> bool + = "camlidl_z3_Z3_stats_is_uint" + +external stats_is_double : context -> stats -> int -> bool + = "camlidl_z3_Z3_stats_is_double" + +external stats_get_uint_value : context -> stats -> int -> int + = "camlidl_z3_Z3_stats_get_uint_value" + +external stats_get_double_value : context -> stats -> int -> float + = "camlidl_z3_Z3_stats_get_double_value" + + + +(* Internal auxiliary functions: *) +(* +(* Transform a pair of arrays into an array of pairs *) +let array_combine a b = + if Array.length a <> Array.length b then raise (Invalid_argument "array_combine"); + Array.init (Array.length a) (fun i -> (a.(i), b.(i))) + +(* [a |> b] is the pipeline operator for [b(a)] *) +let ( |> ) x f = f x +*) + +(* Find the index of an element in an array, raises Not_found is missing *) +let find equal x a = + let len = Array.length a in + let rec find_ i = + if i >= len then + raise Not_found + else + if equal x a.(i) then + i + else + find_ (i+1) + in + find_ 0 + + +(* Symbols *) + +let symbol_refine c s = + match get_symbol_kind c s with + | INT_SYMBOL -> Symbol_int (get_symbol_int c s) + | STRING_SYMBOL -> Symbol_string (get_symbol_string c s) + +let mk_symbol c = function + | Symbol_int(i) -> mk_int_symbol c i + | Symbol_string(s) -> mk_string_symbol c s + + +(* Sorts *) + +let get_datatype_sort c s = + Array.init (get_datatype_sort_num_constructors c s) (fun i -> + let constructor = get_datatype_sort_constructor c s i in + let recognizer = get_datatype_sort_recognizer c s i in + let accessors = + Array.init (get_domain_size c constructor) (fun j -> + get_datatype_sort_constructor_accessor c s i j + ) in + {constructor; recognizer; accessors} + ) + +let sort_refine c s = + match get_sort_kind c s with + | UNINTERPRETED_SORT -> Sort_uninterpreted (get_sort_name c s) + | BOOL_SORT -> Sort_bool + | INT_SORT -> Sort_int + | BV_SORT -> Sort_bv (get_bv_sort_size c s) + | FINITE_DOMAIN_SORT -> + (match get_finite_domain_sort_size c s with + | Some(sz) -> Sort_finite_domain (get_sort_name c s, sz) + | None -> failwith "Z3.sort_refine: failed to get size of finite-domain sort" + ) + | REAL_SORT -> Sort_real + | ARRAY_SORT -> Sort_array (get_array_sort_domain c s, get_array_sort_range c s) + | DATATYPE_SORT -> Sort_datatype (get_datatype_sort c s) + | RELATION_SORT -> Sort_relation (Array.init (get_relation_arity c s) (fun i -> get_relation_column c s i)) + | UNKNOWN_SORT -> Sort_unknown + +let mk_sort c = function + | Sort_uninterpreted(s) -> mk_uninterpreted_sort c s + | Sort_bool -> mk_bool_sort c + | Sort_int -> mk_int_sort c + | Sort_bv(size) -> mk_bv_sort c size + | Sort_finite_domain(name,size) -> mk_finite_domain_sort c name size + | Sort_real -> mk_real_sort c + | Sort_array(domain,range) -> mk_array_sort c domain range + | Sort_datatype(constructors) -> get_range c constructors.(0).constructor + | Sort_relation(_) -> invalid_arg "Z3.mk_sort: cannot construct relation sorts" + | Sort_unknown(_) -> invalid_arg "Z3.mk_sort: cannot construct unknown sorts" + + +(* Replacement datatypes creation API *) + +let mk_datatypes ctx generator = + let usort0 = mk_uninterpreted_sort ctx (mk_int_symbol ctx 0) + in + let rec find_num_sorts i = + if i = max_int then invalid_arg "mk_datatypes: too many sorts" + else + match generator (Array.make i usort0) with + | None -> find_num_sorts (i+1) + | Some(a) when Array.length a = i -> i + | Some _ -> invalid_arg "mk_datatypes: number of sorts and datatype descriptors must be equal" + in + let num_sorts = find_num_sorts 0 + in + let sorts0 = Array.init num_sorts (fun i -> mk_uninterpreted_sort ctx (mk_int_symbol ctx i)) + in + let ctorss_descriptors = + match generator sorts0 with + | Some(ctorss_descriptors) -> ctorss_descriptors + | None -> invalid_arg "mk_datatypes: generator failed" + in + let names = Array.map fst ctorss_descriptors + in + let ctorss = + Array.map (fun (_, ctors_descriptor) -> + Array.map (fun {constructor_desc; recognizer_desc; accessor_descs} -> + let field_names = Array.map fst accessor_descs + in + let sort_refs = Array.make (Array.length accessor_descs) 0 + in + let field_sorts = + Array.mapi (fun i (_, sort) -> + try + let j = find (fun s t -> is_eq_sort ctx s t) sort sorts0 in + sort_refs.(i) <- j ; + None + with Not_found -> + Some(sort) + ) accessor_descs + in + mk_constructor ctx constructor_desc recognizer_desc field_names field_sorts sort_refs + ) ctors_descriptor + ) ctorss_descriptors + in + let constructor_lists = Array.map (mk_constructor_list ctx) ctorss + in + let sorts,_ = mk_datatypes ctx names constructor_lists + in + let datatypes = + Array.mapi (fun i sort -> + (sort, + Array.mapi (fun j ctor -> + let num_fields = Array.length (snd ctorss_descriptors.(i)).(j).accessor_descs in + let constructor, recognizer, accessors = query_constructor ctx ctor num_fields in + {constructor; recognizer; accessors} + ) ctorss.(i)) + ) sorts + in + Array.iter (fun ctor_list -> + del_constructor_list ctx ctor_list + ) constructor_lists + ; + Array.iter (fun ctors -> + Array.iter (fun ctor -> + del_constructor ctx ctor + ) ctors + ) ctorss + ; + datatypes + + +(* Numerals *) + +let rec numeral_refine c t = + assert( get_ast_kind c t = NUMERAL_AST ); + let sort = get_sort c t in + let is_int, i = get_numeral_int c t in + if is_int then + Numeral_int (i, sort) + else + let is_int64, i = get_numeral_int64 c t in + if is_int64 then + Numeral_int64 (i, sort) + else + if get_sort_kind c sort <> REAL_SORT then + Numeral_large (get_numeral_string c t, sort) + else + let n = numeral_refine c (get_numerator c t) in + let d = numeral_refine c (get_denominator c t) in + Numeral_rational (n, d) + + +let to_real c x = + if get_sort_kind c (get_sort c x) = REAL_SORT then + x + else + mk_int2real c x + +let rec embed_numeral c = function + | Numeral_int (i, s) -> mk_int c i s + | Numeral_int64 (i, s) -> mk_int64 c i s + | Numeral_large (l, s) -> mk_numeral c l s + | Numeral_rational (Numeral_int(n,_), Numeral_int(d,_)) -> mk_real c n d + | Numeral_rational (n, d) -> + mk_div c (to_real c (embed_numeral c n)) (to_real c (embed_numeral c d)) + (* Or should the following be used instead? + let n_str = get_numeral_string c (embed_numeral c n) in + let d_str = get_numeral_string c (embed_numeral c d) in + mk_numeral c (n_str ^ " / " ^ d_str) (mk_real_sort c) + *) + +(* Terms *) + +let get_app_args c a = + Array.init (get_app_num_args c a) (get_app_arg c a);; + +let get_domains c d = + Array.init (get_domain_size c d) (get_domain c d);; + + +let get_pattern_terms c p = + Array.init (get_pattern_num_terms c p) (get_pattern c p) + + +let term_refine c t = + match get_ast_kind c t with + | NUMERAL_AST -> + Term_numeral (numeral_refine c t) + | APP_AST -> + let t' = to_app c t in + let f = get_app_decl c t' in + let num_args = get_app_num_args c t' in + let args = Array.init num_args (get_app_arg c t') in + let k = get_decl_kind c f in + Term_app (k, f, args) + | QUANTIFIER_AST -> + let bt = if is_quantifier_forall c t then Forall else Exists in + let w = get_quantifier_weight c t in + let np = get_quantifier_num_patterns c t in + let pats = Array.init np (get_quantifier_pattern_ast c t) in + let pats = Array.map (get_pattern_terms c) pats in + let nb = get_quantifier_num_bound c t in + let bound = + Array.init nb (fun i -> + (get_quantifier_bound_name c t i, get_quantifier_bound_sort c t i) + ) in + let body = get_quantifier_body c t in + Term_quantifier (bt, w, pats, bound, body) + | VAR_AST -> + Term_var (get_index_value c t, get_sort c t) + | _ -> + assert false + + +(* let mk_term c = function *) +(* | Term_numeral (numeral, sort) -> mk_numeral c numeral sort *) +(* | Term_app (kind, decl, args) -> *) +(* | Term_quantifier (strength, weight, pats, bound, body) -> *) +(* | Term_var (index, sort) -> *) + + + +(* Refined model API *) + +let model_refine c m = + let num_sorts = model_get_num_sorts c m in + let sorts = Hashtbl.create num_sorts in + for i = 0 to num_sorts - 1 do + let sort = model_get_sort c m i in + let universe = model_get_sort_universe c m sort in + Hashtbl.add sorts sort universe + done; + let num_consts = model_get_num_consts c m in + let consts = Hashtbl.create num_consts in + let arrays = Hashtbl.create 0 in + for i = 0 to num_consts - 1 do + let const_decl = model_get_const_decl c m i in + match model_get_const_interp c m const_decl with + | Some(const_interp) -> + if is_as_array c const_interp then + let array_decl = get_as_array_func_decl c const_interp in + match model_get_func_interp c m array_decl with + | Some(array_interp) -> + let num_entries = func_interp_get_num_entries c array_interp in + let tbl = Hashtbl.create num_entries in + for i = 0 to num_entries - 1 do + let entry = func_interp_get_entry c array_interp i in + assert( func_entry_get_num_args c entry = 1 ); + let arg = func_entry_get_arg c entry 0 in + let value = func_entry_get_value c entry in + Hashtbl.add tbl arg value + done; + let default = func_interp_get_else c array_interp in + Hashtbl.add arrays const_decl (tbl, default) + | None -> + () + else + Hashtbl.add consts const_decl const_interp + | None -> + () + done; + let num_funcs = model_get_num_funcs c m in + let funcs = Hashtbl.create num_funcs in + for i = 0 to num_funcs - 1 do + let func_decl = model_get_func_decl c m i in + if not (Hashtbl.mem arrays func_decl) then + match model_get_func_interp c m func_decl with + | Some(func_interp) -> + let num_entries = func_interp_get_num_entries c func_interp in + let tbl = Hashtbl.create num_entries in + for i = 0 to num_entries - 1 do + let entry = func_interp_get_entry c func_interp i in + let num_args = func_entry_get_num_args c entry in + let args = Array.init num_args (fun i -> func_entry_get_arg c entry i) in + let value = func_entry_get_value c entry in + Hashtbl.add tbl args value + done; + let default = func_interp_get_else c func_interp in + Hashtbl.add funcs func_decl (tbl, default) + | None -> + () + done; + {sorts; consts; arrays; funcs} + + +(* Extended parser API *) + +let get_smtlib_formulas c = + Array.init (get_smtlib_num_formulas c) (get_smtlib_formula c) + +let get_smtlib_assumptions c = + Array.init (get_smtlib_num_assumptions c) (get_smtlib_assumption c) + +let get_smtlib_decls c = + Array.init (get_smtlib_num_decls c) (get_smtlib_decl c) + +let get_smtlib_parse_results c = + (get_smtlib_formulas c, get_smtlib_assumptions c, get_smtlib_decls c) + +let parse_smtlib_string_x c a1 a2 a3 a4 a5 = + parse_smtlib_string c a1 a2 a3 a4 a5 ; + get_smtlib_parse_results c + +let parse_smtlib_file_x c a1 a2 a3 a4 a5 = + parse_smtlib_file c a1 a2 a3 a4 a5 ; + get_smtlib_parse_results c + +let parse_smtlib_string_formula c a1 a2 a3 a4 a5 = + parse_smtlib_string c a1 a2 a3 a4 a5 ; + match get_smtlib_formulas c with [|f|] -> f | _ -> failwith "Z3: parse_smtlib_string_formula" + +let parse_smtlib_file_formula c a1 a2 a3 a4 a5 = + parse_smtlib_file c a1 a2 a3 a4 a5 ; + match get_smtlib_formulas c with [|f|] -> f | _ -> failwith "Z3: parse_smtlib_file_formula" + + +(* Error handling *) + +let get_error_msg c e = + match e with + | PARSER_ERROR -> (get_error_msg_ex c e) ^ ": " ^ (get_smtlib_error c) + | _ -> get_error_msg_ex c e + + +(* Refined stats API *) + +let stats_refine c s = + let num_stats = stats_size c s in + let tbl = Hashtbl.create num_stats in + for i = 0 to num_stats - 1 do + let key = stats_get_key c s i in + let datum = + if stats_is_uint c s i then + Stat_int(stats_get_uint_value c s i) + else + Stat_float(stats_get_double_value c s i) in + Hashtbl.add tbl key datum + done; + tbl + + +let _ = + Printexc.register_printer (function + | Error(c,e) -> Some ("Z3 "^(get_error_msg c e)) + | _ -> None + ) + + +module V3 = struct + +(* File generated from z3.idl *) + +type symbol +and literals +and theory +and config +and context +and sort +and func_decl +and ast +and app +and pattern +and model +and constructor +and constructor_list + +and lbool = + | L_FALSE + | L_UNDEF + | L_TRUE + +and symbol_kind = + | INT_SYMBOL + | STRING_SYMBOL + +and parameter_kind = + | PARAMETER_INT + | PARAMETER_DOUBLE + | PARAMETER_RATIONAL + | PARAMETER_SYMBOL + | PARAMETER_SORT + | PARAMETER_AST + | PARAMETER_FUNC_DECL + +and sort_kind = + | UNINTERPRETED_SORT + | BOOL_SORT + | INT_SORT + | REAL_SORT + | BV_SORT + | ARRAY_SORT + | DATATYPE_SORT + | RELATION_SORT + | FINITE_DOMAIN_SORT + | UNKNOWN_SORT + +and ast_kind = + | NUMERAL_AST + | APP_AST + | VAR_AST + | QUANTIFIER_AST + | SORT_AST + | FUNC_DECL_AST + | UNKNOWN_AST + +and decl_kind = + | OP_TRUE + | OP_FALSE + | OP_EQ + | OP_DISTINCT + | OP_ITE + | OP_AND + | OP_OR + | OP_IFF + | OP_XOR + | OP_NOT + | OP_IMPLIES + | OP_OEQ + | OP_ANUM + | OP_AGNUM + | OP_LE + | OP_GE + | OP_LT + | OP_GT + | OP_ADD + | OP_SUB + | OP_UMINUS + | OP_MUL + | OP_DIV + | OP_IDIV + | OP_REM + | OP_MOD + | OP_TO_REAL + | OP_TO_INT + | OP_IS_INT + | OP_POWER + | OP_STORE + | OP_SELECT + | OP_CONST_ARRAY + | OP_ARRAY_MAP + | OP_ARRAY_DEFAULT + | OP_SET_UNION + | OP_SET_INTERSECT + | OP_SET_DIFFERENCE + | OP_SET_COMPLEMENT + | OP_SET_SUBSET + | OP_AS_ARRAY + | OP_BNUM + | OP_BIT1 + | OP_BIT0 + | OP_BNEG + | OP_BADD + | OP_BSUB + | OP_BMUL + | OP_BSDIV + | OP_BUDIV + | OP_BSREM + | OP_BUREM + | OP_BSMOD + | OP_BSDIV0 + | OP_BUDIV0 + | OP_BSREM0 + | OP_BUREM0 + | OP_BSMOD0 + | OP_ULEQ + | OP_SLEQ + | OP_UGEQ + | OP_SGEQ + | OP_ULT + | OP_SLT + | OP_UGT + | OP_SGT + | OP_BAND + | OP_BOR + | OP_BNOT + | OP_BXOR + | OP_BNAND + | OP_BNOR + | OP_BXNOR + | OP_CONCAT + | OP_SIGN_EXT + | OP_ZERO_EXT + | OP_EXTRACT + | OP_REPEAT + | OP_BREDOR + | OP_BREDAND + | OP_BCOMP + | OP_BSHL + | OP_BLSHR + | OP_BASHR + | OP_ROTATE_LEFT + | OP_ROTATE_RIGHT + | OP_EXT_ROTATE_LEFT + | OP_EXT_ROTATE_RIGHT + | OP_INT2BV + | OP_BV2INT + | OP_CARRY + | OP_XOR3 + | OP_PR_UNDEF + | OP_PR_TRUE + | OP_PR_ASSERTED + | OP_PR_GOAL + | OP_PR_MODUS_PONENS + | OP_PR_REFLEXIVITY + | OP_PR_SYMMETRY + | OP_PR_TRANSITIVITY + | OP_PR_TRANSITIVITY_STAR + | OP_PR_MONOTONICITY + | OP_PR_QUANT_INTRO + | OP_PR_DISTRIBUTIVITY + | OP_PR_AND_ELIM + | OP_PR_NOT_OR_ELIM + | OP_PR_REWRITE + | OP_PR_REWRITE_STAR + | OP_PR_PULL_QUANT + | OP_PR_PULL_QUANT_STAR + | OP_PR_PUSH_QUANT + | OP_PR_ELIM_UNUSED_VARS + | OP_PR_DER + | OP_PR_QUANT_INST + | OP_PR_HYPOTHESIS + | OP_PR_LEMMA + | OP_PR_UNIT_RESOLUTION + | OP_PR_IFF_TRUE + | OP_PR_IFF_FALSE + | OP_PR_COMMUTATIVITY + | OP_PR_DEF_AXIOM + | OP_PR_DEF_INTRO + | OP_PR_APPLY_DEF + | OP_PR_IFF_OEQ + | OP_PR_NNF_POS + | OP_PR_NNF_NEG + | OP_PR_NNF_STAR + | OP_PR_CNF_STAR + | OP_PR_SKOLEMIZE + | OP_PR_MODUS_PONENS_OEQ + | OP_PR_TH_LEMMA + | OP_RA_STORE + | OP_RA_EMPTY + | OP_RA_IS_EMPTY + | OP_RA_JOIN + | OP_RA_UNION + | OP_RA_WIDEN + | OP_RA_PROJECT + | OP_RA_FILTER + | OP_RA_NEGATION_FILTER + | OP_RA_RENAME + | OP_RA_COMPLEMENT + | OP_RA_SELECT + | OP_RA_CLONE + | OP_FD_LT + | OP_LABEL + | OP_LABEL_LIT + | OP_DT_CONSTRUCTOR + | OP_DT_RECOGNISER + | OP_DT_ACCESSOR + | OP_UNINTERPRETED + +and param_kind = + | PK_UINT + | PK_BOOL + | PK_DOUBLE + | PK_SYMBOL + | PK_STRING + | PK_OTHER + | PK_INVALID + +and search_failure = + | NO_FAILURE + | UNKNOWN + | TIMEOUT + | MEMOUT_WATERMARK + | CANCELED + | NUM_CONFLICTS + | THEORY + | QUANTIFIERS + +and ast_print_mode = + | PRINT_SMTLIB_FULL + | PRINT_LOW_LEVEL + | PRINT_SMTLIB_COMPLIANT + | PRINT_SMTLIB2_COMPLIANT + + +external mk_config : unit -> config + = "camlidl_z3V3_Z3_mk_config" + +external del_config : config -> unit + = "camlidl_z3V3_Z3_del_config" + +external set_param_value : config -> string -> string -> unit + = "camlidl_z3V3_Z3_set_param_value" + +external mk_context : config -> context + = "camlidl_z3V3_Z3_mk_context" + +external del_context : context -> unit + = "camlidl_z3V3_Z3_del_context" + +external update_param_value : context -> string -> string -> unit + = "camlidl_z3V3_Z3_update_param_value" + +external get_param_value : context -> string -> string option + = "camlidl_z3V3_Z3_get_param_value" + +external mk_int_symbol : context -> int -> symbol + = "camlidl_z3V3_Z3_mk_int_symbol" + +external mk_string_symbol : context -> string -> symbol + = "camlidl_z3V3_Z3_mk_string_symbol" + +external mk_uninterpreted_sort : context -> symbol -> sort + = "camlidl_z3V3_Z3_mk_uninterpreted_sort" + +external mk_bool_sort : context -> sort + = "camlidl_z3V3_Z3_mk_bool_sort" + +external mk_int_sort : context -> sort + = "camlidl_z3V3_Z3_mk_int_sort" + +external mk_real_sort : context -> sort + = "camlidl_z3V3_Z3_mk_real_sort" + +external mk_bv_sort : context -> int -> sort + = "camlidl_z3V3_Z3_mk_bv_sort" + +external mk_finite_domain_sort : context -> symbol -> int64 -> sort + = "camlidl_z3V3_Z3_mk_finite_domain_sort" + +external mk_array_sort : context -> sort -> sort -> sort + = "camlidl_z3V3_Z3_mk_array_sort" + +external mk_tuple_sort : context -> symbol -> symbol array -> sort array -> sort * func_decl * func_decl array + = "camlidl_z3V3_Z3_mk_tuple_sort" + +external mk_enumeration_sort : context -> symbol -> symbol array -> sort * func_decl array * func_decl array + = "camlidl_z3V3_Z3_mk_enumeration_sort" + +external mk_list_sort : context -> symbol -> sort -> sort * func_decl * func_decl * func_decl * func_decl * func_decl * func_decl + = "camlidl_z3V3_Z3_mk_list_sort" + +external mk_constructor : context -> symbol -> symbol -> symbol array -> sort array -> int array -> constructor + = "camlidl_z3_Z3_mk_constructor_bytecode" "camlidl_z3V3_Z3_mk_constructor" + +external del_constructor : context -> constructor -> unit + = "camlidl_z3V3_Z3_del_constructor" + +external mk_datatype : context -> symbol -> constructor array -> sort * constructor array + = "camlidl_z3V3_Z3_mk_datatype" + +external mk_constructor_list : context -> constructor array -> constructor_list + = "camlidl_z3V3_Z3_mk_constructor_list" + +external del_constructor_list : context -> constructor_list -> unit + = "camlidl_z3V3_Z3_del_constructor_list" + +external mk_datatypes : context -> symbol array -> constructor_list array -> sort array * constructor_list array + = "camlidl_z3V3_Z3_mk_datatypes" + +external query_constructor : context -> constructor -> int -> func_decl * func_decl * func_decl array + = "camlidl_z3V3_Z3_query_constructor" + +external mk_func_decl : context -> symbol -> sort array -> sort -> func_decl + = "camlidl_z3V3_Z3_mk_func_decl" + +external mk_app : context -> func_decl -> ast array -> ast + = "camlidl_z3V3_Z3_mk_app" + +external mk_const : context -> symbol -> sort -> ast + = "camlidl_z3V3_Z3_mk_const" + +external mk_fresh_func_decl : context -> string -> sort array -> sort -> func_decl + = "camlidl_z3V3_Z3_mk_fresh_func_decl" + +external mk_fresh_const : context -> string -> sort -> ast + = "camlidl_z3V3_Z3_mk_fresh_const" + +external mk_true : context -> ast + = "camlidl_z3V3_Z3_mk_true" + +external mk_false : context -> ast + = "camlidl_z3V3_Z3_mk_false" + +external mk_eq : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_eq" + +external mk_distinct : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_distinct" + +external mk_not : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_not" + +external mk_ite : context -> ast -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_ite" + +external mk_iff : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_iff" + +external mk_implies : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_implies" + +external mk_xor : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_xor" + +external mk_and : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_and" + +external mk_or : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_or" + +external mk_add : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_add" + +external mk_mul : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_mul" + +external mk_sub : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_sub" + +external mk_unary_minus : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_unary_minus" + +external mk_div : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_div" + +external mk_mod : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_mod" + +external mk_rem : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_rem" + +external mk_power : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_power" + +external mk_lt : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_lt" + +external mk_le : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_le" + +external mk_gt : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_gt" + +external mk_ge : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_ge" + +external mk_int2real : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_int2real" + +external mk_real2int : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_real2int" + +external mk_is_int : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_is_int" + +external mk_bvnot : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvnot" + +external mk_bvredand : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvredand" + +external mk_bvredor : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvredor" + +external mk_bvand : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvand" + +external mk_bvor : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvor" + +external mk_bvxor : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvxor" + +external mk_bvnand : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvnand" + +external mk_bvnor : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvnor" + +external mk_bvxnor : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvxnor" + +external mk_bvneg : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvneg" + +external mk_bvadd : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvadd" + +external mk_bvsub : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsub" + +external mk_bvmul : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvmul" + +external mk_bvudiv : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvudiv" + +external mk_bvsdiv : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsdiv" + +external mk_bvurem : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvurem" + +external mk_bvsrem : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsrem" + +external mk_bvsmod : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsmod" + +external mk_bvult : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvult" + +external mk_bvslt : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvslt" + +external mk_bvule : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvule" + +external mk_bvsle : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsle" + +external mk_bvuge : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvuge" + +external mk_bvsge : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsge" + +external mk_bvugt : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvugt" + +external mk_bvsgt : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsgt" + +external mk_concat : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_concat" + +external mk_extract : context -> int -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_extract" + +external mk_sign_ext : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_sign_ext" + +external mk_zero_ext : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_zero_ext" + +external mk_repeat : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_repeat" + +external mk_bvshl : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvshl" + +external mk_bvlshr : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvlshr" + +external mk_bvashr : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvashr" + +external mk_rotate_left : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_rotate_left" + +external mk_rotate_right : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_rotate_right" + +external mk_ext_rotate_left : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_ext_rotate_left" + +external mk_ext_rotate_right : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_ext_rotate_right" + +external mk_int2bv : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_int2bv" + +external mk_bv2int : context -> ast -> bool -> ast + = "camlidl_z3V3_Z3_mk_bv2int" + +external mk_bvadd_no_overflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3V3_Z3_mk_bvadd_no_overflow" + +external mk_bvadd_no_underflow : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvadd_no_underflow" + +external mk_bvsub_no_overflow : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsub_no_overflow" + +external mk_bvsub_no_underflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3V3_Z3_mk_bvsub_no_underflow" + +external mk_bvsdiv_no_overflow : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsdiv_no_overflow" + +external mk_bvneg_no_overflow : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvneg_no_overflow" + +external mk_bvmul_no_overflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3V3_Z3_mk_bvmul_no_overflow" + +external mk_bvmul_no_underflow : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvmul_no_underflow" + +external mk_select : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_select" + +external mk_store : context -> ast -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_store" + +external mk_const_array : context -> sort -> ast -> ast + = "camlidl_z3V3_Z3_mk_const_array" + +external mk_map : context -> func_decl -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_map" + +external mk_array_default : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_array_default" + +external mk_set_sort : context -> sort -> sort + = "camlidl_z3V3_Z3_mk_set_sort" + +external mk_empty_set : context -> sort -> ast + = "camlidl_z3V3_Z3_mk_empty_set" + +external mk_full_set : context -> sort -> ast + = "camlidl_z3V3_Z3_mk_full_set" + +external mk_set_add : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_add" + +external mk_set_del : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_del" + +external mk_set_union : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_set_union" + +external mk_set_intersect : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_set_intersect" + +external mk_set_difference : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_difference" + +external mk_set_complement : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_complement" + +external mk_set_member : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_member" + +external mk_set_subset : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_subset" + +external mk_numeral : context -> string -> sort -> ast + = "camlidl_z3V3_Z3_mk_numeral" + +external mk_real : context -> int -> int -> ast + = "camlidl_z3V3_Z3_mk_real" + +external mk_int : context -> int -> sort -> ast + = "camlidl_z3V3_Z3_mk_int" + +external mk_int64 : context -> int64 -> sort -> ast + = "camlidl_z3V3_Z3_mk_int64" + +external mk_pattern : context -> ast array -> pattern + = "camlidl_z3V3_Z3_mk_pattern" + +external mk_bound : context -> int -> sort -> ast + = "camlidl_z3V3_Z3_mk_bound" + +external mk_forall : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_forall_bytecode" "camlidl_z3V3_Z3_mk_forall" + +external mk_exists : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_exists_bytecode" "camlidl_z3V3_Z3_mk_exists" + +external mk_quantifier : context -> bool -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_bytecode" "camlidl_z3V3_Z3_mk_quantifier" + +external mk_quantifier_ex : context -> bool -> int -> symbol -> symbol -> pattern array -> ast array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_ex" + +external mk_forall_const : context -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3V3_Z3_mk_forall_const" + +external mk_exists_const : context -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3V3_Z3_mk_exists_const" + +external mk_quantifier_const : context -> bool -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_const_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const" + +external mk_quantifier_const_ex : context -> bool -> int -> symbol -> symbol -> app array -> pattern array -> ast array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_const_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const_ex" + +external get_symbol_kind : context -> symbol -> symbol_kind + = "camlidl_z3V3_Z3_get_symbol_kind" + +external get_symbol_int : context -> symbol -> int + = "camlidl_z3V3_Z3_get_symbol_int" + +external get_symbol_string : context -> symbol -> string + = "camlidl_z3V3_Z3_get_symbol_string" + +external get_sort_name : context -> sort -> symbol + = "camlidl_z3V3_Z3_get_sort_name" + +external get_sort_id : context -> sort -> int + = "camlidl_z3V3_Z3_get_sort_id" + +external sort_to_ast : context -> sort -> ast + = "camlidl_z3V3_Z3_sort_to_ast" + +external is_eq_sort : context -> sort -> sort -> bool + = "camlidl_z3V3_Z3_is_eq_sort" + +external get_sort_kind : context -> sort -> sort_kind + = "camlidl_z3V3_Z3_get_sort_kind" + +external get_bv_sort_size : context -> sort -> int + = "camlidl_z3V3_Z3_get_bv_sort_size" + +external get_finite_domain_sort_size : context -> sort -> int64 option + = "camlidl_z3V3_Z3_get_finite_domain_sort_size" + +external get_array_sort_domain : context -> sort -> sort + = "camlidl_z3V3_Z3_get_array_sort_domain" + +external get_array_sort_range : context -> sort -> sort + = "camlidl_z3V3_Z3_get_array_sort_range" + +external get_tuple_sort_mk_decl : context -> sort -> func_decl + = "camlidl_z3V3_Z3_get_tuple_sort_mk_decl" + +external get_tuple_sort_num_fields : context -> sort -> int + = "camlidl_z3V3_Z3_get_tuple_sort_num_fields" + +external get_tuple_sort_field_decl : context -> sort -> int -> func_decl + = "camlidl_z3V3_Z3_get_tuple_sort_field_decl" + +external get_datatype_sort_num_constructors : context -> sort -> int + = "camlidl_z3V3_Z3_get_datatype_sort_num_constructors" + +external get_datatype_sort_constructor : context -> sort -> int -> func_decl + = "camlidl_z3V3_Z3_get_datatype_sort_constructor" + +external get_datatype_sort_recognizer : context -> sort -> int -> func_decl + = "camlidl_z3V3_Z3_get_datatype_sort_recognizer" + +external get_datatype_sort_constructor_accessor : context -> sort -> int -> int -> func_decl + = "camlidl_z3V3_Z3_get_datatype_sort_constructor_accessor" + +external get_relation_arity : context -> sort -> int + = "camlidl_z3V3_Z3_get_relation_arity" + +external get_relation_column : context -> sort -> int -> sort + = "camlidl_z3V3_Z3_get_relation_column" + +external func_decl_to_ast : context -> func_decl -> ast + = "camlidl_z3V3_Z3_func_decl_to_ast" + +external is_eq_func_decl : context -> func_decl -> func_decl -> bool + = "camlidl_z3V3_Z3_is_eq_func_decl" + +external get_func_decl_id : context -> func_decl -> int + = "camlidl_z3V3_Z3_get_func_decl_id" + +external get_decl_name : context -> func_decl -> symbol + = "camlidl_z3V3_Z3_get_decl_name" + +external get_decl_kind : context -> func_decl -> decl_kind + = "camlidl_z3V3_Z3_get_decl_kind" + +external get_domain_size : context -> func_decl -> int + = "camlidl_z3V3_Z3_get_domain_size" + +external get_arity : context -> func_decl -> int + = "camlidl_z3V3_Z3_get_arity" + +external get_domain : context -> func_decl -> int -> sort + = "camlidl_z3V3_Z3_get_domain" + +external get_range : context -> func_decl -> sort + = "camlidl_z3V3_Z3_get_range" + +external get_decl_num_parameters : context -> func_decl -> int + = "camlidl_z3V3_Z3_get_decl_num_parameters" + +external get_decl_parameter_kind : context -> func_decl -> int -> parameter_kind + = "camlidl_z3V3_Z3_get_decl_parameter_kind" + +external get_decl_int_parameter : context -> func_decl -> int -> int + = "camlidl_z3V3_Z3_get_decl_int_parameter" + +external get_decl_double_parameter : context -> func_decl -> int -> float + = "camlidl_z3V3_Z3_get_decl_double_parameter" + +external get_decl_symbol_parameter : context -> func_decl -> int -> symbol + = "camlidl_z3V3_Z3_get_decl_symbol_parameter" + +external get_decl_sort_parameter : context -> func_decl -> int -> sort + = "camlidl_z3V3_Z3_get_decl_sort_parameter" + +external get_decl_ast_parameter : context -> func_decl -> int -> ast + = "camlidl_z3V3_Z3_get_decl_ast_parameter" + +external get_decl_func_decl_parameter : context -> func_decl -> int -> func_decl + = "camlidl_z3V3_Z3_get_decl_func_decl_parameter" + +external get_decl_rational_parameter : context -> func_decl -> int -> string + = "camlidl_z3V3_Z3_get_decl_rational_parameter" + +external app_to_ast : context -> app -> ast + = "camlidl_z3V3_Z3_app_to_ast" + +external get_app_decl : context -> app -> func_decl + = "camlidl_z3V3_Z3_get_app_decl" + +external get_app_num_args : context -> app -> int + = "camlidl_z3V3_Z3_get_app_num_args" + +external get_app_arg : context -> app -> int -> ast + = "camlidl_z3V3_Z3_get_app_arg" + +external is_eq_ast : context -> ast -> ast -> bool + = "camlidl_z3V3_Z3_is_eq_ast" + +external get_ast_id : context -> ast -> int + = "camlidl_z3V3_Z3_get_ast_id" + +external get_ast_hash : context -> ast -> int + = "camlidl_z3V3_Z3_get_ast_hash" + +external get_sort : context -> ast -> sort + = "camlidl_z3V3_Z3_get_sort" + +external is_well_sorted : context -> ast -> bool + = "camlidl_z3V3_Z3_is_well_sorted" + +external get_bool_value : context -> ast -> lbool + = "camlidl_z3V3_Z3_get_bool_value" + +external get_ast_kind : context -> ast -> ast_kind + = "camlidl_z3V3_Z3_get_ast_kind" + +external is_app : context -> ast -> bool + = "camlidl_z3V3_Z3_is_app" + +external is_numeral_ast : context -> ast -> bool + = "camlidl_z3V3_Z3_is_numeral_ast" + +external is_algebraic_number : context -> ast -> bool + = "camlidl_z3V3_Z3_is_algebraic_number" + +external to_app : context -> ast -> app + = "camlidl_z3V3_Z3_to_app" + +external to_func_decl : context -> ast -> func_decl + = "camlidl_z3V3_Z3_to_func_decl" + +external get_numeral_string : context -> ast -> string + = "camlidl_z3V3_Z3_get_numeral_string" + +external get_numeral_decimal_string : context -> ast -> int -> string + = "camlidl_z3V3_Z3_get_numeral_decimal_string" + +external get_numerator : context -> ast -> ast + = "camlidl_z3V3_Z3_get_numerator" + +external get_denominator : context -> ast -> ast + = "camlidl_z3V3_Z3_get_denominator" + +external get_numeral_small : context -> ast -> bool * int64 * int64 + = "camlidl_z3V3_Z3_get_numeral_small" + +external get_numeral_int : context -> ast -> bool * int + = "camlidl_z3V3_Z3_get_numeral_int" + +external get_numeral_int64 : context -> ast -> bool * int64 + = "camlidl_z3V3_Z3_get_numeral_int64" + +external get_numeral_rational_int64 : context -> ast -> bool * int64 * int64 + = "camlidl_z3V3_Z3_get_numeral_rational_int64" + +external get_algebraic_number_lower : context -> ast -> int -> ast + = "camlidl_z3V3_Z3_get_algebraic_number_lower" + +external get_algebraic_number_upper : context -> ast -> int -> ast + = "camlidl_z3V3_Z3_get_algebraic_number_upper" + +external pattern_to_ast : context -> pattern -> ast + = "camlidl_z3V3_Z3_pattern_to_ast" + +external get_pattern_num_terms : context -> pattern -> int + = "camlidl_z3V3_Z3_get_pattern_num_terms" + +external get_pattern : context -> pattern -> int -> ast + = "camlidl_z3V3_Z3_get_pattern" + +external get_index_value : context -> ast -> int + = "camlidl_z3V3_Z3_get_index_value" + +external is_quantifier_forall : context -> ast -> bool + = "camlidl_z3V3_Z3_is_quantifier_forall" + +external get_quantifier_weight : context -> ast -> int + = "camlidl_z3V3_Z3_get_quantifier_weight" + +external get_quantifier_num_patterns : context -> ast -> int + = "camlidl_z3V3_Z3_get_quantifier_num_patterns" + +external get_quantifier_pattern_ast : context -> ast -> int -> pattern + = "camlidl_z3V3_Z3_get_quantifier_pattern_ast" + +external get_quantifier_num_no_patterns : context -> ast -> int + = "camlidl_z3V3_Z3_get_quantifier_num_no_patterns" + +external get_quantifier_no_pattern_ast : context -> ast -> int -> ast + = "camlidl_z3V3_Z3_get_quantifier_no_pattern_ast" + +external get_quantifier_bound_name : context -> ast -> int -> symbol + = "camlidl_z3V3_Z3_get_quantifier_bound_name" + +external get_quantifier_bound_sort : context -> ast -> int -> sort + = "camlidl_z3V3_Z3_get_quantifier_bound_sort" + +external get_quantifier_body : context -> ast -> ast + = "camlidl_z3V3_Z3_get_quantifier_body" + +external get_quantifier_num_bound : context -> ast -> int + = "camlidl_z3V3_Z3_get_quantifier_num_bound" + +external simplify : context -> ast -> ast + = "camlidl_z3V3_Z3_simplify" + +external update_term : context -> ast -> ast array -> ast + = "camlidl_z3V3_Z3_update_term" + +external substitute : context -> ast -> ast array -> ast array -> ast + = "camlidl_z3V3_Z3_substitute" + +external substitute_vars : context -> ast -> ast array -> ast + = "camlidl_z3V3_Z3_substitute_vars" + +external open_log : string -> bool + = "camlidl_z3V3_Z3_open_log" + +external append_log : string -> unit + = "camlidl_z3V3_Z3_append_log" + +external close_log : unit -> unit + = "camlidl_z3V3_Z3_close_log" + +external toggle_warning_messages : bool -> unit + = "camlidl_z3V3_Z3_toggle_warning_messages" + +external set_ast_print_mode : context -> ast_print_mode -> unit + = "camlidl_z3V3_Z3_set_ast_print_mode" + +external ast_to_string : context -> ast -> string + = "camlidl_z3V3_Z3_ast_to_string" + +external pattern_to_string : context -> pattern -> string + = "camlidl_z3V3_Z3_pattern_to_string" + +external sort_to_string : context -> sort -> string + = "camlidl_z3V3_Z3_sort_to_string" + +external func_decl_to_string : context -> func_decl -> string + = "camlidl_z3V3_Z3_func_decl_to_string" + +external model_to_string : context -> model -> string + = "camlidl_z3V3_Z3_model_to_string" + +external benchmark_to_smtlib_string : context -> string -> string -> string -> string -> ast array -> ast -> string + = "camlidl_z3_Z3_benchmark_to_smtlib_string_bytecode" "camlidl_z3V3_Z3_benchmark_to_smtlib_string" + +external parse_smtlib2_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + = "camlidl_z3_Z3_parse_smtlib2_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_string" + +external parse_smtlib2_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + = "camlidl_z3_Z3_parse_smtlib2_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_file" + +external parse_smtlib_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit + = "camlidl_z3_Z3_parse_smtlib_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib_string" + +external parse_smtlib_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit + = "camlidl_z3_Z3_parse_smtlib_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib_file" + +external get_smtlib_num_formulas : context -> int + = "camlidl_z3V3_Z3_get_smtlib_num_formulas" + +external get_smtlib_formula : context -> int -> ast + = "camlidl_z3V3_Z3_get_smtlib_formula" + +external get_smtlib_num_assumptions : context -> int + = "camlidl_z3V3_Z3_get_smtlib_num_assumptions" + +external get_smtlib_assumption : context -> int -> ast + = "camlidl_z3V3_Z3_get_smtlib_assumption" + +external get_smtlib_num_decls : context -> int + = "camlidl_z3V3_Z3_get_smtlib_num_decls" + +external get_smtlib_decl : context -> int -> func_decl + = "camlidl_z3V3_Z3_get_smtlib_decl" + +external get_smtlib_num_sorts : context -> int + = "camlidl_z3V3_Z3_get_smtlib_num_sorts" + +external get_smtlib_sort : context -> int -> sort + = "camlidl_z3V3_Z3_get_smtlib_sort" + +external get_smtlib_error : context -> string + = "camlidl_z3V3_Z3_get_smtlib_error" + +external parse_z3_string : context -> string -> ast + = "camlidl_z3_Z3_parse_z3V3_string" + +external parse_z3_file : context -> string -> ast + = "camlidl_z3_Z3_parse_z3V3_file" + +external get_version : unit -> int * int * int * int + = "camlidl_z3V3_Z3_get_version" + +external reset_memory : unit -> unit + = "camlidl_z3V3_Z3_reset_memory" + +external theory_mk_sort : context -> theory -> symbol -> sort + = "camlidl_z3V3_Z3_theory_mk_sort" + +external theory_mk_value : context -> theory -> symbol -> sort -> ast + = "camlidl_z3V3_Z3_theory_mk_value" + +external theory_mk_constant : context -> theory -> symbol -> sort -> ast + = "camlidl_z3V3_Z3_theory_mk_constant" + +external theory_mk_func_decl : context -> theory -> symbol -> sort array -> sort -> func_decl + = "camlidl_z3V3_Z3_theory_mk_func_decl" + +external theory_get_context : theory -> context + = "camlidl_z3V3_Z3_theory_get_context" + +external theory_assert_axiom : theory -> ast -> unit + = "camlidl_z3V3_Z3_theory_assert_axiom" + +external theory_assume_eq : theory -> ast -> ast -> unit + = "camlidl_z3V3_Z3_theory_assume_eq" + +external theory_enable_axiom_simplification : theory -> bool -> unit + = "camlidl_z3V3_Z3_theory_enable_axiom_simplification" + +external theory_get_eqc_root : theory -> ast -> ast + = "camlidl_z3V3_Z3_theory_get_eqc_root" + +external theory_get_eqc_next : theory -> ast -> ast + = "camlidl_z3V3_Z3_theory_get_eqc_next" + +external theory_get_num_parents : theory -> ast -> int + = "camlidl_z3V3_Z3_theory_get_num_parents" + +external theory_get_parent : theory -> ast -> int -> ast + = "camlidl_z3V3_Z3_theory_get_parent" + +external theory_is_value : theory -> ast -> bool + = "camlidl_z3V3_Z3_theory_is_value" + +external theory_is_decl : theory -> func_decl -> bool + = "camlidl_z3V3_Z3_theory_is_decl" + +external theory_get_num_elems : theory -> int + = "camlidl_z3V3_Z3_theory_get_num_elems" + +external theory_get_elem : theory -> int -> ast + = "camlidl_z3V3_Z3_theory_get_elem" + +external theory_get_num_apps : theory -> int + = "camlidl_z3V3_Z3_theory_get_num_apps" + +external theory_get_app : theory -> int -> ast + = "camlidl_z3V3_Z3_theory_get_app" + +external mk_injective_function : context -> symbol -> sort array -> sort -> func_decl + = "camlidl_z3V3_Z3_mk_injective_function" + +external set_logic : context -> string -> bool + = "camlidl_z3V3_Z3_set_logic" + +external push : context -> unit + = "camlidl_z3V3_Z3_push" + +external pop : context -> int -> unit + = "camlidl_z3V3_Z3_pop" + +external get_num_scopes : context -> int + = "camlidl_z3V3_Z3_get_num_scopes" + +external persist_ast : context -> ast -> int -> unit + = "camlidl_z3V3_Z3_persist_ast" + +external assert_cnstr : context -> ast -> unit + = "camlidl_z3V3_Z3_assert_cnstr" + +external check_and_get_model : context -> lbool * model + = "camlidl_z3V3_Z3_check_and_get_model" + +external check : context -> lbool + = "camlidl_z3V3_Z3_check" + +external check_assumptions : context -> ast array -> int -> ast array -> lbool * model * ast * int * ast array + = "camlidl_z3V3_Z3_check_assumptions" + +external get_implied_equalities : context -> ast array -> lbool * int array + = "camlidl_z3V3_Z3_get_implied_equalities" + +external del_model : context -> model -> unit + = "camlidl_z3V3_Z3_del_model" + +external soft_check_cancel : context -> unit + = "camlidl_z3V3_Z3_soft_check_cancel" + +external get_search_failure : context -> search_failure + = "camlidl_z3V3_Z3_get_search_failure" + +external mk_label : context -> symbol -> bool -> ast -> ast + = "camlidl_z3V3_Z3_mk_label" + +external get_relevant_labels : context -> literals + = "camlidl_z3V3_Z3_get_relevant_labels" + +external get_relevant_literals : context -> literals + = "camlidl_z3V3_Z3_get_relevant_literals" + +external get_guessed_literals : context -> literals + = "camlidl_z3V3_Z3_get_guessed_literals" + +external del_literals : context -> literals -> unit + = "camlidl_z3V3_Z3_del_literals" + +external get_num_literals : context -> literals -> int + = "camlidl_z3V3_Z3_get_num_literals" + +external get_label_symbol : context -> literals -> int -> symbol + = "camlidl_z3V3_Z3_get_label_symbol" + +external get_literal : context -> literals -> int -> ast + = "camlidl_z3V3_Z3_get_literal" + +external disable_literal : context -> literals -> int -> unit + = "camlidl_z3V3_Z3_disable_literal" + +external block_literals : context -> literals -> unit + = "camlidl_z3V3_Z3_block_literals" + +external get_model_num_constants : context -> model -> int + = "camlidl_z3V3_Z3_get_model_num_constants" + +external get_model_constant : context -> model -> int -> func_decl + = "camlidl_z3V3_Z3_get_model_constant" + +external get_model_num_funcs : context -> model -> int + = "camlidl_z3V3_Z3_get_model_num_funcs" + +external get_model_func_decl : context -> model -> int -> func_decl + = "camlidl_z3V3_Z3_get_model_func_decl" + +external eval_func_decl : context -> model -> func_decl -> bool * ast + = "camlidl_z3V3_Z3_eval_func_decl" + +external is_array_value : context -> model -> ast -> bool * int + = "camlidl_z3V3_Z3_is_array_value" + +external get_array_value : context -> model -> ast -> ast array -> ast array -> ast array * ast array * ast + = "camlidl_z3V3_Z3_get_array_value" + +external get_model_func_else : context -> model -> int -> ast + = "camlidl_z3V3_Z3_get_model_func_else" + +external get_model_func_num_entries : context -> model -> int -> int + = "camlidl_z3V3_Z3_get_model_func_num_entries" + +external get_model_func_entry_num_args : context -> model -> int -> int -> int + = "camlidl_z3V3_Z3_get_model_func_entry_num_args" + +external get_model_func_entry_arg : context -> model -> int -> int -> int -> ast + = "camlidl_z3V3_Z3_get_model_func_entry_arg" + +external get_model_func_entry_value : context -> model -> int -> int -> ast + = "camlidl_z3V3_Z3_get_model_func_entry_value" + +external eval : context -> model -> ast -> bool * ast + = "camlidl_z3V3_Z3_eval" + +external eval_decl : context -> model -> func_decl -> ast array -> bool * ast + = "camlidl_z3V3_Z3_eval_decl" + +external context_to_string : context -> string + = "camlidl_z3V3_Z3_context_to_string" + +external statistics_to_string : context -> string + = "camlidl_z3V3_Z3_statistics_to_string" + +external get_context_assignment : context -> ast + = "camlidl_z3V3_Z3_get_context_assignment" + + + + +(* Internal auxillary functions: *) + +(* Transform a pair of arrays into an array of pairs *) +let array_combine a b = + if Array.length a <> Array.length b then raise (Invalid_argument "array_combine"); + Array.init (Array.length a) (fun i->(a.(i),b.(i)));; + +(* [a |> b] is the pipeline operator for [b(a)] *) +let ( |> ) x f = f x;; + + +(* Extensions, except for refinement: *) +let mk_context_x configs = + let config = mk_config() in + let f(param_id,param_value) = set_param_value config param_id param_value in + Array.iter f configs; + let context = mk_context config in + del_config config; + context;; + +let get_app_args c a = + Array.init (get_app_num_args c a) (get_app_arg c a);; + +let get_domains c d = + Array.init (get_domain_size c d) (get_domain c d);; + +let get_array_sort c t = (get_array_sort_domain c t, get_array_sort_range c t);; + +let get_tuple_sort c ty = + (get_tuple_sort_mk_decl c ty, + Array.init (get_tuple_sort_num_fields c ty) (get_tuple_sort_field_decl c ty));; + +type datatype_constructor_refined = { + constructor : func_decl; + recognizer : func_decl; + accessors : func_decl array +} + +let get_datatype_sort c ty = + Array.init (get_datatype_sort_num_constructors c ty) + (fun idx_c -> + let constr = get_datatype_sort_constructor c ty idx_c in + let recog = get_datatype_sort_recognizer c ty idx_c in + let num_acc = get_domain_size c constr in + { constructor = constr; + recognizer = recog; + accessors = Array.init num_acc (get_datatype_sort_constructor_accessor c ty idx_c); + }) + +let get_model_constants c m = + Array.init (get_model_num_constants c m) (get_model_constant c m);; + + +let get_model_func_entry c m i j = + (Array.init + (get_model_func_entry_num_args c m i j) + (get_model_func_entry_arg c m i j), + get_model_func_entry_value c m i j);; + +let get_model_func_entries c m i = + Array.init (get_model_func_num_entries c m i) (get_model_func_entry c m i);; + +let get_model_funcs c m = + Array.init (get_model_num_funcs c m) + (fun i->(get_model_func_decl c m i |> get_decl_name c, + get_model_func_entries c m i, + get_model_func_else c m i));; + +let get_smtlib_formulas c = + Array.init (get_smtlib_num_formulas c) (get_smtlib_formula c);; + +let get_smtlib_assumptions c = + Array.init (get_smtlib_num_assumptions c) (get_smtlib_assumption c);; + +let get_smtlib_decls c = + Array.init (get_smtlib_num_decls c) (get_smtlib_decl c);; + +let get_smtlib_parse_results c = + (get_smtlib_formulas c, get_smtlib_assumptions c, get_smtlib_decls c);; + +let parse_smtlib_string_formula c a1 a2 a3 a4 a5 = + (parse_smtlib_string c a1 a2 a3 a4 a5; + match get_smtlib_formulas c with [|f|] -> f | _ -> failwith "Z3: parse_smtlib_string_formula");; + +let parse_smtlib_file_formula c a1 a2 a3 a4 a5 = + (parse_smtlib_file c a1 a2 a3 a4 a5; + match get_smtlib_formulas c with [|f|] -> f | _ -> failwith "Z3: parse_smtlib_file_formula");; + +let parse_smtlib_string_x c a1 a2 a3 a4 a5 = + (parse_smtlib_string c a1 a2 a3 a4 a5; get_smtlib_parse_results c);; + +let parse_smtlib_file_x c a1 a2 a3 a4 a5 = + (parse_smtlib_file c a1 a2 a3 a4 a5; get_smtlib_parse_results c);; + +(* Refinement: *) + +type symbol_refined = + | Symbol_int of int + | Symbol_string of string + | Symbol_unknown;; + +let symbol_refine c s = + match get_symbol_kind c s with + | INT_SYMBOL -> Symbol_int (get_symbol_int c s) + | STRING_SYMBOL -> Symbol_string (get_symbol_string c s);; + +type sort_refined = + | Sort_uninterpreted of symbol + | Sort_bool + | Sort_int + | Sort_real + | Sort_bv of int + | Sort_array of (sort * sort) + | Sort_datatype of datatype_constructor_refined array + | Sort_relation + | Sort_finite_domain + | Sort_unknown of symbol;; + +let sort_refine c ty = + match get_sort_kind c ty with + | UNINTERPRETED_SORT -> Sort_uninterpreted (get_sort_name c ty) + | BOOL_SORT -> Sort_bool + | INT_SORT -> Sort_int + | REAL_SORT -> Sort_real + | BV_SORT -> Sort_bv (get_bv_sort_size c ty) + | ARRAY_SORT -> Sort_array (get_array_sort_domain c ty, get_array_sort_range c ty) + | DATATYPE_SORT -> Sort_datatype (get_datatype_sort c ty) + | RELATION_SORT -> Sort_relation + | FINITE_DOMAIN_SORT -> Sort_finite_domain + | UNKNOWN_SORT -> Sort_unknown (get_sort_name c ty);; + +let get_pattern_terms c p = + Array.init (get_pattern_num_terms c p) (get_pattern c p) + +type binder_type = | Forall | Exists + +type numeral_refined = + | Numeral_small of int64 * int64 + | Numeral_large of string + +type term_refined = + | Term_app of decl_kind * func_decl * ast array + | Term_quantifier of binder_type * int * ast array array * (symbol *sort) array * ast + | Term_numeral of numeral_refined * sort + | Term_var of int * sort + +let term_refine c t = + match get_ast_kind c t with + | NUMERAL_AST -> + let (is_small, n, d) = get_numeral_small c t in + if is_small then + Term_numeral(Numeral_small(n,d), get_sort c t) + else + Term_numeral(Numeral_large(get_numeral_string c t), get_sort c t) + | APP_AST -> + let t' = to_app c t in + let f = get_app_decl c t' in + let num_args = get_app_num_args c t' in + let args = Array.init num_args (get_app_arg c t') in + let k = get_decl_kind c f in + Term_app (k, f, args) + | QUANTIFIER_AST -> + let bt = if is_quantifier_forall c t then Forall else Exists in + let w = get_quantifier_weight c t in + let np = get_quantifier_num_patterns c t in + let pats = Array.init np (get_quantifier_pattern_ast c t) in + let pats = Array.map (get_pattern_terms c) pats in + let nb = get_quantifier_num_bound c t in + let bound = Array.init nb + (fun i -> (get_quantifier_bound_name c t i, get_quantifier_bound_sort c t i)) in + let body = get_quantifier_body c t in + Term_quantifier(bt, w, pats, bound, body) + | VAR_AST -> + Term_var(get_index_value c t, get_sort c t) + | _ -> assert false + +type theory_callbacks = + { + mutable delete_theory : unit -> unit; + mutable reduce_eq : ast -> ast -> ast option; + mutable reduce_app : func_decl -> ast array -> ast option; + mutable reduce_distinct : ast array -> ast option; + mutable final_check : unit -> bool; + mutable new_app : ast -> unit; + mutable new_elem : ast -> unit; + mutable init_search: unit -> unit; + mutable push: unit -> unit; + mutable pop: unit -> unit; + mutable restart : unit -> unit; + mutable reset: unit -> unit; + mutable new_eq : ast -> ast -> unit; + mutable new_diseq : ast -> ast -> unit; + mutable new_assignment: ast -> bool -> unit; + mutable new_relevant : ast -> unit; + } + +let mk_theory_callbacks() = + { + delete_theory = (fun () -> ()); + reduce_eq = (fun _ _ -> None); + reduce_app = (fun _ _ -> None); + reduce_distinct = (fun _ -> None); + final_check = (fun _ -> true); + new_app = (fun _ -> ()); + new_elem = (fun _ -> ()); + init_search= (fun () -> ()); + push= (fun () -> ()); + pop= (fun () -> ()); + restart = (fun () -> ()); + reset= (fun () -> ()); + new_eq = (fun _ _ -> ()); + new_diseq = (fun _ _ -> ()); + new_assignment = (fun _ _ -> ()); + new_relevant = (fun _ -> ()); + } + + +external get_theory_callbacks : theory -> theory_callbacks = "get_theory_callbacks" +external mk_theory_register : context -> string -> theory_callbacks -> theory = "mk_theory_register" +external set_delete_callback_register : theory -> unit = "set_delete_callback_register" +external set_reduce_app_callback_register : theory -> unit = "set_reduce_app_callback_register" +external set_reduce_eq_callback_register : theory -> unit = "set_reduce_eq_callback_register" +external set_reduce_distinct_callback_register : theory -> unit = "set_reduce_distinct_callback_register" +external set_new_app_callback_register : theory -> unit = "set_new_app_callback_register" +external set_new_elem_callback_register : theory -> unit = "set_new_elem_callback_register" +external set_init_search_callback_register : theory -> unit = "set_init_search_callback_register" +external set_push_callback_register : theory -> unit = "set_push_callback_register" +external set_pop_callback_register : theory -> unit = "set_pop_callback_register" +external set_restart_callback_register : theory -> unit = "set_restart_callback_register" +external set_reset_callback_register : theory -> unit = "set_reset_callback_register" +external set_final_check_callback_register : theory -> unit = "set_final_check_callback_register" +external set_new_eq_callback_register : theory -> unit = "set_new_eq_callback_register" +external set_new_diseq_callback_register : theory -> unit = "set_new_diseq_callback_register" +external set_new_assignment_callback_register : theory -> unit = "set_new_assignment_callback_register" +external set_new_relevant_callback_register : theory -> unit = "set_new_relevant_callback_register" + +let is_some opt = + match opt with + | Some v -> true + | None -> false + +let get_some opt = + match opt with + | Some v -> v + | None -> failwith "None unexpected" + + + + +let apply_delete (th:theory_callbacks) = th.delete_theory () +let set_delete_callback th cb = + let cbs = get_theory_callbacks th in + cbs.delete_theory <- cb; + set_delete_callback_register th + +let mk_theory context name = + Callback.register "is_some" is_some; + Callback.register "get_some" get_some; + Callback.register "apply_delete" apply_delete; + let cbs = mk_theory_callbacks() in + mk_theory_register context name cbs + + +let apply_reduce_app (th:theory_callbacks) f args = th.reduce_app f args +let set_reduce_app_callback th cb = + Callback.register "apply_reduce_app" apply_reduce_app; + let cbs = get_theory_callbacks th in + cbs.reduce_app <- cb; + set_reduce_app_callback_register th + +let apply_reduce_eq (th:theory_callbacks) a b = th.reduce_eq a b +let set_reduce_eq_callback th cb = + Callback.register "apply_reduce_eq" apply_reduce_eq; + let cbs = get_theory_callbacks th in + cbs.reduce_eq <- cb; + set_reduce_eq_callback_register th + +let apply_reduce_distinct (th:theory_callbacks) args = th.reduce_distinct args +let set_reduce_distinct_callback th cb = + Callback.register "apply_reduce_distinct" apply_reduce_distinct; + let cbs = get_theory_callbacks th in + cbs.reduce_distinct <- cb; + set_reduce_distinct_callback_register th + + +let apply_new_app (th:theory_callbacks) a = th.new_app a +let set_new_app_callback th cb = + Callback.register "apply_new_app" apply_new_app; + let cbs = get_theory_callbacks th in + cbs.new_app <- cb; + set_new_app_callback_register th + +let apply_new_elem (th:theory_callbacks) a = th.new_elem a +let set_new_elem_callback th cb = + Callback.register "apply_new_elem" apply_new_elem; + let cbs = get_theory_callbacks th in + cbs.new_elem <- cb; + set_new_elem_callback_register th + + +let apply_init_search (th:theory_callbacks) = th.init_search() +let set_init_search_callback th cb = + Callback.register "apply_init_search" apply_init_search; + let cbs = get_theory_callbacks th in + cbs.init_search <- cb; + set_init_search_callback_register th + + +let apply_push (th:theory_callbacks) = th.push() +let set_push_callback th cb = + Callback.register "apply_push" apply_push; + let cbs = get_theory_callbacks th in + cbs.push <- cb; + set_push_callback_register th + +let apply_pop (th:theory_callbacks) = th.pop() +let set_pop_callback th cb = + Callback.register "apply_pop" apply_pop; + let cbs = get_theory_callbacks th in + cbs.pop <- cb; + set_pop_callback_register th + + +let apply_restart (th:theory_callbacks) = th.restart() +let set_restart_callback th cb = + Callback.register "apply_restart" apply_restart; + let cbs = get_theory_callbacks th in + cbs.restart <- cb; + set_restart_callback_register th + + +let apply_reset (th:theory_callbacks) = th.reset() +let set_reset_callback th cb = + Callback.register "apply_reset" apply_reset; + let cbs = get_theory_callbacks th in + cbs.reset <- cb; + set_reset_callback_register th + +let apply_final_check (th:theory_callbacks) = th.final_check() +let set_final_check_callback th cb = + Callback.register "apply_final_check" apply_final_check; + let cbs = get_theory_callbacks th in + cbs.final_check <- cb; + set_final_check_callback_register th + +let apply_new_eq (th:theory_callbacks) a b = th.new_eq a b +let set_new_eq_callback th cb = + Callback.register "apply_new_eq" apply_new_eq; + let cbs = get_theory_callbacks th in + cbs.new_eq <- cb; + set_new_eq_callback_register th + + +let apply_new_diseq (th:theory_callbacks) a b = th.new_diseq a b +let set_new_diseq_callback th cb = + Callback.register "apply_new_diseq" apply_new_diseq; + let cbs = get_theory_callbacks th in + cbs.new_diseq <- cb; + set_new_diseq_callback_register th + +let apply_new_assignment (th:theory_callbacks) a b = th.new_assignment a b +let set_new_assignment_callback th cb = + Callback.register "apply_new_assignment" apply_new_assignment; + let cbs = get_theory_callbacks th in + cbs.new_assignment <- cb; + set_new_assignment_callback_register th + +let apply_new_relevant (th:theory_callbacks) a = th.new_relevant a +let set_new_relevant_callback th cb = + Callback.register "apply_new_relevant" apply_new_relevant; + let cbs = get_theory_callbacks th in + cbs.new_relevant <- cb; + set_new_relevant_callback_register th + + + +end + diff --git a/ml/z3.mli b/ml/z3.mli new file mode 100644 index 000000000..2d782aa10 --- /dev/null +++ b/ml/z3.mli @@ -0,0 +1,9983 @@ +(* File generated from z3.idl *) + +type context +and symbol +and ast +and sort = private ast +and func_decl = private ast +and app = private ast +and pattern = private ast +and params +and param_descrs +and model +and func_interp +and func_entry +and fixedpoint +and ast_vector +and ast_map +and goal +and tactic +and probe +and apply_result +and solver +and stats + + + +and constructor +and constructor_list + +and lbool = + | L_FALSE + | L_UNDEF + | L_TRUE + +and symbol_kind = + | INT_SYMBOL + | STRING_SYMBOL + +and parameter_kind = + | PARAMETER_INT + | PARAMETER_DOUBLE + | PARAMETER_RATIONAL + | PARAMETER_SYMBOL + | PARAMETER_SORT + | PARAMETER_AST + | PARAMETER_FUNC_DECL + +and sort_kind = + | UNINTERPRETED_SORT + | BOOL_SORT + | INT_SORT + | REAL_SORT + | BV_SORT + | ARRAY_SORT + | DATATYPE_SORT + | RELATION_SORT + | FINITE_DOMAIN_SORT + | UNKNOWN_SORT + +and ast_kind = + | NUMERAL_AST + | APP_AST + | VAR_AST + | QUANTIFIER_AST + | SORT_AST + | FUNC_DECL_AST + | UNKNOWN_AST + +and decl_kind = + | OP_TRUE + | OP_FALSE + | OP_EQ + | OP_DISTINCT + | OP_ITE + | OP_AND + | OP_OR + | OP_IFF + | OP_XOR + | OP_NOT + | OP_IMPLIES + | OP_OEQ + | OP_ANUM + | OP_AGNUM + | OP_LE + | OP_GE + | OP_LT + | OP_GT + | OP_ADD + | OP_SUB + | OP_UMINUS + | OP_MUL + | OP_DIV + | OP_IDIV + | OP_REM + | OP_MOD + | OP_TO_REAL + | OP_TO_INT + | OP_IS_INT + | OP_POWER + | OP_STORE + | OP_SELECT + | OP_CONST_ARRAY + | OP_ARRAY_MAP + | OP_ARRAY_DEFAULT + | OP_SET_UNION + | OP_SET_INTERSECT + | OP_SET_DIFFERENCE + | OP_SET_COMPLEMENT + | OP_SET_SUBSET + | OP_AS_ARRAY + | OP_BNUM + | OP_BIT1 + | OP_BIT0 + | OP_BNEG + | OP_BADD + | OP_BSUB + | OP_BMUL + | OP_BSDIV + | OP_BUDIV + | OP_BSREM + | OP_BUREM + | OP_BSMOD + | OP_BSDIV0 + | OP_BUDIV0 + | OP_BSREM0 + | OP_BUREM0 + | OP_BSMOD0 + | OP_ULEQ + | OP_SLEQ + | OP_UGEQ + | OP_SGEQ + | OP_ULT + | OP_SLT + | OP_UGT + | OP_SGT + | OP_BAND + | OP_BOR + | OP_BNOT + | OP_BXOR + | OP_BNAND + | OP_BNOR + | OP_BXNOR + | OP_CONCAT + | OP_SIGN_EXT + | OP_ZERO_EXT + | OP_EXTRACT + | OP_REPEAT + | OP_BREDOR + | OP_BREDAND + | OP_BCOMP + | OP_BSHL + | OP_BLSHR + | OP_BASHR + | OP_ROTATE_LEFT + | OP_ROTATE_RIGHT + | OP_EXT_ROTATE_LEFT + | OP_EXT_ROTATE_RIGHT + | OP_INT2BV + | OP_BV2INT + | OP_CARRY + | OP_XOR3 + | OP_PR_UNDEF + | OP_PR_TRUE + | OP_PR_ASSERTED + | OP_PR_GOAL + | OP_PR_MODUS_PONENS + | OP_PR_REFLEXIVITY + | OP_PR_SYMMETRY + | OP_PR_TRANSITIVITY + | OP_PR_TRANSITIVITY_STAR + | OP_PR_MONOTONICITY + | OP_PR_QUANT_INTRO + | OP_PR_DISTRIBUTIVITY + | OP_PR_AND_ELIM + | OP_PR_NOT_OR_ELIM + | OP_PR_REWRITE + | OP_PR_REWRITE_STAR + | OP_PR_PULL_QUANT + | OP_PR_PULL_QUANT_STAR + | OP_PR_PUSH_QUANT + | OP_PR_ELIM_UNUSED_VARS + | OP_PR_DER + | OP_PR_QUANT_INST + | OP_PR_HYPOTHESIS + | OP_PR_LEMMA + | OP_PR_UNIT_RESOLUTION + | OP_PR_IFF_TRUE + | OP_PR_IFF_FALSE + | OP_PR_COMMUTATIVITY + | OP_PR_DEF_AXIOM + | OP_PR_DEF_INTRO + | OP_PR_APPLY_DEF + | OP_PR_IFF_OEQ + | OP_PR_NNF_POS + | OP_PR_NNF_NEG + | OP_PR_NNF_STAR + | OP_PR_CNF_STAR + | OP_PR_SKOLEMIZE + | OP_PR_MODUS_PONENS_OEQ + | OP_PR_TH_LEMMA + | OP_RA_STORE + | OP_RA_EMPTY + | OP_RA_IS_EMPTY + | OP_RA_JOIN + | OP_RA_UNION + | OP_RA_WIDEN + | OP_RA_PROJECT + | OP_RA_FILTER + | OP_RA_NEGATION_FILTER + | OP_RA_RENAME + | OP_RA_COMPLEMENT + | OP_RA_SELECT + | OP_RA_CLONE + | OP_FD_LT + | OP_LABEL + | OP_LABEL_LIT + | OP_DT_CONSTRUCTOR + | OP_DT_RECOGNISER + | OP_DT_ACCESSOR + | OP_UNINTERPRETED + +and param_kind = + | PK_UINT + | PK_BOOL + | PK_DOUBLE + | PK_SYMBOL + | PK_STRING + | PK_OTHER + | PK_INVALID + +and search_failure = + | NO_FAILURE + | UNKNOWN + | TIMEOUT + | MEMOUT_WATERMARK + | CANCELED + | NUM_CONFLICTS + | THEORY + | QUANTIFIERS + +and ast_print_mode = + | PRINT_SMTLIB_FULL + | PRINT_LOW_LEVEL + | PRINT_SMTLIB_COMPLIANT + | PRINT_SMTLIB2_COMPLIANT + +and error_code = + | OK + | SORT_ERROR + | IOB + | INVALID_ARG + | PARSER_ERROR + | NO_PARSER + | INVALID_PATTERN + | MEMOUT_FAIL + | FILE_ACCESS_ERROR + | INTERNAL_FATAL + | INVALID_USAGE + | DEC_REF_ERROR + | EXCEPTION + +and goal_prec = + | GOAL_PRECISE + | GOAL_UNDER + | GOAL_OVER + | GOAL_UNDER_OVER + + +(** + + +*) +(** + {2 {L Types}} + + + Most of the types in the API are abstract. + + + - [context]: manager of all other Z3 objects, global configuration options, etc. + - [symbol]: Lisp-like symbol used to name types, constants, and functions. A symbol can be created using string or integers. + - [ast]: abstract syntax tree node. That is, the data-structure used in Z3 to represent terms, formulas and types. + - [sort]: kind of AST used to represent types. + - [func_decl]: kind of AST used to represent function symbols. + - [app]: kind of AST used to represent function applications. + - [pattern]: kind of AST used to represent pattern and multi-patterns used to guide quantifier instantiation. + + - [params]: parameter set used to configure many components such as: simplifiers, tactics, solvers, etc. + - [model]: model for the constraints asserted into the logical context. + - [func_interp]: interpretation of a function in a model. + - [func_entry]: representation of the value of a [func_interp] at a particular point. + - [fixedpoint]: context for the recursive predicate solver. + - [ast_vector]: vector of [ast] objects. + - [ast_map]: mapping from [ast] to [ast] objects. + - [goal]: set of formulas that can be solved and/or transformed using tactics and solvers. + - [tactic]: basic building block for creating custom solvers for specific problem domains. + - [probe]: function/predicate used to inspect a goal and collect information that may be used to decide which solver and/or preprocessing step will be used. + - [apply_result]: collection of subgoals resulting from applying of a tactic to a goal. + - [solver]: (incremental) solver, possibly specialized by a particular tactic or logic. + - [stats]: statistical data for a solver. +*) +(** + {!lbool} + Lifted Boolean type: [false], [undefined], [true]. +*) +(** + {!symbol_kind} + The different kinds of symbol. + In Z3, a symbol can be represented using integers and strings (See {!get_symbol_kind}). + + - {b See also}: {!mk_int_symbol} + - {b See also}: {!mk_string_symbol} +*) +(** + {!parameter_kind} + The different kinds of parameters that can be associated with function symbols. + - {b See also}: {!get_decl_num_parameters} + - {b See also}: {!get_decl_parameter_kind} + + - PARAMETER_INT is used for integer parameters. + - PARAMETER_DOUBLE is used for double parameters. + - PARAMETER_RATIONAL is used for parameters that are rational numbers. + - PARAMETER_SYMBOL is used for parameters that are symbols. + - PARAMETER_SORT is used for sort parameters. + - PARAMETER_AST is used for expression parameters. + - PARAMETER_FUNC_DECL is used for function declaration parameters. +*) +(** + {!sort_kind} + The different kinds of Z3 types (See {!get_sort_kind}). +*) +(** + {!ast_kind} + The different kinds of Z3 AST (abstract syntax trees). That is, terms, formulas and types. + + - APP_AST: constant and applications + - NUMERAL_AST: numeral constants + - VAR_AST: bound variables + - QUANTIFIER_AST: quantifiers + - SORT_AST: sort + - FUNC_DECL_AST: function declaration + - UNKNOWN_AST: internal +*) +(** + {!decl_kind} + The different kinds of interpreted function kinds. + + - OP_TRUE The constant true. + + - OP_FALSE The constant false. + + - OP_EQ The equality predicate. + + - OP_DISTINCT The n-ary distinct predicate (every argument is mutually distinct). + + - OP_ITE The ternary if-then-else term. + + - OP_AND n-ary conjunction. + + - OP_OR n-ary disjunction. + + - OP_IFF equivalence (binary). + + - OP_XOR Exclusive or. + + - OP_NOT Negation. + + - OP_IMPLIES Implication. + + - OP_OEQ Binary equivalence modulo namings. This binary predicate is used in proof terms. + It captures equisatisfiability and equivalence modulo renamings. + + - OP_ANUM Arithmetic numeral. + + - OP_AGNUM Arithmetic algebraic numeral. Algebraic numbers are used to represent irrational numbers in Z3. + + - OP_LE <=. + + - OP_GE >=. + + - OP_LT <. + + - OP_GT >. + + - OP_ADD Addition - Binary. + + - OP_SUB Binary subtraction. + + - OP_UMINUS Unary minus. + + - OP_MUL Multiplication - Binary. + + - OP_DIV Division - Binary. + + - OP_IDIV Integer division - Binary. + + - OP_REM Remainder - Binary. + + - OP_MOD Modulus - Binary. + + - OP_TO_REAL Coercion of integer to real - Unary. + + - OP_TO_INT Coercion of real to integer - Unary. + + - OP_IS_INT Check if real is also an integer - Unary. + + - OP_POWER Power operator x^y. + + - OP_STORE Array store. It satisfies select(store(a,i,v),j) = if i = j then v else select(a,j). + Array store takes at least 3 arguments. + + - OP_SELECT Array select. + + - OP_CONST_ARRAY The constant array. For example, select(const(v),i) = v holds for every v and i. The function is unary. + + - OP_ARRAY_DEFAULT Default value of arrays. For example default(const(v)) = v. The function is unary. + + - OP_ARRAY_MAP Array map operator. + It satisfies map[f](a1,..,a_n)[i] = f(a1[i],...,a_n[i]) for every i. + + - OP_SET_UNION Set union between two Booelan arrays (two arrays whose range type is Boolean). The function is binary. + + - OP_SET_INTERSECT Set intersection between two Boolean arrays. The function is binary. + + - OP_SET_DIFFERENCE Set difference between two Boolean arrays. The function is binary. + + - OP_SET_COMPLEMENT Set complement of a Boolean array. The function is unary. + + - OP_SET_SUBSET Subset predicate between two Boolean arrays. The relation is binary. + + - OP_AS_ARRAY An array value that behaves as the function graph of the + function passed as parameter. + + - OP_BNUM Bit-vector numeral. + + - OP_BIT1 One bit bit-vector. + + - OP_BIT0 Zero bit bit-vector. + + - OP_BNEG Unary minus. + + - OP_BADD Binary addition. + + - OP_BSUB Binary subtraction. + + - OP_BMUL Binary multiplication. + + - OP_BSDIV Binary signed division. + + - OP_BUDIV Binary unsigned int division. + + - OP_BSREM Binary signed remainder. + + - OP_BUREM Binary unsigned int remainder. + + - OP_BSMOD Binary signed modulus. + + - OP_BSDIV0 Unary function. bsdiv(x,0) is congruent to bsdiv0(x). + + - OP_BUDIV0 Unary function. budiv(x,0) is congruent to budiv0(x). + + - OP_BSREM0 Unary function. bsrem(x,0) is congruent to bsrem0(x). + + - OP_BUREM0 Unary function. burem(x,0) is congruent to burem0(x). + + - OP_BSMOD0 Unary function. bsmod(x,0) is congruent to bsmod0(x). + + - OP_ULEQ Unsigned bit-vector <= - Binary relation. + + - OP_SLEQ Signed bit-vector <= - Binary relation. + + - OP_UGEQ Unsigned bit-vector >= - Binary relation. + + - OP_SGEQ Signed bit-vector >= - Binary relation. + + - OP_ULT Unsigned bit-vector < - Binary relation. + + - OP_SLT Signed bit-vector < - Binary relation. + + - OP_UGT Unsigned bit-vector > - Binary relation. + + - OP_SGT Signed bit-vector > - Binary relation. + + - OP_BAND Bit-wise and - Binary. + + - OP_BOR Bit-wise or - Binary. + + - OP_BNOT Bit-wise not - Unary. + + - OP_BXOR Bit-wise xor - Binary. + + - OP_BNAND Bit-wise nand - Binary. + + - OP_BNOR Bit-wise nor - Binary. + + - OP_BXNOR Bit-wise xnor - Binary. + + - OP_CONCAT Bit-vector concatenation - Binary. + + - OP_SIGN_EXT Bit-vector sign extension. + + - OP_ZERO_EXT Bit-vector zero extension. + + - OP_EXTRACT Bit-vector extraction. + + - OP_REPEAT Repeat bit-vector n times. + + - OP_BREDOR Bit-vector reduce or - Unary. + + - OP_BREDAND Bit-vector reduce and - Unary. + + - OP_BCOMP . + + - OP_BSHL Shift left. + + - OP_BLSHR Logical shift right. + + - OP_BASHR Arithmetical shift right. + + - OP_ROTATE_LEFT Left rotation. + + - OP_ROTATE_RIGHT Right rotation. + + - OP_EXT_ROTATE_LEFT (extended) Left rotation. Similar to OP_ROTATE_LEFT, but it is a binary operator instead of a parametric one. + + - OP_EXT_ROTATE_RIGHT (extended) Right rotation. Similar to OP_ROTATE_RIGHT, but it is a binary operator instead of a parametric one. + + - OP_INT2BV Coerce integer to bit-vector. NB. This function + is not supported by the decision procedures. Only the most + rudimentary simplification rules are applied to this function. + + - OP_BV2INT Coerce bit-vector to integer. NB. This function + is not supported by the decision procedures. Only the most + rudimentary simplification rules are applied to this function. + + - OP_CARRY Compute the carry bit in a full-adder. + The meaning is given by the equivalence + (carry l1 l2 l3) <=> (or (and l1 l2) (and l1 l3) (and l2 l3))) + + - OP_XOR3 Compute ternary XOR. + The meaning is given by the equivalence + (xor3 l1 l2 l3) <=> (xor (xor l1 l2) l3) + + - OP_PR_UNDEF: Undef/Null proof object. + + - OP_PR_TRUE: Proof for the expression 'true'. + + - OP_PR_ASSERTED: Proof for a fact asserted by the user. + + - OP_PR_GOAL: Proof for a fact (tagged as goal) asserted by the user. + + - OP_PR_MODUS_PONENS: Given a proof for p and a proof for (implies p q), produces a proof for q. + {e + T1: p + T2: (implies p q) + [mp T1 T2]: q + } + The second antecedents may also be a proof for (iff p q). + + - OP_PR_REFLEXIVITY: A proof for (R t t), where R is a reflexive relation. This proof object has no antecedents. + The only reflexive relations that are used are + equivalence modulo namings, equality and equivalence. + That is, R is either '~', '=' or 'iff'. + + - OP_PR_SYMMETRY: Given an symmetric relation R and a proof for (R t s), produces a proof for (R s t). + {e + T1: (R t s) + [symmetry T1]: (R s t) + } + T1 is the antecedent of this proof object. + + - OP_PR_TRANSITIVITY: Given a transitive relation R, and proofs for (R t s) and (R s u), produces a proof + for (R t u). + {e + T1: (R t s) + T2: (R s u) + [trans T1 T2]: (R t u) + } + + - OP_PR_TRANSITIVITY_STAR: Condensed transitivity proof. This proof object is only used if the parameter PROOF_MODE is 1. + It combines several symmetry and transitivity proofs. + + Example: + {e + T1: (R a b) + T2: (R c b) + T3: (R c d) + [trans* T1 T2 T3]: (R a d) + } + R must be a symmetric and transitive relation. + + Assuming that this proof object is a proof for (R s t), then + a proof checker must check if it is possible to prove (R s t) + using the antecedents, symmetry and transitivity. That is, + if there is a path from s to t, if we view every + antecedent (R a b) as an edge between a and b. + + - OP_PR_MONOTONICITY: Monotonicity proof object. + {e + T1: (R t_1 s_1) + ... + Tn: (R t_n s_n) + [monotonicity T1 ... Tn]: (R (f t_1 ... t_n) (f s_1 ... s_n)) + } + Remark: if t_i == s_i, then the antecedent Ti is suppressed. + That is, reflexivity proofs are supressed to save space. + + - OP_PR_QUANT_INTRO: Given a proof for (~ p q), produces a proof for (~ (forall (x) p) (forall (x) q)). + + T1: (~ p q) + [quant-intro T1]: (~ (forall (x) p) (forall (x) q)) + + - OP_PR_DISTRIBUTIVITY: Distributivity proof object. + Given that f (= or) distributes over g (= and), produces a proof for + + (= (f a (g c d)) + (g (f a c) (f a d))) + + If f and g are associative, this proof also justifies the following equality: + + (= (f (g a b) (g c d)) + (g (f a c) (f a d) (f b c) (f b d))) + + where each f and g can have arbitrary number of arguments. + + This proof object has no antecedents. + Remark. This rule is used by the CNF conversion pass and + instantiated by f = or, and g = and. + + - OP_PR_AND_ELIM: Given a proof for (and l_1 ... l_n), produces a proof for l_i + + {e + T1: (and l_1 ... l_n) + [and-elim T1]: l_i + } + - OP_PR_NOT_OR_ELIM: Given a proof for (not (or l_1 ... l_n)), produces a proof for (not l_i). + + {e + T1: (not (or l_1 ... l_n)) + [not-or-elim T1]: (not l_i) + } + + - OP_PR_REWRITE: A proof for a local rewriting step (= t s). + The head function symbol of t is interpreted. + + This proof object has no antecedents. + The conclusion of a rewrite rule is either an equality (= t s), + an equivalence (iff t s), or equi-satisfiability (~ t s). + Remark: if f is bool, then = is iff. + + + Examples: + {e + (= (+ x 0) x) + (= (+ x 1 2) (+ 3 x)) + (iff (or x false) x) + } + + - OP_PR_REWRITE_STAR: A proof for rewriting an expression t into an expression s. + This proof object is used if the parameter PROOF_MODE is 1. + This proof object can have n antecedents. + The antecedents are proofs for equalities used as substitution rules. + The object is also used in a few cases if the parameter PROOF_MODE is 2. + The cases are: + - When applying contextual simplification (CONTEXT_SIMPLIFIER=true) + - When converting bit-vectors to Booleans (BIT2BOOL=true) + - When pulling ite expression up (PULL_CHEAP_ITE_TREES=true) + + - OP_PR_PULL_QUANT: A proof for (iff (f (forall (x) q(x)) r) (forall (x) (f (q x) r))). This proof object has no antecedents. + + - OP_PR_PULL_QUANT_STAR: A proof for (iff P Q) where Q is in prenex normal form. + This proof object is only used if the parameter PROOF_MODE is 1. + This proof object has no antecedents. + + - OP_PR_PUSH_QUANT: A proof for: + + {e + (iff (forall (x_1 ... x_m) (and p_1[x_1 ... x_m] ... p_n[x_1 ... x_m])) + (and (forall (x_1 ... x_m) p_1[x_1 ... x_m]) + ... + (forall (x_1 ... x_m) p_n[x_1 ... x_m]))) + } + This proof object has no antecedents. + + - OP_PR_ELIM_UNUSED_VARS: + A proof for (iff (forall (x_1 ... x_n y_1 ... y_m) p[x_1 ... x_n]) + (forall (x_1 ... x_n) p[x_1 ... x_n])) + + It is used to justify the elimination of unused variables. + This proof object has no antecedents. + + - OP_PR_DER: A proof for destructive equality resolution: + (iff (forall (x) (or (not (= x t)) P[x])) P[t]) + if x does not occur in t. + + This proof object has no antecedents. + + Several variables can be eliminated simultaneously. + + - OP_PR_QUANT_INST: A proof of (or (not (forall (x) (P x))) (P a)) + + - OP_PR_HYPOTHESIS: Mark a hypothesis in a natural deduction style proof. + + - OP_PR_LEMMA: + + {e + T1: false + [lemma T1]: (or (not l_1) ... (not l_n)) + } + This proof object has one antecedent: a hypothetical proof for false. + It converts the proof in a proof for (or (not l_1) ... (not l_n)), + when T1 contains the hypotheses: l_1, ..., l_n. + + - OP_PR_UNIT_RESOLUTION: + {e + T1: (or l_1 ... l_n l_1' ... l_m') + T2: (not l_1) + ... + T(n+1): (not l_n) + [unit-resolution T1 ... T(n+1)]: (or l_1' ... l_m') + } + + - OP_PR_IFF_TRUE: + {e + T1: p + [iff-true T1]: (iff p true) + } + + - OP_PR_IFF_FALSE: + {e + T1: (not p) + [iff-false T1]: (iff p false) + } + + - OP_PR_COMMUTATIVITY: + + [comm]: (= (f a b) (f b a)) + + f is a commutative operator. + + This proof object has no antecedents. + Remark: if f is bool, then = is iff. + + - OP_PR_DEF_AXIOM: Proof object used to justify Tseitin's like axioms: + + {e + (or (not (and p q)) p) + (or (not (and p q)) q) + (or (not (and p q r)) p) + (or (not (and p q r)) q) + (or (not (and p q r)) r) + ... + (or (and p q) (not p) (not q)) + (or (not (or p q)) p q) + (or (or p q) (not p)) + (or (or p q) (not q)) + (or (not (iff p q)) (not p) q) + (or (not (iff p q)) p (not q)) + (or (iff p q) (not p) (not q)) + (or (iff p q) p q) + (or (not (ite a b c)) (not a) b) + (or (not (ite a b c)) a c) + (or (ite a b c) (not a) (not b)) + (or (ite a b c) a (not c)) + (or (not (not a)) (not a)) + (or (not a) a) + } + This proof object has no antecedents. + Note: all axioms are propositional tautologies. + Note also that 'and' and 'or' can take multiple arguments. + You can recover the propositional tautologies by + unfolding the Boolean connectives in the axioms a small + bounded number of steps (=3). + + - OP_PR_DEF_INTRO: Introduces a name for a formula/term. + Suppose e is an expression with free variables x, and def-intro + introduces the name n(x). The possible cases are: + + When e is of Boolean type: + [def-intro]: (and (or n (not e)) (or (not n) e)) + + or: + [def-intro]: (or (not n) e) + when e only occurs positively. + + When e is of the form (ite cond th el): + [def-intro]: (and (or (not cond) (= n th)) (or cond (= n el))) + + Otherwise: + [def-intro]: (= n e) + + - OP_PR_APPLY_DEF: + [apply-def T1]: F ~ n + F is 'equivalent' to n, given that T1 is a proof that + n is a name for F. + + - OP_PR_IFF_OEQ: + T1: (iff p q) + [iff~ T1]: (~ p q) + + - OP_PR_NNF_POS: Proof for a (positive) NNF step. Example: + {e + T1: (not s_1) ~ r_1 + T2: (not s_2) ~ r_2 + T3: s_1 ~ r_1' + T4: s_2 ~ r_2' + [nnf-pos T1 T2 T3 T4]: (~ (iff s_1 s_2) + (and (or r_1 r_2') (or r_1' r_2))) + } + The negation normal form steps NNF_POS and NNF_NEG are used in the following cases: + (a) When creating the NNF of a positive force quantifier. + The quantifier is retained (unless the bound variables are eliminated). + Example + {e + T1: q ~ q_new + [nnf-pos T1]: (~ (forall (x T) q) (forall (x T) q_new)) + } + (b) When recursively creating NNF over Boolean formulas, where the top-level + connective is changed during NNF conversion. The relevant Boolean connectives + for NNF_POS are 'implies', 'iff', 'xor', 'ite'. + NNF_NEG furthermore handles the case where negation is pushed + over Boolean connectives 'and' and 'or'. + + + - OP_PR_NFF_NEG: Proof for a (negative) NNF step. Examples: + {e + T1: (not s_1) ~ r_1 + ... + Tn: (not s_n) ~ r_n + [nnf-neg T1 ... Tn]: (not (and s_1 ... s_n)) ~ (or r_1 ... r_n) + and + T1: (not s_1) ~ r_1 + ... + Tn: (not s_n) ~ r_n + [nnf-neg T1 ... Tn]: (not (or s_1 ... s_n)) ~ (and r_1 ... r_n) + and + T1: (not s_1) ~ r_1 + T2: (not s_2) ~ r_2 + T3: s_1 ~ r_1' + T4: s_2 ~ r_2' + [nnf-neg T1 T2 T3 T4]: (~ (not (iff s_1 s_2)) + (and (or r_1 r_2) (or r_1' r_2'))) + } + - OP_PR_NNF_STAR: A proof for (~ P Q) where Q is in negation normal form. + + This proof object is only used if the parameter PROOF_MODE is 1. + + This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. + + - OP_PR_CNF_STAR: A proof for (~ P Q) where Q is in conjunctive normal form. + This proof object is only used if the parameter PROOF_MODE is 1. + This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. + + - OP_PR_SKOLEMIZE: Proof for: + + {e + [sk]: (~ (not (forall x (p x y))) (not (p (sk y) y))) + [sk]: (~ (exists x (p x y)) (p (sk y) y)) + } + + This proof object has no antecedents. + + - OP_PR_MODUS_PONENS_OEQ: Modus ponens style rule for equi-satisfiability. + {e + T1: p + T2: (~ p q) + [mp~ T1 T2]: q + } + + - OP_PR_TH_LEMMA: Generic proof for theory lemmas. + + The theory lemma function comes with one or more parameters. + The first parameter indicates the name of the theory. + For the theory of arithmetic, additional parameters provide hints for + checking the theory lemma. + The hints for arithmetic are: + + - farkas - followed by rational coefficients. Multiply the coefficients to the + inequalities in the lemma, add the (negated) inequalities and obtain a contradiction. + + - triangle-eq - Indicates a lemma related to the equivalence: + {e + (iff (= t1 t2) (and (<= t1 t2) (<= t2 t1))) + } + + - gcd-test - Indicates an integer linear arithmetic lemma that uses a gcd test. + + + - OP_RA_STORE: Insert a record into a relation. + The function takes [n+1] arguments, where the first argument is the relation and the remaining [n] elements + correspond to the [n] columns of the relation. + + - OP_RA_EMPTY: Creates the empty relation. + + - OP_RA_IS_EMPTY: Tests if the relation is empty. + + - OP_RA_JOIN: Create the relational join. + + - OP_RA_UNION: Create the union or convex hull of two relations. + The function takes two arguments. + + - OP_RA_WIDEN: Widen two relations. + The function takes two arguments. + + - OP_RA_PROJECT: Project the columns (provided as numbers in the parameters). + The function takes one argument. + + - OP_RA_FILTER: Filter (restrict) a relation with respect to a predicate. + The first argument is a relation. + The second argument is a predicate with free de-Brujin indices + corresponding to the columns of the relation. + So the first column in the relation has index 0. + + - OP_RA_NEGATION_FILTER: Intersect the first relation with respect to negation + of the second relation (the function takes two arguments). + Logically, the specification can be described by a function + + target = filter_by_negation(pos, neg, columns) + + where columns are pairs c1, d1, .., cN, dN of columns from pos and neg, such that + target are elements in x in pos, such that there is no y in neg that agrees with + x on the columns c1, d1, .., cN, dN. + + + - OP_RA_RENAME: rename columns in the relation. + The function takes one argument. + The parameters contain the renaming as a cycle. + + - OP_RA_COMPLEMENT: Complement the relation. + + - OP_RA_SELECT: Check if a record is an element of the relation. + The function takes [n+1] arguments, where the first argument is a relation, + and the remaining [n] arguments correspond to a record. + + - OP_RA_CLONE: Create a fresh copy (clone) of a relation. + The function is logically the identity, but + in the context of a register machine allows + for [OP_RA_UNION] + to perform destructive updates to the first argument. + + + - OP_FD_LT: A less than predicate over the finite domain FINITE_DOMAIN_SORT. + + - OP_LABEL: A label (used by the Boogie Verification condition generator). + The label has two parameters, a string and a Boolean polarity. + It takes one argument, a formula. + + - OP_LABEL_LIT: A label literal (used by the Boogie Verification condition generator). + A label literal has a set of string parameters. It takes no arguments. + + - OP_DT_CONSTRUCTOR: datatype constructor. + + - OP_DT_RECOGNISER: datatype recognizer. + + - OP_DT_ACCESSOR: datatype accessor. + + - OP_UNINTERPRETED: kind used for uninterpreted symbols. +*) +(** + {!param_kind} + + The different kinds of parameters that can be associated with parameter sets. + (see {!mk_params}). + + - PK_UINT integer parameters. + - PK_BOOL boolean parameters. + - PK_DOUBLE double parameters. + - PK_SYMBOL symbol parameters. + - PK_STRING string parameters. + - PK_OTHER all internal parameter kinds which are not exposed in the API. + - PK_INVALID invalid parameter. +*) +(** + {!search_failure} + The different kinds of search failure types. + + - NO_FAILURE: The last search was successful + - UNKNOWN: Undocumented failure reason + - TIMEOUT: Timeout + - MEMOUT_WATERMAK: Search hit a memory high-watermak limit + - CANCELED: External cancel flag was set + - NUM_CONFLICTS: Maximum number of conflicts was reached + - THEORY: Theory is incomplete + - QUANTIFIERS: Logical context contains universal quantifiers +*) +(** + {!ast_print_mode} + Z3 pretty printing modes (See {!set_ast_print_mode}). + + - PRINT_SMTLIB_FULL: Print AST nodes in SMTLIB verbose format. + - PRINT_LOW_LEVEL: Print AST nodes using a low-level format. + - PRINT_SMTLIB_COMPLIANT: Print AST nodes in SMTLIB 1.x compliant format. + - PRINT_SMTLIB2_COMPLIANT: Print AST nodes in SMTLIB 2.x compliant format. +*) +(** + {!error_code} + Z3 error codes + + - OK: No error. + - SORT_ERROR: User tried to build an invalid (type incorrect) AST. + - IOB: Index out of bounds. + - INVALID_ARG: Invalid argument was provided. + - PARSER_ERROR: An error occurred when parsing a string or file. + - NO_PARSER: Parser output is not available, that is, user didn't invoke {!parse_smtlib_string} or {!parse_smtlib_file}. + - INVALID_PATTERN: Invalid pattern was used to build a quantifier. + - MEMOUT_FAIL: A memory allocation failure was encountered. + - FILE_ACCESS_ERRROR: A file could not be accessed. + - INVALID_USAGE: API call is invalid in the current state. + - INTERNAL_FATAL: An error internal to Z3 occurred. + - DEC_REF_ERROR: Trying to decrement the reference counter of an AST that was deleted or the reference counter was not initialized. + - EXCEPTION: Internal Z3 exception. Additional details can be retrieved using {!get_error_msg}. +*) + +(** Exceptions raised by Z3. It is safe to continue interacting with Z3 after + catching [Error] exceptions. + + - {b See also}: {!get_error_msg} +*) +exception Error of context * error_code + +(** + {!goal_prec} + A Goal is essentially a set of formulas. Z3 provide APIs for building strategies/tactics for solving and transforming Goals. Some of these transformations apply under/over approximations. + + - GOAL_PRECISE: Approximations/Relaxations were not applied on the goal (sat and unsat answers were preserved). + - GOAL_UNDER: Goal is the product of a under-approximation (sat answers are preserved). + - GOAL_OVER: Goal is the product of an over-approximation (unsat answers are preserved). + - GOAL_UNDER_OVER: Goal is garbage (it is the product of over- and under-approximations, sat and unsat answers are not preserved). +*) +(** + {2 {L Create context}} +*) +(** + Summary: Create a context using the given configuration. + + After a context is created, the configuration cannot be changed, + although some parameters can be changed using {!update_param_value}. + All main interaction with Z3 happens in the context of a [context]. + + + + +*) +external mk_context: (string * string) list -> context = "caml_z3_mk_context" + +(** + Summary: Update a mutable configuration parameter. + + The list of all configuration parameters can be obtained using the Z3 executable: + + {v + z3.exe -ini? + v} + + Only a few configuration parameters are mutable once the context is created. + The error handler is invoked when trying to modify an immutable parameter. + + + - {b See also}: {!mk_context } +*) +external update_param_value : context -> string -> string -> unit + = "camlidl_z3_Z3_update_param_value" + +(** + Summary: Get a configuration parameter. + + Returns [None] + if the parameter value does not exist. + + + + - {b See also}: {!mk_context } +*) +external get_param_value : context -> string -> string option + = "camlidl_z3_Z3_get_param_value" + +(** + Summary: Interrupt the execution of a Z3 procedure. + This procedure can be used to interrupt: solvers, simplifiers and tactics. +*) +external interrupt : context -> unit + = "camlidl_z3_Z3_interrupt" + +(** + {2 {L Parameters}} +*) +(** + Summary: Create a Z3 (empty) parameter set. + Starting at Z3 4.0, parameter sets are used to configure many components such as: + simplifiers, tactics, solvers, etc. + + + +*) +external mk_params : context -> params + = "camlidl_z3_Z3_mk_params" + +(** + Summary: Add a Boolean parameter [k] with value [v] to the parameter set [p]. +*) +external params_set_bool : context -> params -> symbol -> bool -> unit + = "camlidl_z3_Z3_params_set_bool" + +(** + Summary: Add a unsigned int parameter [k] with value [v] to the parameter set [p]. +*) +external params_set_uint : context -> params -> symbol -> int -> unit + = "camlidl_z3_Z3_params_set_uint" + +(** + Summary: Add a double parameter [k] with value [v] to the parameter set [p]. +*) +external params_set_double : context -> params -> symbol -> float -> unit + = "camlidl_z3_Z3_params_set_double" + +(** + Summary: Add a symbol parameter [k] with value [v] to the parameter set [p]. +*) +external params_set_symbol : context -> params -> symbol -> symbol -> unit + = "camlidl_z3_Z3_params_set_symbol" + +(** + Summary: Convert a parameter set into a string. This function is mainly used for printing the + contents of a parameter set. +*) +external params_to_string : context -> params -> string + = "camlidl_z3_Z3_params_to_string" + +(** + Summary: Validate the parameter set [p] against the parameter description set [d]. + + The procedure invokes the error handler if [p] is invalid. +*) +external params_validate : context -> params -> param_descrs -> unit + = "camlidl_z3_Z3_params_validate" + +(** + {2 {L Parameter Descriptions}} +*) +(** + Summary: Return the kind associated with the given parameter name [n]. +*) +external param_descrs_get_kind : context -> param_descrs -> symbol -> param_kind + = "camlidl_z3_Z3_param_descrs_get_kind" + +(** + Summary: Return the number of parameters in the given parameter description set. +*) +external param_descrs_size : context -> param_descrs -> int + = "camlidl_z3_Z3_param_descrs_size" + +(** + Summary: Return the number of parameters in the given parameter description set. + + - {b Precondition}: i < param_descrs_size c p +*) +external param_descrs_get_name : context -> param_descrs -> int -> symbol + = "camlidl_z3_Z3_param_descrs_get_name" + +(** + {2 {L Symbols}} +*) + +(** + Refined view of a {!symbol}. + + - {b See also}: {!mk_symbol} + - {b See also}: {!symbol_refine} +*) +type symbol_refined = + | Symbol_int of int + | Symbol_string of string + + +(** + Summary: \[ [ mk_symbol c sr ] \] constructs the symbol described by [sr]. + + - {b See also}: {!symbol_refine} +*) +val mk_symbol: context -> symbol_refined -> symbol + +(** + {4 {L Redundant low-level API}} +*) +(** + Summary: Create a Z3 symbol using an integer. + + Symbols are used to name several term and type constructors. + + NB. Not all integers can be passed to this function. + The legal range of unsigned int integers is 0 to 2^30-1. + + - {b See also}: {!mk_string_symbol} +*) +external mk_int_symbol : context -> int -> symbol + = "camlidl_z3_Z3_mk_int_symbol" + +(** + Summary: Create a Z3 symbol using a C string. + + Symbols are used to name several term and type constructors. + + - {b See also}: {!mk_int_symbol} +*) +external mk_string_symbol : context -> string -> symbol + = "camlidl_z3_Z3_mk_string_symbol" + +(** + {2 {L Sorts}} +*) + +(** + A datatype constructor descriptor. +*) +type datatype_constructor_desc = { + constructor_desc : symbol; (** name of the constructor function *) + recognizer_desc : symbol; (** name of the recognizer function *) + accessor_descs : (symbol * sort) array; (** names and sorts of the fields *) +} + +(** + A datatype is described by a name and constructor descriptors. +*) +type datatype_desc = symbol * datatype_constructor_desc array + +(** + A datatype constructor representation. +*) +type datatype_constructor = { + constructor : func_decl; (** constructor function *) + recognizer : func_decl; (** recognizer function *) + accessors : func_decl array; (** field accessor functions *) +} + +(** + A datatype is represented by a sort and constructors. +*) +type datatype = sort * datatype_constructor array + +(** + Refined view of a {!sort}. + + - {b See also}: {!mk_sort} + - {b See also}: {!sort_refine} +*) +type sort_refined = + | Sort_uninterpreted of symbol + | Sort_bool + | Sort_int + | Sort_bv of int + | Sort_finite_domain of symbol * int64 + | Sort_real + | Sort_array of sort * sort + | Sort_datatype of datatype_constructor array + | Sort_relation of sort array + | Sort_unknown + + +(** + Summary: \[ [ mk_sort c sr ] \] constructs the sort described by [sr]. + + - {b Precondition}: [sr] is not of form [Sort_relation] or [Sort_unknown], which cannot be directly constructed + - {b See also}: {!mk_datatypes} + - {b See also}: {!sort_refine} +*) +val mk_sort: context -> sort_refined -> sort + +(** + \[ [mk_datatypes ctx sorts_to_descriptors] \] creates mutually recursive datatypes described by + [sorts_to_descriptors], which is a function from the sorts of the datatypes to be created to + descriptors of the datatypes' constructors. + + - {b See also}: {!Test_mlapi.forest_example} +*) +val mk_datatypes: context -> (sort array -> (datatype_desc array) option) -> datatype array + +(** + {4 {L Redundant low-level API}} +*) +(** + Summary: Create a free (uninterpreted) type using the given name (symbol). + + Two free types are considered the same iff the have the same name. +*) +external mk_uninterpreted_sort : context -> symbol -> sort + = "camlidl_z3_Z3_mk_uninterpreted_sort" + +(** + Summary: Create the Boolean type. + + This type is used to create propositional variables and predicates. +*) +external mk_bool_sort : context -> sort + = "camlidl_z3_Z3_mk_bool_sort" + +(** + Summary: Create the integer type. + + This type is not the int type found in programming languages. + A machine integer can be represented using bit-vectors. The function + {!mk_bv_sort} creates a bit-vector type. + + - {b See also}: {!mk_bv_sort} +*) +external mk_int_sort : context -> sort + = "camlidl_z3_Z3_mk_int_sort" + +(** + Summary: Create the real type. + + This type is not a floating point number. + Z3 does not have support for floating point numbers yet. +*) +external mk_real_sort : context -> sort + = "camlidl_z3_Z3_mk_real_sort" + +(** + Summary: Create a bit-vector type of the given size. + + This type can also be seen as a machine integer. + + - {b Remarks}: The size of the bitvector type must be greater than zero. +*) +external mk_bv_sort : context -> int -> sort + = "camlidl_z3_Z3_mk_bv_sort" + +(** + Summary: Create a named finite domain sort. + + To create constants that belong to the finite domain, + use the APIs for creating numerals and pass a numeric + constant together with the sort returned by this call. + + - {b See also}: {!get_finite_domain_sort_size.} +*) +external mk_finite_domain_sort : context -> symbol -> int64 -> sort + = "camlidl_z3_Z3_mk_finite_domain_sort" + +(** + Summary: Create an array type. + + We usually represent the array type as: {e [domain -> range] }. + Arrays are usually used to model the heap/memory in software verification. + + - {b See also}: {!mk_select} + - {b See also}: {!mk_store} +*) +external mk_array_sort : context -> sort -> sort -> sort + = "camlidl_z3_Z3_mk_array_sort" + +(** + Summary: Create a tuple type. + + [mk_tuple_sort c name field_names field_sorts] creates a tuple with a constructor named [name], + a [n] fields, where [n] is the size of the arrays [field_names] and [field_sorts]. + + + + + + @param c logical context + @param mk_tuple_name name of the constructor function associated with the tuple type. + @param num_fields number of fields in the tuple type. + @param field_names name of the projection functions. + @param field_sorts type of the tuple fields. + @param mk_tuple_decl output parameter that will contain the constructor declaration. + @param proj_decl output parameter that will contain the projection function declarations. This field must be a buffer of size [num_fields] allocated by the user. +*) +external mk_tuple_sort : context -> symbol -> symbol array -> sort array -> sort * func_decl * func_decl array + = "camlidl_z3_Z3_mk_tuple_sort" + +(** + Summary: Create a enumeration sort. + + [mk_enumeration_sort c enums] creates an enumeration sort with enumeration names [enums], + it also returns [n] predicates, where [n] is the number of [enums] corresponding + to testing whether an element is one of the enumerants. + + + + + + @param c logical context + @param name name of the enumeration sort. + @param n number of elemenets in enumeration sort. + @param enum_names names of the enumerated elements. + @param enum_consts constants corresponding to the enumerated elements. + @param enum_testers predicates testing if terms of the enumeration sort correspond to an enumeration. + + For example, if this function is called with three symbols A, B, C and the name S, then + [s] is a sort whose name is S, and the function returns three terms corresponding to A, B, C in + [enum_consts]. The array [enum_testers] has three predicates of type {e (s -> Bool) }. + The first predicate (corresponding to A) is true when applied to A, and false otherwise. + Similarly for the other predicates. +*) +external mk_enumeration_sort : context -> symbol -> symbol array -> sort * func_decl array * func_decl array + = "camlidl_z3_Z3_mk_enumeration_sort" + +(** + Summary: Create a list sort + + [mk_list_sort c name elem_sort] creates a list sort of [name], over elements of sort [elem_sort]. + + + + + + @param c logical context + @param name name of the list sort. + @param elem_sort sort of list elements. + @param nil_decl declaration for the empty list. + @param is_nil_decl test for the empty list. + @param cons_decl declaration for a cons cell. + @param is_cons_decl cons cell test. + @param head_decl list head. + @param tail_decl list tail. +*) +external mk_list_sort : context -> symbol -> sort -> sort * func_decl * func_decl * func_decl * func_decl * func_decl * func_decl + = "camlidl_z3_Z3_mk_list_sort" + +(* +(** + Summary: Create a constructor. + + @param c logical context. + @param name constructor name. + @param recognizer name of recognizer function. + @param num_fields number of fields in constructor. + @param field_names names of the constructor fields. + @param sorts field sorts, [None] + if the field sort refers to a recursive sort. + @param sort_refs reference to datatype sort that is an argument to the constructor; if the corresponding + sort reference is [None], + then the value in sort_refs should be an index referring to + one of the recursive datatypes that is declared. +*) +external mk_constructor : context -> symbol -> symbol -> symbol array -> sort option array -> int array -> constructor + = "camlidl_z3_Z3_mk_constructor_bytecode" "camlidl_z3_Z3_mk_constructor" + +(** + Summary: Reclaim memory allocated to constructor. + + @param c logical context. + @param constr constructor. +*) +external del_constructor : context -> constructor -> unit + = "camlidl_z3_Z3_del_constructor" + +(** + Summary: Create datatype, such as lists, trees, records, enumerations or unions of records. + The datatype may be recursive. Return the datatype sort. + + @param c logical context. + @param name name of datatype. + @param num_constructors number of constructors passed in. + @param constructors array of constructor containers. +*) +external mk_datatype : context -> symbol -> constructor array -> sort * constructor array + = "camlidl_z3_Z3_mk_datatype" + +(** + Summary: Create list of constructors. + + @param c logical context. + @param num_constructors number of constructors in list. + @param constructors list of constructors. +*) +external mk_constructor_list : context -> constructor array -> constructor_list + = "camlidl_z3_Z3_mk_constructor_list" + +(** + Summary: Reclaim memory allocated for constructor list. + + Each constructor inside the constructor list must be independently reclaimed using {!del_constructor}. + + @param c logical context. + @param clist constructor list container. + +*) +external del_constructor_list : context -> constructor_list -> unit + = "camlidl_z3_Z3_del_constructor_list" + +(** + Summary: Create mutually recursive datatypes. + + @param c logical context. + @param num_sorts number of datatype sorts. + @param sort_names names of datatype sorts. + @param sorts array of datattype sorts. + @param constructor_lists list of constructors, one list per sort. +*) +external mk_datatypes : context -> symbol array -> constructor_list array -> sort array * constructor_list array + = "camlidl_z3_Z3_mk_datatypes" + +(** + Summary: Query constructor for declared functions. + + @param c logical context. + @param constr constructor container. The container must have been passed in to a {!mk_datatype} call. + @param num_fields number of accessor fields in the constructor. + @param constructor constructor function declaration. + @param tester constructor test function declaration. + @param accessors array of accessor function declarations. +*) +external query_constructor : context -> constructor -> int -> func_decl * func_decl * func_decl array + = "camlidl_z3_Z3_query_constructor" + +*) +(** + {2 {L Constants and Applications}} +*) +(** + Summary: Declare a constant or function. + + [mk_func_decl c n d r] creates a function with name [n], domain [d], and range [r]. + The arity of the function is the size of the array [d]. + + @param c logical context. + @param s name of the constant or function. + @param domain_size number of arguments. It is 0 when declaring a constant. + @param domain array containing the sort of each argument. The array must contain domain_size elements. It is 0 when declaring a constant. + @param range sort of the constant or the return sort of the function. + + After declaring a constant or function, the function + {!mk_app} can be used to create a constant or function + application. + + - {b See also}: {!mk_app} +*) +external mk_func_decl : context -> symbol -> sort array -> sort -> func_decl + = "camlidl_z3_Z3_mk_func_decl" + +(** + Summary: Create a constant or function application. + + - {b See also}: {!mk_func_decl} +*) +external mk_app : context -> func_decl -> ast array -> ast + = "camlidl_z3_Z3_mk_app" + +(** + Summary: Declare and create a constant. + + + + + + + + [mk_const c s t] is a shorthand for [mk_app c (mk_func_decl c s [||] t) [||]] + + - {b See also}: {!mk_func_decl} + - {b See also}: {!mk_app} +*) +external mk_const : context -> symbol -> sort -> ast + = "camlidl_z3_Z3_mk_const" + +(** + Summary: Declare a fresh constant or function. + + Z3 will generate an unique name for this function declaration. + + + + + - {b See also}: {!mk_func_decl} +*) +external mk_fresh_func_decl : context -> string -> sort array -> sort -> func_decl + = "camlidl_z3_Z3_mk_fresh_func_decl" + +(** + Summary: Declare and create a fresh constant. + + + + + [mk_fresh_const c p t] is a shorthand for [mk_app c (mk_fresh_func_decl c p [||] t) [||]]. + + + + - {b See also}: {!mk_func_decl} + - {b See also}: {!mk_app} +*) +external mk_fresh_const : context -> string -> sort -> ast + = "camlidl_z3_Z3_mk_fresh_const" + +(** + {2 {L Propositional Logic and Equality}} +*) +(** + Summary: Create an AST node representing [true]. +*) +external mk_true : context -> ast + = "camlidl_z3_Z3_mk_true" + +(** + Summary: Create an AST node representing [false]. +*) +external mk_false : context -> ast + = "camlidl_z3_Z3_mk_false" + +(** + Summary: \[ [ mk_eq c l r ] \] + Create an AST node representing {e l = r }. + + The nodes [l] and [r] must have the same type. +*) +external mk_eq : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_eq" + +(** + + Summary: \[ [mk_distinct c [| t_1; ...; t_n |]] \] Create an AST + node represeting a distinct construct. It is used for declaring + the arguments t_i pairwise distinct. + + The [distinct] construct is used for declaring the arguments pairwise distinct. + That is, {e Forall 0 <= i < j < num_args. not args[i] = args[j] }. + + All arguments must have the same sort. + + - {b Remarks}: The number of arguments of a distinct construct must be greater than one. +*) +external mk_distinct : context -> ast array -> ast + = "camlidl_z3_Z3_mk_distinct" + +(** + Summary: \[ [ mk_not c a ] \] + Create an AST node representing {e not(a) }. + + The node [a] must have Boolean sort. +*) +external mk_not : context -> ast -> ast + = "camlidl_z3_Z3_mk_not" + +(** + Summary: \[ [ mk_ite c t1 t2 t2 ] \] + Create an AST node representing an if-then-else: {e ite(t1, t2, + t3) }. + + The node [t1] must have Boolean sort, [t2] and [t3] must have the same sort. + The sort of the new node is equal to the sort of [t2] and [t3]. +*) +external mk_ite : context -> ast -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_ite" + +(** + Summary: \[ [ mk_iff c t1 t2 ] \] + Create an AST node representing {e t1 iff t2 }. + + The nodes [t1] and [t2] must have Boolean sort. +*) +external mk_iff : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_iff" + +(** + Summary: \[ [ mk_implies c t1 t2 ] \] + Create an AST node representing {e t1 implies t2 }. + + The nodes [t1] and [t2] must have Boolean sort. +*) +external mk_implies : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_implies" + +(** + Summary: \[ [ mk_xor c t1 t2 ] \] + Create an AST node representing {e t1 xor t2 }. + + The nodes [t1] and [t2] must have Boolean sort. +*) +external mk_xor : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_xor" + +(** + + Summary: \[ [mk_and c [| t_1; ...; t_n |]] \] Create the conjunction: {e t_1 and ... and t_n}. + + + All arguments must have Boolean sort. + + - {b Remarks}: The number of arguments must be greater than zero. +*) +external mk_and : context -> ast array -> ast + = "camlidl_z3_Z3_mk_and" + +(** + + Summary: \[ [mk_or c [| t_1; ...; t_n |]] \] Create the disjunction: {e t_1 or ... or t_n}. + + + All arguments must have Boolean sort. + + - {b Remarks}: The number of arguments must be greater than zero. +*) +external mk_or : context -> ast array -> ast + = "camlidl_z3_Z3_mk_or" + +(** + {2 {L Arithmetic: Integers and Reals}} +*) +(** + + Summary: \[ [mk_add c [| t_1; ...; t_n |]] \] Create the term: {e t_1 + ... + t_n}. + + + All arguments must have int or real sort. + + - {b Remarks}: The number of arguments must be greater than zero. +*) +external mk_add : context -> ast array -> ast + = "camlidl_z3_Z3_mk_add" + +(** + + Summary: \[ [mk_mul c [| t_1; ...; t_n |]] \] Create the term: {e t_1 * ... * t_n}. + + + All arguments must have int or real sort. + + - {b Remarks}: Z3 has limited support for non-linear arithmetic. + - {b Remarks}: The number of arguments must be greater than zero. +*) +external mk_mul : context -> ast array -> ast + = "camlidl_z3_Z3_mk_mul" + +(** + + Summary: \[ [mk_sub c [| t_1; ...; t_n |]] \] Create the term: {e t_1 - ... - t_n}. + + + All arguments must have int or real sort. + + - {b Remarks}: The number of arguments must be greater than zero. +*) +external mk_sub : context -> ast array -> ast + = "camlidl_z3_Z3_mk_sub" + +(** + + Summary: \[ [mk_unary_minus c arg] \] Create the term: {e - arg}. + + The arguments must have int or real type. +*) +external mk_unary_minus : context -> ast -> ast + = "camlidl_z3_Z3_mk_unary_minus" + +(** + + Summary: \[ [mk_div c t_1 t_2] \] Create the term: {e t_1 div t_2}. + + The arguments must either both have int type or both have real type. + If the arguments have int type, then the result type is an int type, otherwise the + the result type is real. + +*) +external mk_div : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_div" + +(** + + Summary: \[ [mk_mod c t_1 t_2] \] Create the term: {e t_1 mod t_2}. + + The arguments must have int type. + +*) +external mk_mod : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_mod" + +(** + + Summary: \[ [mk_rem c t_1 t_2] \] Create the term: {e t_1 rem t_2}. + + The arguments must have int type. + +*) +external mk_rem : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_rem" + +(** + + + The arguments must have int or real type. +*) +external mk_power : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_power" + +(** + Summary: \[ [ mk_lt c t1 t2 ] \] + Create less than. + + The nodes [t1] and [t2] must have the same sort, and must be int or real. +*) +external mk_lt : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_lt" + +(** + Summary: \[ [ mk_le c t1 t2 ] \] + Create less than or equal to. + + The nodes [t1] and [t2] must have the same sort, and must be int or real. +*) +external mk_le : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_le" + +(** + Summary: \[ [ mk_gt c t1 t2 ] \] + Create greater than. + + The nodes [t1] and [t2] must have the same sort, and must be int or real. +*) +external mk_gt : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_gt" + +(** + Summary: \[ [ mk_ge c t1 t2 ] \] + Create greater than or equal to. + + The nodes [t1] and [t2] must have the same sort, and must be int or real. +*) +external mk_ge : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_ge" + +(** + Summary: \[ [ mk_int2real c t1 ] \] + Coerce an integer to a real. + + There is also a converse operation exposed. + It follows the semantics prescribed by the SMT-LIB standard. + + You can take the floor of a real by + creating an auxiliary integer constant [k] and + and asserting {e mk_int2real(k) <= t1 < mk_int2real(k)+1 }. + + The node [t1] must have sort integer. + + - {b See also}: {!mk_real2int} + - {b See also}: {!mk_is_int} +*) +external mk_int2real : context -> ast -> ast + = "camlidl_z3_Z3_mk_int2real" + +(** + Summary: \[ [ mk_real2int c t1 ] \] + Coerce a real to an integer. + + The semantics of this function follows the SMT-LIB standard + for the function to_int + + - {b See also}: {!mk_int2real} + - {b See also}: {!mk_is_int} +*) +external mk_real2int : context -> ast -> ast + = "camlidl_z3_Z3_mk_real2int" + +(** + Summary: \[ [ mk_is_int c t1 ] \] + Check if a real number is an integer. + + - {b See also}: {!mk_int2real} + - {b See also}: {!mk_real2int} +*) +external mk_is_int : context -> ast -> ast + = "camlidl_z3_Z3_mk_is_int" + +(** + {2 {L Bit-vectors}} +*) +(** + Summary: \[ [ mk_bvnot c t1 ] \] + Bitwise negation. + + The node [t1] must have a bit-vector sort. +*) +external mk_bvnot : context -> ast -> ast + = "camlidl_z3_Z3_mk_bvnot" + +(** + Summary: \[ [ mk_bvredand c t1 ] \] + Take conjunction of bits in vector, return vector of length 1. + + The node [t1] must have a bit-vector sort. +*) +external mk_bvredand : context -> ast -> ast + = "camlidl_z3_Z3_mk_bvredand" + +(** + Summary: \[ [ mk_bvredor c t1 ] \] + Take disjunction of bits in vector, return vector of length 1. + + The node [t1] must have a bit-vector sort. +*) +external mk_bvredor : context -> ast -> ast + = "camlidl_z3_Z3_mk_bvredor" + +(** + Summary: \[ [ mk_bvand c t1 t2 ] \] + Bitwise and. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvand : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvand" + +(** + Summary: \[ [ mk_bvor c t1 t2 ] \] + Bitwise or. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvor : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvor" + +(** + Summary: \[ [ mk_bvxor c t1 t2 ] \] + Bitwise exclusive-or. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvxor : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvxor" + +(** + Summary: \[ [ mk_bvnand c t1 t2 ] \] + Bitwise nand. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvnand : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvnand" + +(** + Summary: \[ [ mk_bvnor c t1 t2 ] \] + Bitwise nor. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvnor : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvnor" + +(** + Summary: \[ [ mk_bvxnor c t1 t2 ] \] + Bitwise xnor. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvxnor : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvxnor" + +(** + Summary: \[ [ mk_bvneg c t1 ] \] + Standard two's complement unary minus. + + The node [t1] must have bit-vector sort. +*) +external mk_bvneg : context -> ast -> ast + = "camlidl_z3_Z3_mk_bvneg" + +(** + Summary: \[ [ mk_bvadd c t1 t2 ] \] + Standard two's complement addition. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvadd : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvadd" + +(** + Summary: \[ [ mk_bvsub c t1 t2 ] \] + Standard two's complement subtraction. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsub : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsub" + +(** + Summary: \[ [ mk_bvmul c t1 t2 ] \] + Standard two's complement multiplication. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvmul : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvmul" + +(** + Summary: \[ [ mk_bvudiv c t1 t2 ] \] + Unsigned division. + + It is defined as the [floor] of {e t1/t2 } if [t2] is + different from zero. If {e t2 } is zero, then the result + is undefined. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvudiv : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvudiv" + +(** + Summary: \[ [ mk_bvsdiv c t1 t2 ] \] + Two's complement signed division. + + It is defined in the following way: + + - The [floor] of {e t1/t2 } if [t2] is different from zero, and {e t1*t2 >= 0 }. + + - The [ceiling] of {e t1/t2 } if [t2] is different from zero, and {e t1*t2 < 0 }. + + If {e t2 } is zero, then the result is undefined. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsdiv : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsdiv" + +(** + Summary: \[ [ mk_bvurem c t1 t2 ] \] + Unsigned remainder. + + It is defined as {e t1 - (t1 /u t2) * t2 }, where {e /u } represents unsigned int division. + + If {e t2 } is zero, then the result is undefined. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvurem : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvurem" + +(** + Summary: \[ [ mk_bvsrem c t1 t2 ] \] + Two's complement signed remainder (sign follows dividend). + + It is defined as {e t1 - (t1 /s t2) * t2 }, where {e /s } represents signed division. + The most significant bit (sign) of the result is equal to the most significant bit of [t1]. + + If {e t2 } is zero, then the result is undefined. + + The nodes [t1] and [t2] must have the same bit-vector sort. + + - {b See also}: {!mk_bvsmod} +*) +external mk_bvsrem : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsrem" + +(** + Summary: \[ [ mk_bvsmod c t1 t2 ] \] + Two's complement signed remainder (sign follows divisor). + + If {e t2 } is zero, then the result is undefined. + + The nodes [t1] and [t2] must have the same bit-vector sort. + + - {b See also}: {!mk_bvsrem} +*) +external mk_bvsmod : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsmod" + +(** + Summary: \[ [ mk_bvult c t1 t2 ] \] + Unsigned less than. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvult : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvult" + +(** + Summary: \[ [ mk_bvslt c t1 t2 ] \] + Two's complement signed less than. + + It abbreviates: + {v + (or (and (= (extract[|m-1|:|m-1|] t1) bit1) + (= (extract[|m-1|:|m-1|] t2) bit0)) + (and (= (extract[|m-1|:|m-1|] t1) (extract[|m-1|:|m-1|] t2)) + (bvult t1 t2))) + v} + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvslt : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvslt" + +(** + Summary: \[ [ mk_bvule c t1 t2 ] \] + Unsigned less than or equal to. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvule : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvule" + +(** + Summary: \[ [ mk_bvsle c t1 t2 ] \] + Two's complement signed less than or equal to. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsle : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsle" + +(** + Summary: \[ [ mk_bvuge c t1 t2 ] \] + Unsigned greater than or equal to. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvuge : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvuge" + +(** + Summary: \[ [ mk_bvsge c t1 t2 ] \] + Two's complement signed greater than or equal to. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsge : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsge" + +(** + Summary: \[ [ mk_bvugt c t1 t2 ] \] + Unsigned greater than. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvugt : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvugt" + +(** + Summary: \[ [ mk_bvsgt c t1 t2 ] \] + Two's complement signed greater than. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsgt : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsgt" + +(** + Summary: \[ [ mk_concat c t1 t2 ] \] + Concatenate the given bit-vectors. + + The nodes [t1] and [t2] must have (possibly different) bit-vector sorts + + The result is a bit-vector of size {e n1+n2 }, where [n1] ([n2)] is the size + of [t1] ([t2)]. +*) +external mk_concat : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_concat" + +(** + Summary: \[ [ mk_extract c high low t1 ] \] + Extract the bits [high] down to [low] from a bitvector of + size [m] to yield a new bitvector of size [n], where {e n = + high - low + 1 }. + + The node [t1] must have a bit-vector sort. +*) +external mk_extract : context -> int -> int -> ast -> ast + = "camlidl_z3_Z3_mk_extract" + +(** + Summary: \[ [ mk_sign_ext c i t1 ] \] + Sign-extend of the given bit-vector to the (signed) equivalent bitvector of + size {e m+i }, where [m] is the size of the given + bit-vector. + + The node [t1] must have a bit-vector sort. +*) +external mk_sign_ext : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_sign_ext" + +(** + Summary: \[ [ mk_zero_ext c i t1 ] \] + Extend the given bit-vector with zeros to the (unsigned int) equivalent + bitvector of size {e m+i }, where [m] is the size of the + given bit-vector. + + The node [t1] must have a bit-vector sort. +*) +external mk_zero_ext : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_zero_ext" + +(** + Summary: \[ [ mk_repeat c i t1 ] \] + Repeat the given bit-vector up length {e i }. + + The node [t1] must have a bit-vector sort. +*) +external mk_repeat : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_repeat" + +(** + Summary: \[ [ mk_bvshl c t1 t2 ] \] + Shift left. + + It is equivalent to multiplication by {e 2^x } where [x] is the value of the + third argument. + + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the + programming language or assembly architecture you are modeling. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvshl : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvshl" + +(** + Summary: \[ [ mk_bvlshr c t1 t2 ] \] + Logical shift right. + + It is equivalent to unsigned int division by {e 2^x } where [x] is the + value of the third argument. + + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the + programming language or assembly architecture you are modeling. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvlshr : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvlshr" + +(** + Summary: \[ [ mk_bvashr c t1 t2 ] \] + Arithmetic shift right. + + It is like logical shift right except that the most significant + bits of the result always copy the most significant bit of the + second argument. + + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the + programming language or assembly architecture you are modeling. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvashr : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvashr" + +(** + Summary: \[ [ mk_rotate_left c i t1 ] \] + Rotate bits of [t1] to the left [i] times. + + The node [t1] must have a bit-vector sort. +*) +external mk_rotate_left : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_rotate_left" + +(** + Summary: \[ [ mk_rotate_right c i t1 ] \] + Rotate bits of [t1] to the right [i] times. + + The node [t1] must have a bit-vector sort. +*) +external mk_rotate_right : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_rotate_right" + +(** + Summary: \[ [ mk_ext_rotate_left c t1 t2 ] \] + Rotate bits of [t1] to the left [t2] times. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_ext_rotate_left : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_ext_rotate_left" + +(** + Summary: \[ [ mk_ext_rotate_right c t1 t2 ] \] + Rotate bits of [t1] to the right [t2] times. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_ext_rotate_right : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_ext_rotate_right" + +(** + Summary: \[ [ mk_int2bv c n t1 ] \] + Create an [n] bit bit-vector from the integer argument [t1]. + + NB. This function is essentially treated as uninterpreted. + So you cannot expect Z3 to precisely reflect the semantics of this function + when solving constraints with this function. + + The node [t1] must have integer sort. +*) +external mk_int2bv : context -> int -> ast -> ast + = "camlidl_z3_Z3_mk_int2bv" + +(** + Summary: \[ [ mk_bv2int c t1 is_signed ] \] + Create an integer from the bit-vector argument [t1]. + If [is_signed] is false, then the bit-vector [t1] is treated as unsigned int. + So the result is non-negative + and in the range {e [0..2^N-1] }, where N are the number of bits in [t1]. + If [is_signed] is true, [t1] is treated as a signed bit-vector. + + NB. This function is essentially treated as uninterpreted. + So you cannot expect Z3 to precisely reflect the semantics of this function + when solving constraints with this function. + + The node [t1] must have a bit-vector sort. +*) +external mk_bv2int : context -> ast -> bool -> ast + = "camlidl_z3_Z3_mk_bv2int" + +(** + Summary: \[ [ mk_bvadd_no_overflow c t1 t2 is_signed ] \] + Create a predicate that checks that the bit-wise addition + of [t1] and [t2] does not overflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvadd_no_overflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3_Z3_mk_bvadd_no_overflow" + +(** + Summary: \[ [ mk_bvadd_no_underflow c t1 t2 ] \] + Create a predicate that checks that the bit-wise signed addition + of [t1] and [t2] does not underflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvadd_no_underflow : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvadd_no_underflow" + +(** + Summary: \[ [ mk_bvsub_no_overflow c t1 t2 ] \] + Create a predicate that checks that the bit-wise signed subtraction + of [t1] and [t2] does not overflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsub_no_overflow : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsub_no_overflow" + +(** + Summary: \[ [ mk_bvsub_no_underflow c t1 t2 is_signed ] \] + Create a predicate that checks that the bit-wise subtraction + of [t1] and [t2] does not underflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsub_no_underflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3_Z3_mk_bvsub_no_underflow" + +(** + Summary: \[ [ mk_bvsdiv_no_overflow c t1 t2 ] \] + Create a predicate that checks that the bit-wise signed division + of [t1] and [t2] does not overflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsdiv_no_overflow : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvsdiv_no_overflow" + +(** + Summary: \[ [ mk_bvneg_no_overflow c t1 ] \] + Check that bit-wise negation does not overflow when + [t1] is interpreted as a signed bit-vector. + + The node [t1] must have bit-vector sort. +*) +external mk_bvneg_no_overflow : context -> ast -> ast + = "camlidl_z3_Z3_mk_bvneg_no_overflow" + +(** + Summary: \[ [ mk_bvmul_no_overflow c t1 t2 is_signed ] \] + Create a predicate that checks that the bit-wise multiplication + of [t1] and [t2] does not overflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvmul_no_overflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3_Z3_mk_bvmul_no_overflow" + +(** + Summary: \[ [ mk_bvmul_no_underflow c t1 t2 ] \] + Create a predicate that checks that the bit-wise signed multiplication + of [t1] and [t2] does not underflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvmul_no_underflow : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_bvmul_no_underflow" + +(** + {2 {L Arrays}} +*) +(** + Summary: \[ [ mk_select c a i ] \] + Array read. + The argument [a] is the array and [i] is the index of the array that gets read. + + The node [a] must have an array sort {e [domain -> range] }, + and [i] must have the sort [domain]. + The sort of the result is [range]. + + - {b See also}: {!mk_array_sort} + - {b See also}: {!mk_store} +*) +external mk_select : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_select" + +(** + Summary: \[ [ mk_store c a i v ] \] + Array update. + + The node [a] must have an array sort {e [domain -> range] }, [i] must have sort [domain], + [v] must have sort range. The sort of the result is {e [domain -> range] }. + The semantics of this function is given by the theory of arrays described in the SMT-LIB + standard. See http: + The result of this function is an array that is equal to [a] (with respect to [select)] + on all indices except for [i], where it maps to [v] (and the [select] of [a] with + respect to [i] may be a different value). + + - {b See also}: {!mk_array_sort} + - {b See also}: {!mk_select} +*) +external mk_store : context -> ast -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_store" + +(** + Summary: Create the constant array. + + The resulting term is an array, such that a [select] on an arbitrary index + produces the value [v]. + + @param c logical context. + @param domain domain sort for the array. + @param v value that the array maps to. +*) +external mk_const_array : context -> sort -> ast -> ast + = "camlidl_z3_Z3_mk_const_array" + +(** + Summary: \[ [ mk_map f n args ] \] + map f on the the argument arrays. + + The [n] nodes [args] must be of array sorts {e [domain_i -> range_i] }. + The function declaration [f] must have type {e range_1 .. range_n -> range }. + [v] must have sort range. The sort of the result is {e [domain_i -> range] }. + + - {b See also}: {!mk_array_sort} + - {b See also}: {!mk_store} + - {b See also}: {!mk_select} +*) +external mk_map : context -> func_decl -> int -> ast -> ast + = "camlidl_z3_Z3_mk_map" + +(** + Summary: Access the array default value. + Produces the default range value, for arrays that can be represented as + finite maps with a default range value. + + @param c logical context. + @param array array value whose default range value is accessed. + +*) +external mk_array_default : context -> ast -> ast + = "camlidl_z3_Z3_mk_array_default" + +(** + {2 {L Sets}} +*) +(** + Summary: Create Set type. +*) +external mk_set_sort : context -> sort -> sort + = "camlidl_z3_Z3_mk_set_sort" + +(** + Summary: Create the empty set. +*) +external mk_empty_set : context -> sort -> ast + = "camlidl_z3_Z3_mk_empty_set" + +(** + Summary: Create the full set. +*) +external mk_full_set : context -> sort -> ast + = "camlidl_z3_Z3_mk_full_set" + +(** + Summary: Add an element to a set. + + The first argument must be a set, the second an element. +*) +external mk_set_add : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_set_add" + +(** + Summary: Remove an element to a set. + + The first argument must be a set, the second an element. +*) +external mk_set_del : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_set_del" + +(** + Summary: Take the union of a list of sets. +*) +external mk_set_union : context -> ast array -> ast + = "camlidl_z3_Z3_mk_set_union" + +(** + Summary: Take the intersection of a list of sets. +*) +external mk_set_intersect : context -> ast array -> ast + = "camlidl_z3_Z3_mk_set_intersect" + +(** + Summary: Take the set difference between two sets. +*) +external mk_set_difference : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_set_difference" + +(** + Summary: Take the complement of a set. +*) +external mk_set_complement : context -> ast -> ast + = "camlidl_z3_Z3_mk_set_complement" + +(** + Summary: Check for set membership. + + The first argument should be an element type of the set. +*) +external mk_set_member : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_set_member" + +(** + Summary: Check for subsetness of sets. +*) +external mk_set_subset : context -> ast -> ast -> ast + = "camlidl_z3_Z3_mk_set_subset" + +(** + {2 {L Numerals}} +*) + +(** + Summary: \[ [ numeral_refined ] \] is the refined view of a numeral . +*) +type numeral_refined = + | Numeral_int of int * sort + | Numeral_int64 of int64 * sort + | Numeral_large of string * sort + | Numeral_rational of numeral_refined * numeral_refined + + +(** + Summary: \[ [ embed_numeral c nr ] \] constructs the numeral described by [nr]. + + - {b See also}: {!numeral_refine} +*) +val embed_numeral: context -> numeral_refined -> ast + +(** + {4 {L Redundant low-level API}} +*) +(** + Summary: Create a numeral of a given sort. + + @param c logical context. + @param numeral A string representing the numeral value in decimal notation. If the given sort is a real, then the numeral can be a rational, that is, a string of the form {e [num]* / [num]* }. + @param ty The sort of the numeral. In the current implementation, the given sort can be an int, real, finite-domain, or bit-vectors of arbitrary size. + + - {b See also}: {!mk_int} + +*) +external mk_numeral : context -> string -> sort -> ast + = "camlidl_z3_Z3_mk_numeral" + +(** + Summary: Create a real from a fraction. + + @param c logical context. + @param num numerator of rational. + @param den denomerator of rational. + + - {b Precondition}: den != 0 + + - {b See also}: {!mk_numeral} + - {b See also}: {!mk_int} + +*) +external mk_real : context -> int -> int -> ast + = "camlidl_z3_Z3_mk_real" + +(** + Summary: Create a numeral of an int, bit-vector, or finite-domain sort. + + This function can be use to create numerals that fit in a machine integer. + It is slightly faster than {!mk_numeral} since it is not necessary to parse a string. + + - {b See also}: {!mk_numeral} +*) +external mk_int : context -> int -> sort -> ast + = "camlidl_z3_Z3_mk_int" + +(** + Summary: Create a numeral of a int, bit-vector, or finite-domain sort. + + This function can be use to create numerals that fit in a machine long long integer. + It is slightly faster than {!mk_numeral} since it is not necessary to parse a string. + + - {b See also}: {!mk_numeral} +*) +external mk_int64 : context -> int64 -> sort -> ast + = "camlidl_z3_Z3_mk_int64" + +(** + {2 {L Quantifiers}} +*) +(** + Summary: Create a pattern for quantifier instantiation. + + Z3 uses pattern matching to instantiate quantifiers. If a + pattern is not provided for a quantifier, then Z3 will + automatically compute a set of patterns for it. However, for + optimal performance, the user should provide the patterns. + + Patterns comprise a list of terms. The list should be + non-empty. If the list comprises of more than one term, it is + a called a multi-pattern. + + In general, one can pass in a list of (multi-)patterns in the + quantifier constructor. + + + - {b See also}: {!mk_forall} + - {b See also}: {!mk_exists} +*) +external mk_pattern : context -> ast array -> pattern + = "camlidl_z3_Z3_mk_pattern" + +(** + Summary: Create a bound variable. + + Bound variables are indexed by de-Bruijn indices. It is perhaps easiest to explain + the meaning of de-Bruijn indices by indicating the compilation process from + non-de-Bruijn formulas to de-Bruijn format. + + {v + abs(forall (x1) phi) = forall (x1) abs1(phi, x1, 0) + abs(forall (x1, x2) phi) = abs(forall (x1) abs(forall (x2) phi)) + abs1(x, x, n) = b_n + abs1(y, x, n) = y + abs1(f(t1,...,tn), x, n) = f(abs1(t1,x,n), ..., abs1(tn,x,n)) + abs1(forall (x1) phi, x, n) = forall (x1) (abs1(phi, x, n+1)) + v} + + The last line is significant: the index of a bound variable is different depending + on the scope in which it appears. The deeper x appears, the higher is its + index. + + @param c logical context + @param index de-Bruijn index + @param ty sort of the bound variable + + - {b See also}: {!mk_forall} + - {b See also}: {!mk_exists} +*) +external mk_bound : context -> int -> sort -> ast + = "camlidl_z3_Z3_mk_bound" + +(** + Summary: Create a forall formula. It takes an expression [body] that contains bound variables + of the same sorts as the sorts listed in the array [sorts]. The bound variables are de-Bruijn indices created + using {!mk_bound}. The array [decl_names] contains the names that the quantified formula uses for the + bound variables. Z3 applies the convention that the last element in the [decl_names] and [sorts] array + refers to the variable with index 0, the second to last element of [decl_names] and [sorts] refers + to the variable with index 1, etc. + + + [mk_forall c w p t n b] creates a forall formula, where + [w] is the weight, [p] is an array of patterns, [t] is an array + with the sorts of the bound variables, [n] is an array with the + 'names' of the bound variables, and [b] is the body of the + quantifier. Quantifiers are associated with weights indicating + the importance of using the quantifier during + instantiation. + + + @param c logical context. + @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. + @param num_patterns number of patterns. + @param patterns array containing the patterns created using {!mk_pattern}. + @param num_decls number of variables to be bound. + @param sorts the sorts of the bound variables. + @param decl_names names of the bound variables + @param body the body of the quantifier. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_bound} + - {b See also}: {!mk_exists} +*) +external mk_forall : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_forall_bytecode" "camlidl_z3_Z3_mk_forall" + +(** + Summary: Create an exists formula. Similar to {!mk_forall}. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_bound} + - {b See also}: {!mk_forall} + - {b See also}: {!mk_quantifier} +*) +external mk_exists : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_exists_bytecode" "camlidl_z3_Z3_mk_exists" + +(** + Summary: Create a quantifier - universal or existential, with pattern hints. + See the documentation for {!mk_forall} for an explanation of the parameters. + + @param c logical context. + @param is_forall flag to indicate if this is a universal or existential quantifier. + @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. + @param num_patterns number of patterns. + @param patterns array containing the patterns created using {!mk_pattern}. + @param num_decls number of variables to be bound. + @param sorts array of sorts of the bound variables. + @param decl_names names of the bound variables. + @param body the body of the quantifier. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_bound} + - {b See also}: {!mk_forall} + - {b See also}: {!mk_exists} +*) +external mk_quantifier : context -> bool -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_bytecode" "camlidl_z3_Z3_mk_quantifier" + +(** + Summary: Create a quantifier - universal or existential, with pattern hints, no patterns, and attributes + + @param c logical context. + @param is_forall flag to indicate if this is a universal or existential quantifier. + @param quantifier_id identifier to identify quantifier + @param skolem_id identifier to identify skolem constants introduced by quantifier. + @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. + @param num_patterns number of patterns. + @param patterns array containing the patterns created using {!mk_pattern}. + @param num_no_patterns number of patterns. + @param no_patterns array containing the patterns created using {!mk_pattern}. + @param num_decls number of variables to be bound. + @param sorts array of sorts of the bound variables. + @param decl_names names of the bound variables. + @param body the body of the quantifier. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_bound} + - {b See also}: {!mk_forall} + - {b See also}: {!mk_exists} +*) +external mk_quantifier_ex : context -> bool -> int -> symbol -> symbol -> pattern array -> ast array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_ex_bytecode" "camlidl_z3_Z3_mk_quantifier_ex" + +(** + Summary: Create a universal quantifier using a list of constants that + will form the set of bound variables. + + @param c logical context. + @param weight quantifiers are associated with weights indicating the importance of using + the quantifier during instantiation. By default, pass the weight 0. + @param num_bound number of constants to be abstracted into bound variables. + @param bound array of constants to be abstracted into bound variables. + @param num_patterns number of patterns. + @param patterns array containing the patterns created using {!mk_pattern}. + @param body the body of the quantifier. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_exists_const} + +*) +external mk_forall_const : context -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3_Z3_mk_forall_const" + +(** + Summary: Similar to {!mk_forall_const}. + + Summary: Create an existential quantifier using a list of constants that + will form the set of bound variables. + + @param c logical context. + @param weight quantifiers are associated with weights indicating the importance of using + the quantifier during instantiation. By default, pass the weight 0. + @param num_bound number of constants to be abstracted into bound variables. + @param bound array of constants to be abstracted into bound variables. + @param num_patterns number of patterns. + @param patterns array containing the patterns created using {!mk_pattern}. + @param body the body of the quantifier. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_forall_const} +*) +external mk_exists_const : context -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3_Z3_mk_exists_const" + +(** + Summary: Create a universal or existential + quantifier using a list of constants that + will form the set of bound variables. +*) +external mk_quantifier_const : context -> bool -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_const_bytecode" "camlidl_z3_Z3_mk_quantifier_const" + +(** + Summary: Create a universal or existential + quantifier using a list of constants that + will form the set of bound variables. +*) +external mk_quantifier_const_ex : context -> bool -> int -> symbol -> symbol -> app array -> pattern array -> ast array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_const_ex_bytecode" "camlidl_z3_Z3_mk_quantifier_const_ex" + +(** + {2 {L Accessors}} +*) +(** + {3 {L Symbols}} +*) + +(** + Summary: \[ [ symbol_refine c s ] \] is the refined view of [s]. +*) +val symbol_refine: context -> symbol -> symbol_refined + +(** + {4 {L Redundant low-level API}} +*) +(** + Summary: Return [INT_SYMBOL] if the symbol was constructed + using {!mk_int_symbol}, and [STRING_SYMBOL] if the symbol + was constructed using {!mk_string_symbol}. +*) +external get_symbol_kind : context -> symbol -> symbol_kind + = "camlidl_z3_Z3_get_symbol_kind" + +(** + Summary: \[ [ get_symbol_int c s ] \] + Return the symbol int value. + + - {b Precondition}: get_symbol_kind s == INT_SYMBOL + + - {b See also}: {!mk_int_symbol} +*) +external get_symbol_int : context -> symbol -> int + = "camlidl_z3_Z3_get_symbol_int" + +(** + Summary: \[ [ get_symbol_string c s ] \] + Return the symbol name. + + - {b Precondition}: get_symbol_string s == STRING_SYMBOL + + + + + + - {b See also}: {!mk_string_symbol} +*) +external get_symbol_string : context -> symbol -> string + = "camlidl_z3_Z3_get_symbol_string" + +(** + {3 {L Sorts}} +*) + +(** + Summary: \[ [ sort_refine c s ] \] is the refined view of [s]. +*) +val sort_refine: context -> sort -> sort_refined + +(** + Summary: Return the sort name as a symbol. +*) +external get_sort_name : context -> sort -> symbol + = "camlidl_z3_Z3_get_sort_name" + +(** + Summary: Return a unique identifier for [s]. + - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. +*) +external get_sort_id : context -> sort -> int + = "camlidl_z3_Z3_get_sort_id" + +(** + {4 {L Redundant low-level API}} +*) +(** + Summary: Convert a [sort] into [ast]. + - {b Remarks}: [sort_to_ast c s] can be replaced by [(s :> ast)]. +*) +external sort_to_ast : context -> sort -> ast + = "camlidl_z3_Z3_sort_to_ast" + +(** + Summary: compare sorts. + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. +*) +external is_eq_sort : context -> sort -> sort -> bool + = "camlidl_z3_Z3_is_eq_sort" + +(** + Summary: Return the sort kind (e.g., array, tuple, int, bool, etc). + + - {b See also}: {!sort_kind} +*) +external get_sort_kind : context -> sort -> sort_kind + = "camlidl_z3_Z3_get_sort_kind" + +(** + Summary: \[ [ get_bv_sort_size c t ] \] + Return the size of the given bit-vector sort. + + - {b Precondition}: get_sort_kind c t == BV_SORT + + - {b See also}: {!mk_bv_sort} + - {b See also}: {!get_sort_kind} +*) +external get_bv_sort_size : context -> sort -> int + = "camlidl_z3_Z3_get_bv_sort_size" + +(** + + Summary: Return the size of the sort in [r]. Return [None] if the call failed. + That is, get_sort_kind(s) == FINITE_DOMAIN_SORT +*) +external get_finite_domain_sort_size : context -> sort -> int64 option + = "camlidl_z3_Z3_get_finite_domain_sort_size" + +(** + Summary: \[ [ get_array_sort_domain c t ] \] + Return the domain of the given array sort. + + - {b Precondition}: get_sort_kind c t == ARRAY_SORT + + - {b See also}: {!mk_array_sort} + - {b See also}: {!get_sort_kind} +*) +external get_array_sort_domain : context -> sort -> sort + = "camlidl_z3_Z3_get_array_sort_domain" + +(** + Summary: \[ [ get_array_sort_range c t ] \] + Return the range of the given array sort. + + - {b Precondition}: get_sort_kind c t == ARRAY_SORT + + - {b See also}: {!mk_array_sort} + - {b See also}: {!get_sort_kind} +*) +external get_array_sort_range : context -> sort -> sort + = "camlidl_z3_Z3_get_array_sort_range" + +(** + Summary: \[ [ get_tuple_sort_mk_decl c t ] \] + Return the constructor declaration of the given tuple + sort. + + - {b Precondition}: get_sort_kind c t == DATATYPE_SORT + + - {b See also}: {!mk_tuple_sort} + - {b See also}: {!get_sort_kind} +*) +external get_tuple_sort_mk_decl : context -> sort -> func_decl + = "camlidl_z3_Z3_get_tuple_sort_mk_decl" + +(** + Summary: \[ [ get_tuple_sort_num_fields c t ] \] + Return the number of fields of the given tuple sort. + + - {b Precondition}: get_sort_kind c t == DATATYPE_SORT + + - {b See also}: {!mk_tuple_sort} + - {b See also}: {!get_sort_kind} +*) +external get_tuple_sort_num_fields : context -> sort -> int + = "camlidl_z3_Z3_get_tuple_sort_num_fields" + +(** + Summary: \[ [ get_tuple_sort_field_decl c t i ] \] + Return the i-th field declaration (i.e., projection function declaration) + of the given tuple sort. + + - {b Precondition}: get_sort_kind t == DATATYPE_SORT + - {b Precondition}: i < get_tuple_sort_num_fields c t + + - {b See also}: {!mk_tuple_sort} + - {b See also}: {!get_sort_kind} +*) +external get_tuple_sort_field_decl : context -> sort -> int -> func_decl + = "camlidl_z3_Z3_get_tuple_sort_field_decl" + +(** + Summary: Return number of constructors for datatype. + + - {b Precondition}: get_sort_kind t == DATATYPE_SORT + + - {b See also}: {!get_datatype_sort_constructor} + - {b See also}: {!get_datatype_sort_recognizer} + - {b See also}: {!get_datatype_sort_constructor_accessor} + +*) +external get_datatype_sort_num_constructors : context -> sort -> int + = "camlidl_z3_Z3_get_datatype_sort_num_constructors" + +(** + Summary: Return idx'th constructor. + + - {b Precondition}: get_sort_kind t == DATATYPE_SORT + - {b Precondition}: idx < get_datatype_sort_num_constructors c t + + - {b See also}: {!get_datatype_sort_num_constructors} + - {b See also}: {!get_datatype_sort_recognizer} + - {b See also}: {!get_datatype_sort_constructor_accessor} + +*) +external get_datatype_sort_constructor : context -> sort -> int -> func_decl + = "camlidl_z3_Z3_get_datatype_sort_constructor" + +(** + Summary: Return idx'th recognizer. + + - {b Precondition}: get_sort_kind t == DATATYPE_SORT + - {b Precondition}: idx < get_datatype_sort_num_constructors c t + + - {b See also}: {!get_datatype_sort_num_constructors} + - {b See also}: {!get_datatype_sort_constructor} + - {b See also}: {!get_datatype_sort_constructor_accessor} + +*) +external get_datatype_sort_recognizer : context -> sort -> int -> func_decl + = "camlidl_z3_Z3_get_datatype_sort_recognizer" + +(** + Summary: Return idx_a'th accessor for the idx_c'th constructor. + + - {b Precondition}: get_sort_kind t == DATATYPE_SORT + - {b Precondition}: idx_c < get_datatype_sort_num_constructors c t + - {b Precondition}: idx_a < get_domain_size c get_datatype_sort_constructor c idx_c + + - {b See also}: {!get_datatype_sort_num_constructors} + - {b See also}: {!get_datatype_sort_constructor} + - {b See also}: {!get_datatype_sort_recognizer} +*) +external get_datatype_sort_constructor_accessor : context -> sort -> int -> int -> func_decl + = "camlidl_z3_Z3_get_datatype_sort_constructor_accessor" + +(** + Summary: Return arity of relation. + + - {b Precondition}: get_sort_kind s == RELATION_SORT + + - {b See also}: {!get_relation_column} +*) +external get_relation_arity : context -> sort -> int + = "camlidl_z3_Z3_get_relation_arity" + +(** + Summary: Return sort at i'th column of relation sort. + + - {b Precondition}: get_sort_kind c s == RELATION_SORT + - {b Precondition}: col < get_relation_arity c s + + - {b See also}: {!get_relation_arity} +*) +external get_relation_column : context -> sort -> int -> sort + = "camlidl_z3_Z3_get_relation_column" + +(** + {3 {L Function Declarations}} +*) +(** + Summary: Convert a [func_decl] into [ast]. + - {b Remarks}: [func_decl_to_ast c f] can be replaced by [(f :> ast)]. +*) +external func_decl_to_ast : context -> func_decl -> ast + = "camlidl_z3_Z3_func_decl_to_ast" + +(** + Summary: compare terms. + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. +*) +external is_eq_func_decl : context -> func_decl -> func_decl -> bool + = "camlidl_z3_Z3_is_eq_func_decl" + +(** + Summary: Return a unique identifier for [f]. + - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. +*) +external get_func_decl_id : context -> func_decl -> int + = "camlidl_z3_Z3_get_func_decl_id" + +(** + Summary: Return the constant declaration name as a symbol. +*) +external get_decl_name : context -> func_decl -> symbol + = "camlidl_z3_Z3_get_decl_name" + +(** + Summary: Return declaration kind corresponding to declaration. +*) +external get_decl_kind : context -> func_decl -> decl_kind + = "camlidl_z3_Z3_get_decl_kind" + +(** + Summary: Return the number of parameters of the given declaration. + + - {b See also}: {!get_arity} +*) +external get_domain_size : context -> func_decl -> int + = "camlidl_z3_Z3_get_domain_size" + +(** + Summary: Alias for [get_domain_size]. + + - {b See also}: {!get_domain_size} +*) +external get_arity : context -> func_decl -> int + = "camlidl_z3_Z3_get_arity" + +(** + Summary: \[ [ get_domain c d i ] \] + Return the sort of the i-th parameter of the given function declaration. + + - {b Precondition}: i < get_domain_size d + + - {b See also}: {!get_domain_size} +*) +external get_domain : context -> func_decl -> int -> sort + = "camlidl_z3_Z3_get_domain" + + +(** + Summary: \[ [ get_domains c d ] \] is the array of parameters of [d]. + + - {b See also}: {!get_domain_size} + - {b See also}: {!get_domain} +*) +val get_domains: context -> func_decl -> sort array + +(** + Summary: \[ [ get_range c d ] \] + Return the range of the given declaration. + + If [d] is a constant (i.e., has zero arguments), then this + function returns the sort of the constant. +*) +external get_range : context -> func_decl -> sort + = "camlidl_z3_Z3_get_range" + +(** + Summary: Return the number of parameters associated with a declaration. +*) +external get_decl_num_parameters : context -> func_decl -> int + = "camlidl_z3_Z3_get_decl_num_parameters" + +(** + Summary: Return the parameter type associated with a declaration. + + @param c the context + @param d the function declaration + @param idx is the index of the named parameter it should be between 0 and the number of parameters. +*) +external get_decl_parameter_kind : context -> func_decl -> int -> parameter_kind + = "camlidl_z3_Z3_get_decl_parameter_kind" + +(** + Summary: Return the integer value associated with an integer parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_INT +*) +external get_decl_int_parameter : context -> func_decl -> int -> int + = "camlidl_z3_Z3_get_decl_int_parameter" + +(** + Summary: Return the double value associated with an double parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_DOUBLE +*) +external get_decl_double_parameter : context -> func_decl -> int -> float + = "camlidl_z3_Z3_get_decl_double_parameter" + +(** + Summary: Return the double value associated with an double parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_SYMBOL +*) +external get_decl_symbol_parameter : context -> func_decl -> int -> symbol + = "camlidl_z3_Z3_get_decl_symbol_parameter" + +(** + Summary: Return the sort value associated with a sort parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_SORT +*) +external get_decl_sort_parameter : context -> func_decl -> int -> sort + = "camlidl_z3_Z3_get_decl_sort_parameter" + +(** + Summary: Return the expresson value associated with an expression parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_AST +*) +external get_decl_ast_parameter : context -> func_decl -> int -> ast + = "camlidl_z3_Z3_get_decl_ast_parameter" + +(** + Summary: Return the expresson value associated with an expression parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_FUNC_DECL +*) +external get_decl_func_decl_parameter : context -> func_decl -> int -> func_decl + = "camlidl_z3_Z3_get_decl_func_decl_parameter" + +(** + Summary: Return the rational value, as a string, associated with a rational parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_RATIONAL +*) +external get_decl_rational_parameter : context -> func_decl -> int -> string + = "camlidl_z3_Z3_get_decl_rational_parameter" + +(** + {3 {L Applications}} +*) +(** + Summary: Convert a [app] into [ast]. + - {b Remarks}: [app_to_ast c a] can be replaced by [(a :> ast)]. +*) +external app_to_ast : context -> app -> ast + = "camlidl_z3_Z3_app_to_ast" + +(** + Summary: Return the declaration of a constant or function application. +*) +external get_app_decl : context -> app -> func_decl + = "camlidl_z3_Z3_get_app_decl" + +(** + Summary: \[ [ get_app_num_args c a ] \] + Return the number of argument of an application. If [t] + is an constant, then the number of arguments is 0. +*) +external get_app_num_args : context -> app -> int + = "camlidl_z3_Z3_get_app_num_args" + +(** + Summary: \[ [ get_app_arg c a i ] \] + Return the i-th argument of the given application. + + - {b Precondition}: i < get_num_args c a +*) +external get_app_arg : context -> app -> int -> ast + = "camlidl_z3_Z3_get_app_arg" + + +(** + Summary: \[ [ get_app_args c a ] \] is the array of arguments of an application. If [t] is a constant, then the array is empty. + + - {b See also}: {!get_app_num_args} + - {b See also}: {!get_app_arg} +*) +val get_app_args: context -> app -> ast array + +(** + {3 {L Terms}} +*) + +(** + Summary: \[ [ binder_type ] \] is a universal or existential quantifier. + + - {b See also}: {!term_refined} +*) +type binder_type = Forall | Exists + +(** + Summary: \[ [ term_refined ] \] is the refinement of a {!ast} . + + - {b See also}: {!term_refine} +*) +type term_refined = + | Term_numeral of numeral_refined + | Term_app of decl_kind * func_decl * ast array + | Term_quantifier of binder_type * int * ast array array * (symbol * sort) array * ast + | Term_var of int * sort + + +(** + Summary: \[ [ mk_term c tr ] \] constructs the term described by [tr]. + + - {b Precondition}: [tr] is not of form + - {b See also}: {!term_refine} +*) +(* val mk_term: context -> term_refined -> ast *) + + +(** + Summary: \[ [ term_refine c a ] \] is the refined view of [a]. +*) +val term_refine : context -> ast -> term_refined + +(** + Summary: compare terms. + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. +*) +external is_eq_ast : context -> ast -> ast -> bool + = "camlidl_z3_Z3_is_eq_ast" + +(** + Summary: Return a unique identifier for [t]. + - {b Remarks}: Implicitly used by [Pervasives.compare] for values of type [ast], [app], [sort], [func_decl], and [pattern]. +*) +external get_ast_id : context -> ast -> int + = "camlidl_z3_Z3_get_ast_id" + +(** + Summary: Return a hash code for the given AST. + - {b Remarks}: Implicitly used by [Hashtbl.hash] for values of type [ast], [app], [sort], [func_decl], and [pattern]. +*) +external get_ast_hash : context -> ast -> int + = "camlidl_z3_Z3_get_ast_hash" + +(** + Summary: Return the sort of an AST node. + + The AST node must be a constant, application, numeral, bound variable, or quantifier. + +*) +external get_sort : context -> ast -> sort + = "camlidl_z3_Z3_get_sort" + +(** + Summary: Return true if the given expression [t] is well sorted. +*) +external is_well_sorted : context -> ast -> bool + = "camlidl_z3_Z3_is_well_sorted" + +(** + Summary: Return L_TRUE if [a] is true, L_FALSE if it is false, and L_UNDEF otherwise. +*) +external get_bool_value : context -> ast -> lbool + = "camlidl_z3_Z3_get_bool_value" + +(** + Summary: Return the kind of the given AST. +*) +external get_ast_kind : context -> ast -> ast_kind + = "camlidl_z3_Z3_get_ast_kind" + +external is_app : context -> ast -> bool + = "camlidl_z3_Z3_is_app" + +external is_numeral_ast : context -> ast -> bool + = "camlidl_z3_Z3_is_numeral_ast" + +(** + Summary: Return true if the give AST is a real algebraic number. +*) +external is_algebraic_number : context -> ast -> bool + = "camlidl_z3_Z3_is_algebraic_number" + +(** + Summary: Convert an [ast] into an [APP_AST]. + + - {b Precondition}: {v get_ast_kind c a == [APP_AST] v} +*) +external to_app : context -> ast -> app + = "camlidl_z3_Z3_to_app" + +(** + Summary: Convert an AST into a FUNC_DECL_AST. This is just type casting. + + - {b Precondition}: {v get_ast_kind c a == FUNC_DECL_AST v} +*) +external to_func_decl : context -> ast -> func_decl + = "camlidl_z3_Z3_to_func_decl" + +(** + {4 {L Numerals}} +*) + +(** + Summary: \[ [ numeral_refine c a ] \] is the refined view of [a]. + + - {b Precondition}: [get_ast_kind c a = NUMERAL_AST] +*) +val numeral_refine : context -> ast -> numeral_refined + +(** + {5 {L Low-level API}} +*) +(** + Summary: Return numeral value, as a string of a numeric constant term + + - {b Precondition}: get_ast_kind c a == NUMERAL_AST +*) +external get_numeral_string : context -> ast -> string + = "camlidl_z3_Z3_get_numeral_string" + +(** + Summary: Return numeral as a string in decimal notation. + The result has at most [precision] decimal places. + + - {b Precondition}: get_ast_kind c a == NUMERAL_AST || is_algebraic_number c a +*) +external get_numeral_decimal_string : context -> ast -> int -> string + = "camlidl_z3_Z3_get_numeral_decimal_string" + +(** + Summary: Return the numerator (as a numeral AST) of a numeral AST of sort Real. + + - {b Precondition}: get_ast_kind c a == NUMERAL_AST +*) +external get_numerator : context -> ast -> ast + = "camlidl_z3_Z3_get_numerator" + +(** + Summary: Return the denominator (as a numeral AST) of a numeral AST of sort Real. + + - {b Precondition}: get_ast_kind c a == NUMERAL_AST +*) +external get_denominator : context -> ast -> ast + = "camlidl_z3_Z3_get_denominator" + +(** + Summary: Return numeral value, as a pair of 64 bit numbers if the representation fits. + + @param c logical context. + @param a term. + @param num numerator. + @param den denominator. + + Return [TRUE] if the numeral value fits in 64 bit numerals, [FALSE] otherwise. + + - {b Precondition}: get_ast_kind a == NUMERAL_AST +*) +external get_numeral_small : context -> ast -> bool * int64 * int64 + = "camlidl_z3_Z3_get_numeral_small" + +(** + Summary: \[ [ get_numeral_int c v ] \] + Similar to {!get_numeral_string}, but only succeeds if + the value can fit in a machine int. Return TRUE if the call succeeded. + + - {b Precondition}: get_ast_kind c v == NUMERAL_AST + + - {b See also}: {!get_numeral_string} +*) +external get_numeral_int : context -> ast -> bool * int + = "camlidl_z3_Z3_get_numeral_int" + +(** + Summary: \[ [ get_numeral_int64 c v ] \] + Similar to {!get_numeral_string}, but only succeeds if + the value can fit in a machine long long int. Return TRUE if the call succeeded. + + - {b Precondition}: get_ast_kind c v == NUMERAL_AST + + - {b See also}: {!get_numeral_string} +*) +external get_numeral_int64 : context -> ast -> bool * int64 + = "camlidl_z3_Z3_get_numeral_int64" + +(** + Summary: \[ [ get_numeral_rational_int64 c x y] \] + Similar to {!get_numeral_string}, but only succeeds if + the value can fit as a rational number as machine long long int. Return TRUE if the call succeeded. + + - {b Precondition}: get_ast_kind c v == NUMERAL_AST + + - {b See also}: {!get_numeral_string} +*) +external get_numeral_rational_int64 : context -> ast -> bool * int64 * int64 + = "camlidl_z3_Z3_get_numeral_rational_int64" + +(** + Summary: Return a lower bound for the given real algebraic number. + The interval isolating the number is smaller than 1/10^precision. + The result is a numeral AST of sort Real. + + - {b Precondition}: is_algebraic_number c a +*) +external get_algebraic_number_lower : context -> ast -> int -> ast + = "camlidl_z3_Z3_get_algebraic_number_lower" + +(** + Summary: Return a upper bound for the given real algebraic number. + The interval isolating the number is smaller than 1/10^precision. + The result is a numeral AST of sort Real. + + - {b Precondition}: is_algebraic_number c a +*) +external get_algebraic_number_upper : context -> ast -> int -> ast + = "camlidl_z3_Z3_get_algebraic_number_upper" + +(** + {4 {L Patterns}} +*) +(** + Summary: Convert a pattern into ast. + - {b Remarks}: [pattern_to_ast c p] can be replaced by [(p :> ast)]. +*) +external pattern_to_ast : context -> pattern -> ast + = "camlidl_z3_Z3_pattern_to_ast" + + +(** + Summary: \[ [ get_pattern_terms c p ] \] is the ast's in pattern. + + - {b See also}: {!get_pattern_num_terms} + - {b See also}: {!get_pattern} +*) +val get_pattern_terms: context -> pattern -> ast array;; + +(** + Summary: Return number of terms in pattern. +*) +external get_pattern_num_terms : context -> pattern -> int + = "camlidl_z3_Z3_get_pattern_num_terms" + +(** + Summary: Return i'th ast in pattern. +*) +external get_pattern : context -> pattern -> int -> ast + = "camlidl_z3_Z3_get_pattern" + +(** + {4 {L Quantifiers}} +*) +(** + Summary: Return index of de-Brujin bound variable. + + - {b Precondition}: get_ast_kind a == VAR_AST +*) +external get_index_value : context -> ast -> int + = "camlidl_z3_Z3_get_index_value" + +(** + Summary: Determine if quantifier is universal. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external is_quantifier_forall : context -> ast -> bool + = "camlidl_z3_Z3_is_quantifier_forall" + +(** + Summary: Obtain weight of quantifier. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_weight : context -> ast -> int + = "camlidl_z3_Z3_get_quantifier_weight" + +(** + Summary: Return number of patterns used in quantifier. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_num_patterns : context -> ast -> int + = "camlidl_z3_Z3_get_quantifier_num_patterns" + +(** + Summary: Return i'th pattern. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_pattern_ast : context -> ast -> int -> pattern + = "camlidl_z3_Z3_get_quantifier_pattern_ast" + +(** + Summary: Return number of no_patterns used in quantifier. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_num_no_patterns : context -> ast -> int + = "camlidl_z3_Z3_get_quantifier_num_no_patterns" + +(** + Summary: Return i'th no_pattern. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_no_pattern_ast : context -> ast -> int -> ast + = "camlidl_z3_Z3_get_quantifier_no_pattern_ast" + +(** + Summary: Return symbol of the i'th bound variable. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_bound_name : context -> ast -> int -> symbol + = "camlidl_z3_Z3_get_quantifier_bound_name" + +(** + Summary: Return sort of the i'th bound variable. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_bound_sort : context -> ast -> int -> sort + = "camlidl_z3_Z3_get_quantifier_bound_sort" + +(** + Summary: Return body of quantifier. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_body : context -> ast -> ast + = "camlidl_z3_Z3_get_quantifier_body" + +(** + Summary: Return number of bound variables of quantifier. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_num_bound : context -> ast -> int + = "camlidl_z3_Z3_get_quantifier_num_bound" + +(** + {3 {L Simplification}} +*) +(** + Summary: Interface to simplifier. + + Provides an interface to the AST simplifier used by Z3. +*) +external simplify : context -> ast -> ast + = "camlidl_z3_Z3_simplify" + +(** + Summary: Interface to simplifier. + + Provides an interface to the AST simplifier used by Z3. + This procedure is similar to {!simplify}, but the behavior of the simplifier + can be configured using the given parameter set. +*) +external simplify_ex : context -> ast -> params -> ast + = "camlidl_z3_Z3_simplify_ex" + +(** + Summary: Return a string describing all available parameters. +*) +external simplify_get_help : context -> string + = "camlidl_z3_Z3_simplify_get_help" + +(** + Summary: Return the parameter description set for the simplify procedure. +*) +external simplify_get_param_descrs : context -> param_descrs + = "camlidl_z3_Z3_simplify_get_param_descrs" + +(** + {2 {L Modifiers}} +*) +(** + Summary: Update the arguments of term [a] using the arguments [args]. + The number of arguments [num_args] should coincide + with the number of arguments to [a]. + If [a] is a quantifier, then num_args has to be 1. +*) +external update_term : context -> ast -> ast array -> ast + = "camlidl_z3_Z3_update_term" + +(** + Summary: Substitute every occurrence of {e from[i] } in [a] with {e to[i] }, for [i] smaller than [num_exprs]. + The result is the new AST. The arrays [from] and [to] must have size [num_exprs]. + For every [i] smaller than [num_exprs], we must have that sort of {e from[i] } must be equal to sort of {e to[i] }. +*) +external substitute : context -> ast -> ast array -> ast array -> ast + = "camlidl_z3_Z3_substitute" + +(** + Summary: Substitute the free variables in [a] with the expressions in [to]. + For every [i] smaller than [num_exprs], the variable with de-Bruijn index [i] is replaced with term {e to[i] }. +*) +external substitute_vars : context -> ast -> ast array -> ast + = "camlidl_z3_Z3_substitute_vars" + +(** + Summary: Translate/Copy the AST [a] from context [source] to context [target]. + AST [a] must have been created using context [source]. + - {b Precondition}: source != target +*) +external translate : context -> ast -> context -> ast + = "camlidl_z3_Z3_translate" + +(** + {2 {L Models}} +*) + +(** + A model assigns uninterpreted sorts to finite universes of distinct values, constants to values, + and arrays and functions to finite maps from argument values to result values plus a default + value for all other arguments. +*) +type model_refined = { + sorts : (sort, ast_vector) Hashtbl.t; + consts : (func_decl, ast) Hashtbl.t; + arrays : (func_decl, (ast, ast) Hashtbl.t * ast) Hashtbl.t; + funcs : (func_decl, (ast array, ast) Hashtbl.t * ast) Hashtbl.t; +} + + +(** + Summary: [model_refine c m] is the refined model of [m]. +*) +val model_refine : context -> model -> model_refined + +(** + Summary: \[ [ model_eval c m t ] \] + Evaluate the AST node [t] in the given model. + + Return [None] if the term was not successfully evaluated. + + If [model_completion] is TRUE, then Z3 will assign an interpretation for any constant or function that does + not have an interpretation in [m]. These constants and functions were essentially don't cares. + + The evaluation may fail for the following reasons: + + - [t] contains a quantifier. + + - the model [m] is partial, that is, it doesn't have a complete interpretation for uninterpreted functions. + That is, the option {e MODEL_PARTIAL=true } was used. + + - [t] is type incorrect. +*) +external model_eval : context -> model -> ast -> bool -> ast option + = "camlidl_z3_Z3_model_eval" + +(** + {4 {L Low-level API}} +*) +(** + Summary: Return the interpretation (i.e., assignment) of constant [a] in the model [m]. + Return [None], + if the model does not assign an interpretation for [a]. + That should be interpreted as: the value of [a] does not matter. + + - {b Precondition}: get_arity c a == 0 +*) +external model_get_const_interp : context -> model -> func_decl -> ast option + = "camlidl_z3_Z3_model_get_const_interp" + +(** + Summary: Return the interpretation of the function [f] in the model [m]. + Return [None], + if the model does not assign an interpretation for [f]. + That should be interpreted as: the [f] does not matter. + + - {b Precondition}: get_arity c f > 0 + + + +*) +external model_get_func_interp : context -> model -> func_decl -> func_interp option + = "camlidl_z3_Z3_model_get_func_interp" + +(** + Summary: Return the number of constants assigned by the given model. + + - {b See also}: {!model_get_const_decl} +*) +external model_get_num_consts : context -> model -> int + = "camlidl_z3_Z3_model_get_num_consts" + +(** + Summary: \[ [ model_get_const_decl c m i ] \] + Return the i-th constant in the given model. + + - {b Precondition}: i < model_get_num_consts c m + + - {b See also}: {!model_eval} +*) +external model_get_const_decl : context -> model -> int -> func_decl + = "camlidl_z3_Z3_model_get_const_decl" + +(** + Summary: Return the number of function interpretations in the given model. + + A function interpretation is represented as a finite map and an 'else' value. + Each entry in the finite map represents the value of a function given a set of arguments. +*) +external model_get_num_funcs : context -> model -> int + = "camlidl_z3_Z3_model_get_num_funcs" + +(** + Summary: \[ [ model_get_func_decl c m i ] \] + Return the declaration of the i-th function in the given model. + + - {b Precondition}: i < model_get_num_funcs c m + + - {b See also}: {!model_get_num_funcs} +*) +external model_get_func_decl : context -> model -> int -> func_decl + = "camlidl_z3_Z3_model_get_func_decl" + +(** + Summary: Return the number of uninterpreted sorts that [m] assigs an interpretation to. + + Z3 also provides an intepretation for uninterpreted sorts used in a formua. + The interpretation for a sort [s] is a finite set of distinct values. We say this finite set is + the "universe" of [s]. + + - {b See also}: {!model_get_sort} + - {b See also}: {!model_get_sort_universe} +*) +external model_get_num_sorts : context -> model -> int + = "camlidl_z3_Z3_model_get_num_sorts" + +(** + Summary: Return a uninterpreted sort that [m] assigns an interpretation. + + - {b Precondition}: i < model_get_num_sorts c m + + - {b See also}: {!model_get_num_sorts} + - {b See also}: {!model_get_sort_universe} +*) +external model_get_sort : context -> model -> int -> sort + = "camlidl_z3_Z3_model_get_sort" + +(** + Summary: Return the finite set of distinct values that represent the interpretation for sort [s]. + + - {b See also}: {!model_get_num_sorts} + - {b See also}: {!model_get_sort} +*) +external model_get_sort_universe : context -> model -> sort -> ast_vector + = "camlidl_z3_Z3_model_get_sort_universe" + +(** + Summary: The {e (_ as-array f) } AST node is a construct for assigning interpretations for arrays in Z3. + It is the array such that forall indices [i] we have that {e (select (_ as-array f) i) } is equal to {e (f i) }. + This procedure returns TRUE if the [a] is an [as-array] AST node. + + Z3 current solvers have minimal support for [as_array] nodes. + + - {b See also}: {!get_as_array_func_decl} +*) +external is_as_array : context -> ast -> bool + = "camlidl_z3_Z3_is_as_array" + +(** + Summary: Return the function declaration [f] associated with a {e (_ as_array f) } node. + + - {b See also}: {!is_as_array} +*) +external get_as_array_func_decl : context -> ast -> func_decl + = "camlidl_z3_Z3_get_as_array_func_decl" + +(** + Summary: Return the number of entries in the given function interpretation. + + A function interpretation is represented as a finite map and an 'else' value. + Each entry in the finite map represents the value of a function given a set of arguments. + This procedure return the number of element in the finite map of [f]. +*) +external func_interp_get_num_entries : context -> func_interp -> int + = "camlidl_z3_Z3_func_interp_get_num_entries" + +(** + Summary: Return a "point" of the given function intepretation. It represents the + value of [f] in a particular point. + + - {b Precondition}: i < func_interp_get_num_entries c f + + - {b See also}: {!func_interp_get_num_entries} +*) +external func_interp_get_entry : context -> func_interp -> int -> func_entry + = "camlidl_z3_Z3_func_interp_get_entry" + +(** + Summary: Return the 'else' value of the given function interpretation. + + A function interpretation is represented as a finite map and an 'else' value. + This procedure returns the 'else' value. +*) +external func_interp_get_else : context -> func_interp -> ast + = "camlidl_z3_Z3_func_interp_get_else" + +(** + Summary: Return the arity (number of arguments) of the given function interpretation. +*) +external func_interp_get_arity : context -> func_interp -> int + = "camlidl_z3_Z3_func_interp_get_arity" + +(** + Summary: Return the value of this point. + + A func_entry object represents an element in the finite map used to encode + a function interpretation. + + - {b See also}: {!func_interp_get_entry} +*) +external func_entry_get_value : context -> func_entry -> ast + = "camlidl_z3_Z3_func_entry_get_value" + +(** + Summary: Return the number of arguments in a func_entry object. + + - {b See also}: {!func_interp_get_entry} +*) +external func_entry_get_num_args : context -> func_entry -> int + = "camlidl_z3_Z3_func_entry_get_num_args" + +(** + Summary: Return an argument of a func_entry object. + + - {b Precondition}: i < func_entry_get_num_args c e + + - {b See also}: {!func_interp_get_entry} +*) +external func_entry_get_arg : context -> func_entry -> int -> ast + = "camlidl_z3_Z3_func_entry_get_arg" + +(** + {2 {L Interaction logging.}} +*) +(** + Summary: Log interaction to a file. +*) +external open_log : string -> bool + = "camlidl_z3_Z3_open_log" + +(** + Summary: Append user-defined string to interaction log. + + The interaction log is opened using open_log. + It contains the formulas that are checked using Z3. + You can use this command to append comments, for instance. +*) +external append_log : string -> unit + = "camlidl_z3_Z3_append_log" + +(** + Summary: Close interaction log. +*) +external close_log : unit -> unit + = "camlidl_z3_Z3_close_log" + +(** + Summary: Enable/disable printing warning messages to the console. + + Warnings are printed after passing [true], warning messages are + suppressed after calling this method with [false]. +*) +external toggle_warning_messages : bool -> unit + = "camlidl_z3_Z3_toggle_warning_messages" + +(** + {2 {L String conversion}} +*) +(** + Summary: Select mode for the format used for pretty-printing AST nodes. + + The default mode for pretty printing AST nodes is to produce + SMT-LIB style output where common subexpressions are printed + at each occurrence. The mode is called PRINT_SMTLIB_FULL. + To print shared common subexpressions only once, + use the PRINT_LOW_LEVEL mode. + To print in way that conforms to SMT-LIB standards and uses let + expressions to share common sub-expressions use PRINT_SMTLIB_COMPLIANT. + + - {b See also}: {!ast_to_string} + - {b See also}: {!pattern_to_string} + - {b See also}: {!func_decl_to_string} + +*) +external set_ast_print_mode : context -> ast_print_mode -> unit + = "camlidl_z3_Z3_set_ast_print_mode" + +(** + Summary: Convert the given AST node into a string. + + + + + - {b See also}: {!pattern_to_string} + - {b See also}: {!sort_to_string} +*) +external ast_to_string : context -> ast -> string + = "camlidl_z3_Z3_ast_to_string" + +external pattern_to_string : context -> pattern -> string + = "camlidl_z3_Z3_pattern_to_string" + +external sort_to_string : context -> sort -> string + = "camlidl_z3_Z3_sort_to_string" + +external func_decl_to_string : context -> func_decl -> string + = "camlidl_z3_Z3_func_decl_to_string" + +(** + Summary: Convert the given model into a string. + + + + +*) +external model_to_string : context -> model -> string + = "camlidl_z3_Z3_model_to_string" + +(** + Summary: Convert the given benchmark into SMT-LIB formatted string. + + + + + + @param c - context. + @param name - name of benchmark. The argument is optional. + @param logic - the benchmark logic. + @param status - the status string (sat, unsat, or unknown) + @param attributes - other attributes, such as source, difficulty or category. + @param num_assumptions - number of assumptions. + @param assumptions - auxiliary assumptions. + @param formula - formula to be checked for consistency in conjunction with assumptions. +*) +external benchmark_to_smtlib_string : context -> string -> string -> string -> string -> ast array -> ast -> string + = "camlidl_z3_Z3_benchmark_to_smtlib_string_bytecode" "camlidl_z3_Z3_benchmark_to_smtlib_string" + +(** + {2 {L Parser interface}} +*) +(** + Summary: \[ [ parse_smtlib2_string c str ] \] + Parse the given string using the SMT-LIB2 parser. + + It returns a formula comprising of the conjunction of assertions in the scope + (up to push/pop) at the end of the string. +*) +external parse_smtlib2_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + = "camlidl_z3_Z3_parse_smtlib2_string_bytecode" "camlidl_z3_Z3_parse_smtlib2_string" + +(** + Summary: Similar to {!parse_smtlib2_string}, but reads the benchmark from a file. +*) +external parse_smtlib2_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + = "camlidl_z3_Z3_parse_smtlib2_file_bytecode" "camlidl_z3_Z3_parse_smtlib2_file" + + +(** + Summary: \[ [ parse_smtlib_string_x c str sort_names sorts decl_names decls ] \] + + Parse the given string using the SMT-LIB parser. + + The symbol table of the parser can be initialized using the given sorts and declarations. + The symbols in the arrays [sort_names] and [decl_names] don't need to match the names + of the sorts and declarations in the arrays [sorts] and [decls]. This is an useful feature + since we can use arbitrary names to reference sorts and declarations defined using the API. + + - {b See also}: {!parse_smtlib_file_x} +*) +val parse_smtlib_string_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) + +(** + Summary: Similar to {!parse_smtlib_string_x}, but reads the benchmark from a file. + + - {b See also}: {!parse_smtlib_string_x} +*) +val parse_smtlib_file_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) + +(** + Summary: \[ [ parse_smtlib_string_formula c ... ] \] calls [(parse_smtlib_string c ...)] and returns the single formula produced. + + - {b See also}: {!parse_smtlib_file_formula} + - {b See also}: {!parse_smtlib_string_x} +*) +val parse_smtlib_string_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + +(** + Summary: \[ [ parse_smtlib_file_formula c ... ] \] calls [(parse_smtlib_file c ...)] and returns the single formula produced. + + - {b See also}: {!parse_smtlib_string_formula} + - {b See also}: {!parse_smtlib_file_x} +*) +val parse_smtlib_file_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + +(** + {4 {L Low-level API}} +*) +(** + Summary: \[ [ parse_smtlib_string c str sort_names sorts decl_names decls ] \] + Parse the given string using the SMT-LIB parser. + + The symbol table of the parser can be initialized using the given sorts and declarations. + The symbols in the arrays [sort_names] and [decl_names] don't need to match the names + of the sorts and declarations in the arrays [sorts] and [decls]. This is an useful feature + since we can use arbitrary names to reference sorts and declarations defined using the C API. + + The formulas, assumptions and declarations defined in [str] can be extracted using the functions: + {!get_smtlib_num_formulas}, {!get_smtlib_formula}, {!get_smtlib_num_assumptions}, {!get_smtlib_assumption}, + {!get_smtlib_num_decls}, and {!get_smtlib_decl}. +*) +external parse_smtlib_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit + = "camlidl_z3_Z3_parse_smtlib_string_bytecode" "camlidl_z3_Z3_parse_smtlib_string" + +(** + Summary: Similar to {!parse_smtlib_string}, but reads the benchmark from a file. +*) +external parse_smtlib_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit + = "camlidl_z3_Z3_parse_smtlib_file_bytecode" "camlidl_z3_Z3_parse_smtlib_file" + +(** + Summary: Return the number of SMTLIB formulas parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. +*) +external get_smtlib_num_formulas : context -> int + = "camlidl_z3_Z3_get_smtlib_num_formulas" + +(** + Summary: \[ [ get_smtlib_formula c i ] \] + Return the i-th formula parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + - {b Precondition}: i < get_smtlib_num_formulas c +*) +external get_smtlib_formula : context -> int -> ast + = "camlidl_z3_Z3_get_smtlib_formula" + +(** + Summary: Return the number of SMTLIB assumptions parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. +*) +external get_smtlib_num_assumptions : context -> int + = "camlidl_z3_Z3_get_smtlib_num_assumptions" + +(** + Summary: \[ [ get_smtlib_assumption c i ] \] + Return the i-th assumption parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + - {b Precondition}: i < get_smtlib_num_assumptions c +*) +external get_smtlib_assumption : context -> int -> ast + = "camlidl_z3_Z3_get_smtlib_assumption" + +(** + Summary: Return the number of declarations parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. +*) +external get_smtlib_num_decls : context -> int + = "camlidl_z3_Z3_get_smtlib_num_decls" + +(** + Summary: \[ [ get_smtlib_decl c i ] \] + Return the i-th declaration parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + - {b Precondition}: i < get_smtlib_num_decls c +*) +external get_smtlib_decl : context -> int -> func_decl + = "camlidl_z3_Z3_get_smtlib_decl" + +(** + Summary: Return the number of sorts parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. +*) +external get_smtlib_num_sorts : context -> int + = "camlidl_z3_Z3_get_smtlib_num_sorts" + +(** + Summary: \[ [ get_smtlib_sort c i ] \] + Return the i-th sort parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + - {b Precondition}: i < get_smtlib_num_sorts c +*) +external get_smtlib_sort : context -> int -> sort + = "camlidl_z3_Z3_get_smtlib_sort" + +(* +(** + Summary: \[ [ get_smtlib_error c ] \] + Retrieve that last error message information generated from parsing. +*) +external get_smtlib_error : context -> string + = "camlidl_z3_Z3_get_smtlib_error" + +*) +(** + Summary: \[ [ parse_z3_string c str ] \] + Parse the given string using the Z3 native parser. + + Return the conjunction of asserts made in the input. +*) +external parse_z3_string : context -> string -> ast + = "camlidl_z3_Z3_parse_z3_string" + +(** + Summary: Similar to {!parse_z3_string}, but reads the benchmark from a file. +*) +external parse_z3_file : context -> string -> ast + = "camlidl_z3_Z3_parse_z3_file" + +(** + {2 {L Error Handling}} +*) +(** + Summary: Set an error. +*) +external set_error : context -> error_code -> unit + = "camlidl_z3_Z3_set_error" + +(* +(** + Summary: Return a string describing the given error code. +*) +external get_error_msg_ex : context -> error_code -> string + = "camlidl_z3_Z3_get_error_msg_ex" + +*) + +(** + Summary: Return a string describing the given error code. +*) +val get_error_msg: context -> error_code -> string + +(** + {2 {L Miscellaneous}} +*) +(** + Summary: Return Z3 version number information. +*) +external get_version : unit -> int * int * int * int + = "camlidl_z3_Z3_get_version" + +(** + {2 {L Fixedpoint facilities}} +*) +(** + Summary: Create a new fixedpoint context. + + + +*) +external mk_fixedpoint : context -> fixedpoint + = "camlidl_z3_Z3_mk_fixedpoint" + +(** + Summary: Add a universal Horn clause as a named rule. + The [horn_rule] should be of the form: + + {v + horn_rule ::= (forall (bound-vars) horn_rule) + | (=> atoms horn_rule) + | atom + v} +*) +external fixedpoint_add_rule : context -> fixedpoint -> ast -> symbol -> unit + = "camlidl_z3_Z3_fixedpoint_add_rule" + +(** + Summary: Add a Database fact. + + @param c - context + @param d - fixed point context + @param r - relation signature for the row. + @param num_args - number of columns for the given row. + @param args - array of the row elements. + + The number of arguments [num_args] should be equal to the number + of sorts in the domain of [r]. Each sort in the domain should be an integral + (bit-vector, Boolean or or finite domain sort). + + The call has the same effect as adding a rule where is applied to the arguments. + +*) +external fixedpoint_add_fact : context -> fixedpoint -> func_decl -> int array -> unit + = "camlidl_z3_Z3_fixedpoint_add_fact" + +(** + Summary: Assert a constraint to the fixedpoint context. + + The constraints are used as background axioms when the fixedpoint engine uses the PDR mode. + They are ignored for standard Datalog mode. +*) +external fixedpoint_assert : context -> fixedpoint -> ast -> unit + = "camlidl_z3_Z3_fixedpoint_assert" + +(** + Summary: Pose a query against the asserted rules. + + {v + query ::= (exists (bound-vars) query) + | literals + v} + + query returns + - L_FALSE if the query is unsatisfiable. + - L_TRUE if the query is satisfiable. Obtain the answer by calling {!fixedpoint_get_answer}. + - L_UNDEF if the query was interrupted, timed out or otherwise failed. + +*) +external fixedpoint_query : context -> fixedpoint -> ast -> lbool + = "camlidl_z3_Z3_fixedpoint_query" + +(** + Summary: Pose multiple queries against the asserted rules. + + The queries are encoded as relations (function declarations). + + query returns + - L_FALSE if the query is unsatisfiable. + - L_TRUE if the query is satisfiable. Obtain the answer by calling {!fixedpoint_get_answer}. + - L_UNDEF if the query was interrupted, timed out or otherwise failed. + +*) +external fixedpoint_query_relations : context -> fixedpoint -> func_decl array -> lbool + = "camlidl_z3_Z3_fixedpoint_query_relations" + +(** + Summary: Retrieve a formula that encodes satisfying answers to the query. + + + When used in Datalog mode, the returned answer is a disjunction of conjuncts. + Each conjunct encodes values of the bound variables of the query that are satisfied. + In PDR mode, the returned answer is a single conjunction. + + The previous call to fixedpoint_query must have returned L_TRUE. +*) +external fixedpoint_get_answer : context -> fixedpoint -> ast + = "camlidl_z3_Z3_fixedpoint_get_answer" + +(** + Summary: Retrieve a string that describes the last status returned by {!fixedpoint_query}. + + Use this method when {!fixedpoint_query} returns L_UNDEF. +*) +external fixedpoint_get_reason_unknown : context -> fixedpoint -> string + = "camlidl_z3_Z3_fixedpoint_get_reason_unknown" + +(** + Summary: Update a named rule. + A rule with the same name must have been previously created. +*) +external fixedpoint_update_rule : context -> fixedpoint -> ast -> symbol -> unit + = "camlidl_z3_Z3_fixedpoint_update_rule" + +(** + Summary: Query the PDR engine for the maximal levels properties are known about predicate. + + This call retrieves the maximal number of relevant unfoldings + of [pred] with respect to the current exploration state. + Note: this functionality is PDR specific. +*) +external fixedpoint_get_num_levels : context -> fixedpoint -> func_decl -> int + = "camlidl_z3_Z3_fixedpoint_get_num_levels" + +(** + Retrieve the current cover of [pred] up to [level] unfoldings. + Return just the delta that is known at [level]. To + obtain the full set of properties of [pred] one should query + at [level+1] , [level+2] etc, and include [level=-1]. + + Note: this functionality is PDR specific. +*) +external fixedpoint_get_cover_delta : context -> fixedpoint -> int -> func_decl -> ast + = "camlidl_z3_Z3_fixedpoint_get_cover_delta" + +(** + Summary: Add property about the predicate [pred]. + Add a property of predicate [pred] at [level]. + It gets pushed forward when possible. + + Note: level = -1 is treated as the fixedpoint. So passing -1 for the [level] + means that the property is true of the fixed-point unfolding with respect to [pred]. + + Note: this functionality is PDR specific. +*) +external fixedpoint_add_cover : context -> fixedpoint -> int -> func_decl -> ast -> unit + = "camlidl_z3_Z3_fixedpoint_add_cover" + +(** + Summary: Retrieve statistics information from the last call to {!fixedpoint_query}. +*) +external fixedpoint_get_statistics : context -> fixedpoint -> stats + = "camlidl_z3_Z3_fixedpoint_get_statistics" + +(** + Summary: Register relation as Fixedpoint defined. + Fixedpoint defined relations have least-fixedpoint semantics. + For example, the relation is empty if it does not occur + in a head or a fact. +*) +external fixedpoint_register_relation : context -> fixedpoint -> func_decl -> unit + = "camlidl_z3_Z3_fixedpoint_register_relation" + +(** + Summary: Configure the predicate representation. + + It sets the predicate to use a set of domains given by the list of symbols. + The domains given by the list of symbols must belong to a set + of built-in domains. +*) +external fixedpoint_set_predicate_representation : context -> fixedpoint -> func_decl -> symbol array -> unit + = "camlidl_z3_Z3_fixedpoint_set_predicate_representation" + +(** + Summary: Simplify rules into a set of new rules that are returned. + The simplification routines apply inlining, quantifier elimination, and other + algebraic simplifications. +*) +external fixedpoint_simplify_rules : context -> fixedpoint -> ast array -> func_decl array -> ast_vector + = "camlidl_z3_Z3_fixedpoint_simplify_rules" + +(** + Summary: Set parameters on fixedpoint context. +*) +external fixedpoint_set_params : context -> fixedpoint -> params -> unit + = "camlidl_z3_Z3_fixedpoint_set_params" + +(** + Summary: Return a string describing all fixedpoint available parameters. +*) +external fixedpoint_get_help : context -> fixedpoint -> string + = "camlidl_z3_Z3_fixedpoint_get_help" + +(** + Summary: Return the parameter description set for the given fixedpoint object. +*) +external fixedpoint_get_param_descrs : context -> fixedpoint -> param_descrs + = "camlidl_z3_Z3_fixedpoint_get_param_descrs" + +(** + Summary: Print the current rules and background axioms as a string. + @param c - context. + @param f - fixedpoint context. + @param num_queries - number of additional queries to print. + @param queries - additional queries. +*) +external fixedpoint_to_string : context -> fixedpoint -> ast array -> string + = "camlidl_z3_Z3_fixedpoint_to_string" + +(** + Summary: Create a backtracking point. + + The fixedpoint solver contains a set of rules, added facts and assertions. + The set of rules, facts and assertions are restored upon calling {!fixedpoint_pop}. + + - {b See also}: {!fixedpoint_pop} +*) +external fixedpoint_push : context -> fixedpoint -> unit + = "camlidl_z3_Z3_fixedpoint_push" + +(** + Summary: Backtrack one backtracking point. + + - {b See also}: {!fixedpoing_push} + + - {b Precondition}: The number of calls to pop cannot exceed calls to push. +*) +external fixedpoint_pop : context -> fixedpoint -> unit + = "camlidl_z3_Z3_fixedpoint_pop" + +(** + {2 {L AST vectors}} +*) +(** + Summary: Return an empty AST vector. + + + +*) +external mk_ast_vector : context -> ast_vector + = "camlidl_z3_Z3_mk_ast_vector" + +(** + Summary: Return the size of the given AST vector. +*) +external ast_vector_size : context -> ast_vector -> int + = "camlidl_z3_Z3_ast_vector_size" + +(** + Summary: Return the AST at position [i] in the AST vector [v]. + + - {b Precondition}: i < ast_vector_size c v +*) +external ast_vector_get : context -> ast_vector -> int -> ast + = "camlidl_z3_Z3_ast_vector_get" + +(** + Summary: Update position [i] of the AST vector [v] with the AST [a]. + + - {b Precondition}: i < ast_vector_size c v +*) +external ast_vector_set : context -> ast_vector -> int -> ast -> unit + = "camlidl_z3_Z3_ast_vector_set" + +(** + Summary: Resize the AST vector [v]. +*) +external ast_vector_resize : context -> ast_vector -> int -> unit + = "camlidl_z3_Z3_ast_vector_resize" + +(** + Summary: Add the AST [a] in the end of the AST vector [v]. The size of [v] is increased by one. +*) +external ast_vector_push : context -> ast_vector -> ast -> unit + = "camlidl_z3_Z3_ast_vector_push" + +(** + Summary: Translate the AST vector [v] from context [s] into an AST vector in context [t]. +*) +external ast_vector_translate : context -> ast_vector -> context -> ast_vector + = "camlidl_z3_Z3_ast_vector_translate" + +(** + Summary: Convert AST vector into a string. +*) +external ast_vector_to_string : context -> ast_vector -> string + = "camlidl_z3_Z3_ast_vector_to_string" + +(** + {2 {L AST maps}} +*) +(** + Summary: Return an empty mapping from AST to AST + + + +*) +external mk_ast_map : context -> ast_map + = "camlidl_z3_Z3_mk_ast_map" + +(** + Summary: Return true if the map [m] contains the AST key [k]. +*) +external ast_map_contains : context -> ast_map -> ast -> bool + = "camlidl_z3_Z3_ast_map_contains" + +(** + Summary: Return the value associated with the key [k]. + + The procedure invokes the error handler if [k] is not in the map. +*) +external ast_map_find : context -> ast_map -> ast -> ast + = "camlidl_z3_Z3_ast_map_find" + +(** + Summary: Store/Replace a new key, value pair in the given map. +*) +external ast_map_insert : context -> ast_map -> ast -> ast -> unit + = "camlidl_z3_Z3_ast_map_insert" + +(** + Summary: Erase a key from the map. +*) +external ast_map_erase : context -> ast_map -> ast -> unit + = "camlidl_z3_Z3_ast_map_erase" + +(** + Summary: Remove all keys from the given map. +*) +external ast_map_reset : context -> ast_map -> unit + = "camlidl_z3_Z3_ast_map_reset" + +(** + Summary: Return the size of the given map. +*) +external ast_map_size : context -> ast_map -> int + = "camlidl_z3_Z3_ast_map_size" + +(** + Summary: Return the keys stored in the given map. +*) +external ast_map_keys : context -> ast_map -> ast_vector + = "camlidl_z3_Z3_ast_map_keys" + +(** + Summary: Convert the given map into a string. +*) +external ast_map_to_string : context -> ast_map -> string + = "camlidl_z3_Z3_ast_map_to_string" + +(** + {2 {L Goals}} +*) +(** + Summary: Create a goal (aka problem). A goal is essentially a set + of formulas, that can be solved and/or transformed using + tactics and solvers. + + If models == true, then model generation is enabled for the new goal. + + If unsat_cores == true, then unsat core generation is enabled for the new goal. + + If proofs == true, then proof generation is enabled for the new goal. Remark, the + Z3 context c must have been created with proof generation support. + + + +*) +external mk_goal : context -> bool -> bool -> bool -> goal + = "camlidl_z3_Z3_mk_goal" + +(** + Summary: Return the "precision" of the given goal. Goals can be transformed using over and under approximations. + A under approximation is applied when the objective is to find a model for a given goal. + An over approximation is applied when the objective is to find a proof for a given goal. +*) +external goal_precision : context -> goal -> goal_prec + = "camlidl_z3_Z3_goal_precision" + +(** + Summary: Add a new formula [a] to the given goal. +*) +external goal_assert : context -> goal -> ast -> unit + = "camlidl_z3_Z3_goal_assert" + +(** + Summary: Return true if the given goal contains the formula [false]. +*) +external goal_inconsistent : context -> goal -> bool + = "camlidl_z3_Z3_goal_inconsistent" + +(** + Summary: Return the depth of the given goal. It tracks how many transformations were applied to it. +*) +external goal_depth : context -> goal -> int + = "camlidl_z3_Z3_goal_depth" + +(** + Summary: Erase all formulas from the given goal. +*) +external goal_reset : context -> goal -> unit + = "camlidl_z3_Z3_goal_reset" + +(** + Summary: Return the number of formulas in the given goal. +*) +external goal_size : context -> goal -> int + = "camlidl_z3_Z3_goal_size" + +(** + Summary: Return a formula from the given goal. + + - {b Precondition}: idx < goal_size c g +*) +external goal_formula : context -> goal -> int -> ast + = "camlidl_z3_Z3_goal_formula" + +(** + Summary: Return the number of formulas, subformulas and terms in the given goal. +*) +external goal_num_exprs : context -> goal -> int + = "camlidl_z3_Z3_goal_num_exprs" + +(** + Summary: Return true if the goal is empty, and it is precise or the product of a under approximation. +*) +external goal_is_decided_sat : context -> goal -> bool + = "camlidl_z3_Z3_goal_is_decided_sat" + +(** + Summary: Return true if the goal contains false, and it is precise or the product of an over approximation. +*) +external goal_is_decided_unsat : context -> goal -> bool + = "camlidl_z3_Z3_goal_is_decided_unsat" + +(** + Summary: Copy a goal [g] from the context [source] to a the context [target]. +*) +external goal_translate : context -> goal -> context -> goal + = "camlidl_z3_Z3_goal_translate" + +(** + Summary: Convert a goal into a string. +*) +external goal_to_string : context -> goal -> string + = "camlidl_z3_Z3_goal_to_string" + +(** + {2 {L Tactics and Probes}} +*) +(** + Summary: Return a tactic associated with the given name. + The complete list of tactics may be obtained using the procedures {!get_num_tactics} and {!get_tactic_name}. + It may also be obtained using the command {e (help-tactics) } in the SMT 2.0 front-end. + + Tactics are the basic building block for creating custom solvers for specific problem domains. +*) +external mk_tactic : context -> string -> tactic + = "camlidl_z3_Z3_mk_tactic" + +(** + Summary: Return a probe associated with the given name. + The complete list of probes may be obtained using the procedures {!get_num_probes} and {!get_probe_name}. + It may also be obtained using the command {e (help-tactics) } in the SMT 2.0 front-end. + + Probes are used to inspect a goal (aka problem) and collect information that may be used to decide + which solver and/or preprocessing step will be used. +*) +external mk_probe : context -> string -> probe + = "camlidl_z3_Z3_mk_probe" + +(** + Summary: Return a tactic that applies [t1] to a given goal and [t2] + to every subgoal produced by t1. +*) +external tactic_and_then : context -> tactic -> tactic -> tactic + = "camlidl_z3_Z3_tactic_and_then" + +(** + Summary: Return a tactic that first applies [t1] to a given goal, + if it fails then returns the result of [t2] applied to the given goal. +*) +external tactic_or_else : context -> tactic -> tactic -> tactic + = "camlidl_z3_Z3_tactic_or_else" + +(** + Summary: Return a tactic that applies the given tactics in parallel. +*) +external tactic_par_or : context -> tactic array -> tactic + = "camlidl_z3_Z3_tactic_par_or" + +(** + Summary: Return a tactic that applies [t1] to a given goal and then [t2] + to every subgoal produced by t1. The subgoals are processed in parallel. +*) +external tactic_par_and_then : context -> tactic -> tactic -> tactic + = "camlidl_z3_Z3_tactic_par_and_then" + +(** + Summary: Return a tactic that applies [t] to a given goal for [ms] milliseconds. + If [t] does not terminate in [ms] milliseconds, then it fails. +*) +external tactic_try_for : context -> tactic -> int -> tactic + = "camlidl_z3_Z3_tactic_try_for" + +(** + Summary: Return a tactic that applies [t] to a given goal is the probe [p] evaluates to true. + If [p] evaluates to false, then the new tactic behaves like the skip tactic. +*) +external tactic_when : context -> probe -> tactic -> tactic + = "camlidl_z3_Z3_tactic_when" + +(** + Summary: Return a tactic that applies [t1] to a given goal if the probe [p] evaluates to true, + and [t2] if [p] evaluates to false. +*) +external tactic_cond : context -> probe -> tactic -> tactic -> tactic + = "camlidl_z3_Z3_tactic_cond" + +(** + Summary: Return a tactic that keeps applying [t] until the goal is not modified anymore or the maximum + number of iterations [max] is reached. +*) +external tactic_repeat : context -> tactic -> int -> tactic + = "camlidl_z3_Z3_tactic_repeat" + +(** + Summary: Return a tactic that just return the given goal. +*) +external tactic_skip : context -> tactic + = "camlidl_z3_Z3_tactic_skip" + +(** + Summary: Return a tactic that always fails. +*) +external tactic_fail : context -> tactic + = "camlidl_z3_Z3_tactic_fail" + +(** + Summary: Return a tactic that fails if the probe [p] evaluates to false. +*) +external tactic_fail_if : context -> probe -> tactic + = "camlidl_z3_Z3_tactic_fail_if" + +(** + Summary: Return a tactic that fails if the goal is not trivially satisfiable (i.e., empty) or + trivially unsatisfiable (i.e., contains false). +*) +external tactic_fail_if_not_decided : context -> tactic + = "camlidl_z3_Z3_tactic_fail_if_not_decided" + +(** + Summary: Return a tactic that applies [t] using the given set of parameters. +*) +external tactic_using_params : context -> tactic -> params -> tactic + = "camlidl_z3_Z3_tactic_using_params" + +(** + Summary: Return a probe that always evaluates to val. +*) +external probe_const : context -> float -> probe + = "camlidl_z3_Z3_probe_const" + +(** + Summary: Return a probe that evaluates to "true" when the value returned by [p1] is less than the value returned by [p2]. + + - {b Remarks}: For probes, "true" is any value different from 0.0. +*) +external probe_lt : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_lt" + +(** + Summary: Return a probe that evaluates to "true" when the value returned by [p1] is greater than the value returned by [p2]. + + - {b Remarks}: For probes, "true" is any value different from 0.0. +*) +external probe_gt : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_gt" + +(** + Summary: Return a probe that evaluates to "true" when the value returned by [p1] is less than or equal to the value returned by [p2]. + + - {b Remarks}: For probes, "true" is any value different from 0.0. +*) +external probe_le : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_le" + +(** + Summary: Return a probe that evaluates to "true" when the value returned by [p1] is greater than or equal to the value returned by [p2]. + + - {b Remarks}: For probes, "true" is any value different from 0.0. +*) +external probe_ge : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_ge" + +(** + Summary: Return a probe that evaluates to "true" when the value returned by [p1] is equal to the value returned by [p2]. + + - {b Remarks}: For probes, "true" is any value different from 0.0. +*) +external probe_eq : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_eq" + +(** + Summary: Return a probe that evaluates to "true" when [p1] and [p2] evaluates to true. + + - {b Remarks}: For probes, "true" is any value different from 0.0. +*) +external probe_and : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_and" + +(** + Summary: Return a probe that evaluates to "true" when [p1] or [p2] evaluates to true. + + - {b Remarks}: For probes, "true" is any value different from 0.0. +*) +external probe_or : context -> probe -> probe -> probe + = "camlidl_z3_Z3_probe_or" + +(** + Summary: Return a probe that evaluates to "true" when [p] does not evaluate to true. + + - {b Remarks}: For probes, "true" is any value different from 0.0. +*) +external probe_not : context -> probe -> probe + = "camlidl_z3_Z3_probe_not" + +(** + Summary: Return the number of builtin tactics available in Z3. +*) +external get_num_tactics : context -> int + = "camlidl_z3_Z3_get_num_tactics" + +(** + Summary: Return the name of the idx tactic. + + - {b Precondition}: i < get_num_tactics c +*) +external get_tactic_name : context -> int -> string + = "camlidl_z3_Z3_get_tactic_name" + +(** + Summary: Return the number of builtin probes available in Z3. +*) +external get_num_probes : context -> int + = "camlidl_z3_Z3_get_num_probes" + +(** + Summary: Return the name of the i probe. + + - {b Precondition}: i < get_num_probes c +*) +external get_probe_name : context -> int -> string + = "camlidl_z3_Z3_get_probe_name" + +(** + Summary: Return a string containing a description of parameters accepted by the given tactic. +*) +external tactic_get_help : context -> tactic -> string + = "camlidl_z3_Z3_tactic_get_help" + +(** + Summary: Return the parameter description set for the given tactic object. +*) +external tactic_get_param_descrs : context -> tactic -> param_descrs + = "camlidl_z3_Z3_tactic_get_param_descrs" + +(** + Summary: Return a string containing a description of the tactic with the given name. +*) +external tactic_get_descr : context -> string -> string + = "camlidl_z3_Z3_tactic_get_descr" + +(** + Summary: Return a string containing a description of the probe with the given name. +*) +external probe_get_descr : context -> string -> string + = "camlidl_z3_Z3_probe_get_descr" + +(** + Summary: Execute the probe over the goal. The probe always produce a double value. + "Boolean" probes return 0.0 for false, and a value different from 0.0 for true. +*) +external probe_apply : context -> probe -> goal -> float + = "camlidl_z3_Z3_probe_apply" + +(** + Summary: Apply tactic [t] to the goal [g]. +*) +external tactic_apply : context -> tactic -> goal -> apply_result + = "camlidl_z3_Z3_tactic_apply" + +(** + Summary: Apply tactic [t] to the goal [g] using the parameter set [p]. +*) +external tactic_apply_ex : context -> tactic -> goal -> params -> apply_result + = "camlidl_z3_Z3_tactic_apply_ex" + +(** + Summary: Convert the [apply_result] object returned by {!tactic_apply} into a string. +*) +external apply_result_to_string : context -> apply_result -> string + = "camlidl_z3_Z3_apply_result_to_string" + +(** + Summary: Return the number of subgoals in the [apply_result] object returned by {!tactic_apply}. +*) +external apply_result_get_num_subgoals : context -> apply_result -> int + = "camlidl_z3_Z3_apply_result_get_num_subgoals" + +(** + Summary: Return one of the subgoals in the [apply_result] object returned by {!tactic_apply}. + + - {b Precondition}: i < apply_result_get_num_subgoals c r +*) +external apply_result_get_subgoal : context -> apply_result -> int -> goal + = "camlidl_z3_Z3_apply_result_get_subgoal" + +(** + Summary: Convert a model for the subgoal [apply_result_get_subgoal(c], r, i) into a model for the original goal [g]. + Where [g] is the goal used to create [r] using [tactic_apply(c], t, g). +*) +external apply_result_convert_model : context -> apply_result -> int -> model -> model + = "camlidl_z3_Z3_apply_result_convert_model" + +(** + {2 {L Solvers}} +*) +(** + Summary: Create a new (incremental) solver. This solver also uses a + set of builtin tactics for handling the first check-sat command, and + check-sat commands that take more than a given number of milliseconds to be solved. + + + +*) +external mk_solver : context -> solver + = "camlidl_z3_Z3_mk_solver" + +(** + Summary: Create a new (incremental) solver. +*) +external mk_simple_solver : context -> solver + = "camlidl_z3_Z3_mk_simple_solver" + +(** + Summary: Create a new solver customized for the given logic. + It behaves like {!mk_solver} if the logic is unknown or unsupported. + + + +*) +external mk_solver_for_logic : context -> symbol -> solver + = "camlidl_z3_Z3_mk_solver_for_logic" + +(** + Summary: Create a new solver that is implemented using the given tactic. + The solver supports the commands {!solver_push} and {!solver_pop}, but it + will always solve each {!solver_check} from scratch. +*) +external mk_solver_from_tactic : context -> tactic -> solver + = "camlidl_z3_Z3_mk_solver_from_tactic" + +(** + Summary: Return a string describing all solver available parameters. +*) +external solver_get_help : context -> solver -> string + = "camlidl_z3_Z3_solver_get_help" + +(** + Summary: Return the parameter description set for the given solver object. +*) +external solver_get_param_descrs : context -> solver -> param_descrs + = "camlidl_z3_Z3_solver_get_param_descrs" + +(** + Summary: Set the given solver using the given parameters. +*) +external solver_set_params : context -> solver -> params -> unit + = "camlidl_z3_Z3_solver_set_params" + +(** + Summary: Create a backtracking point. + + The solver contains a stack of assertions. + + - {b See also}: {!solver_pop} +*) +external solver_push : context -> solver -> unit + = "camlidl_z3_Z3_solver_push" + +(** + Summary: Backtrack [n] backtracking points. + + - {b See also}: {!solver_push} + + - {b Precondition}: n <= solver_get_num_scopes c s +*) +external solver_pop : context -> solver -> int -> unit + = "camlidl_z3_Z3_solver_pop" + +(** + Summary: Remove all assertions from the solver. +*) +external solver_reset : context -> solver -> unit + = "camlidl_z3_Z3_solver_reset" + +(** + Summary: Return the number of backtracking points. + + - {b See also}: {!solver_push} + - {b See also}: {!solver_pop} +*) +external solver_get_num_scopes : context -> solver -> int + = "camlidl_z3_Z3_solver_get_num_scopes" + +(** + Summary: Assert a constraint into the solver. + + The functions {!solver_check} and {!solver_check_assumptions} should be + used to check whether the logical context is consistent or not. +*) +external solver_assert : context -> solver -> ast -> unit + = "camlidl_z3_Z3_solver_assert" + +(** + Summary: Return the set of asserted formulas as a goal object. +*) +external solver_get_assertions : context -> solver -> ast_vector + = "camlidl_z3_Z3_solver_get_assertions" + +(** + Summary: Check whether the assertions in a given solver are consistent or not. + + The function {!solver_get_model} retrieves a model if the + assertions are not unsatisfiable (i.e., the result is not \c + L_FALSE) and model construction is enabled. + + The function {!solver_get_proof} retrieves a proof if proof + generation was enabled when the context was created, and the + assertions are unsatisfiable (i.e., the result is [L_FALSE)]. +*) +external solver_check : context -> solver -> lbool + = "camlidl_z3_Z3_solver_check" + +(** + Summary: Check whether the assertions in the given solver and + optional assumptions are consistent or not. + + The function {!solver_get_unsat_core} retrieves the subset of the + assumptions used in the unsatisfiability proof produced by Z3. + + - {b See also}: {!solver_check} +*) +external solver_check_assumptions : context -> solver -> ast array -> lbool + = "camlidl_z3_Z3_solver_check_assumptions" + +(** + Summary: Retrieve the model for the last {!solver_check} or {!solver_check_assumptions} + + The error handler is invoked if a model is not available because + the commands above were not invoked for the given solver, or if the result was [L_FALSE]. +*) +external solver_get_model : context -> solver -> model + = "camlidl_z3_Z3_solver_get_model" + +(** + Summary: Retrieve the proof for the last {!solver_check} or {!solver_check_assumptions} + + The error handler is invoked if proof generation is not enabled, + or if the commands above were not invoked for the given solver, + or if the result was different from [L_FALSE]. +*) +external solver_get_proof : context -> solver -> ast + = "camlidl_z3_Z3_solver_get_proof" + +(** + Summary: Retrieve the unsat core for the last {!solver_check_assumptions} + The unsat core is a subset of the assumptions [a]. +*) +external solver_get_unsat_core : context -> solver -> ast_vector + = "camlidl_z3_Z3_solver_get_unsat_core" + +(** + Summary: Return a brief justification for an "unknown" result (i.e., L_UNDEF) for + the commands {!solver_check} and {!solver_check_assumptions} +*) +external solver_get_reason_unknown : context -> solver -> string + = "camlidl_z3_Z3_solver_get_reason_unknown" + +(** + Summary: Return statistics for the given solver. + + +*) +external solver_get_statistics : context -> solver -> stats + = "camlidl_z3_Z3_solver_get_statistics" + +(** + Summary: Convert a solver into a string. +*) +external solver_to_string : context -> solver -> string + = "camlidl_z3_Z3_solver_to_string" + +(** + {2 {L Statistics}} +*) + +type stat_datum = Stat_int of int | Stat_float of float +type stats_refined = (string, stat_datum) Hashtbl.t + + +(** + Summary: [stats_refine c s] is the refined stats of [s]. +*) +val stats_refine : context -> stats -> stats_refined + +(** + Summary: Convert a statistics into a string. +*) +external stats_to_string : context -> stats -> string + = "camlidl_z3_Z3_stats_to_string" + +(** + {4 {L Low-level API}} +*) +(** + Summary: Return the number of statistical data in [s]. +*) +external stats_size : context -> stats -> int + = "camlidl_z3_Z3_stats_size" + +(** + Summary: Return the key (a string) for a particular statistical data. + + - {b Precondition}: idx < stats_size c s +*) +external stats_get_key : context -> stats -> int -> string + = "camlidl_z3_Z3_stats_get_key" + +(** + Summary: Return TRUE if the given statistical data is a unsigned int integer. + + - {b Precondition}: idx < stats_size c s +*) +external stats_is_uint : context -> stats -> int -> bool + = "camlidl_z3_Z3_stats_is_uint" + +(** + Summary: Return TRUE if the given statistical data is a double. + + - {b Precondition}: idx < stats_size c s +*) +external stats_is_double : context -> stats -> int -> bool + = "camlidl_z3_Z3_stats_is_double" + +(** + Summary: Return the unsigned int value of the given statistical data. + + - {b Precondition}: idx < stats_size c s && stats_is_uint c s +*) +external stats_get_uint_value : context -> stats -> int -> int + = "camlidl_z3_Z3_stats_get_uint_value" + +(** + Summary: Return the double value of the given statistical data. + + - {b Precondition}: idx < stats_size c s && stats_is_double c s +*) +external stats_get_double_value : context -> stats -> int -> float + = "camlidl_z3_Z3_stats_get_double_value" + + +(** + {2 {L Legacy V3 API}} +*) + +module V3 : sig +(** + {2 {L Legacy V3 API}} +*) + +(* File generated from z3.idl *) + +type symbol +and literals +and theory +and config +and context +and sort +and func_decl +and ast +and app +and pattern +and model +and constructor +and constructor_list + +and lbool = + | L_FALSE + | L_UNDEF + | L_TRUE + +and symbol_kind = + | INT_SYMBOL + | STRING_SYMBOL + +and parameter_kind = + | PARAMETER_INT + | PARAMETER_DOUBLE + | PARAMETER_RATIONAL + | PARAMETER_SYMBOL + | PARAMETER_SORT + | PARAMETER_AST + | PARAMETER_FUNC_DECL + +and sort_kind = + | UNINTERPRETED_SORT + | BOOL_SORT + | INT_SORT + | REAL_SORT + | BV_SORT + | ARRAY_SORT + | DATATYPE_SORT + | RELATION_SORT + | FINITE_DOMAIN_SORT + | UNKNOWN_SORT + +and ast_kind = + | NUMERAL_AST + | APP_AST + | VAR_AST + | QUANTIFIER_AST + | SORT_AST + | FUNC_DECL_AST + | UNKNOWN_AST + +and decl_kind = + | OP_TRUE + | OP_FALSE + | OP_EQ + | OP_DISTINCT + | OP_ITE + | OP_AND + | OP_OR + | OP_IFF + | OP_XOR + | OP_NOT + | OP_IMPLIES + | OP_OEQ + | OP_ANUM + | OP_AGNUM + | OP_LE + | OP_GE + | OP_LT + | OP_GT + | OP_ADD + | OP_SUB + | OP_UMINUS + | OP_MUL + | OP_DIV + | OP_IDIV + | OP_REM + | OP_MOD + | OP_TO_REAL + | OP_TO_INT + | OP_IS_INT + | OP_POWER + | OP_STORE + | OP_SELECT + | OP_CONST_ARRAY + | OP_ARRAY_MAP + | OP_ARRAY_DEFAULT + | OP_SET_UNION + | OP_SET_INTERSECT + | OP_SET_DIFFERENCE + | OP_SET_COMPLEMENT + | OP_SET_SUBSET + | OP_AS_ARRAY + | OP_BNUM + | OP_BIT1 + | OP_BIT0 + | OP_BNEG + | OP_BADD + | OP_BSUB + | OP_BMUL + | OP_BSDIV + | OP_BUDIV + | OP_BSREM + | OP_BUREM + | OP_BSMOD + | OP_BSDIV0 + | OP_BUDIV0 + | OP_BSREM0 + | OP_BUREM0 + | OP_BSMOD0 + | OP_ULEQ + | OP_SLEQ + | OP_UGEQ + | OP_SGEQ + | OP_ULT + | OP_SLT + | OP_UGT + | OP_SGT + | OP_BAND + | OP_BOR + | OP_BNOT + | OP_BXOR + | OP_BNAND + | OP_BNOR + | OP_BXNOR + | OP_CONCAT + | OP_SIGN_EXT + | OP_ZERO_EXT + | OP_EXTRACT + | OP_REPEAT + | OP_BREDOR + | OP_BREDAND + | OP_BCOMP + | OP_BSHL + | OP_BLSHR + | OP_BASHR + | OP_ROTATE_LEFT + | OP_ROTATE_RIGHT + | OP_EXT_ROTATE_LEFT + | OP_EXT_ROTATE_RIGHT + | OP_INT2BV + | OP_BV2INT + | OP_CARRY + | OP_XOR3 + | OP_PR_UNDEF + | OP_PR_TRUE + | OP_PR_ASSERTED + | OP_PR_GOAL + | OP_PR_MODUS_PONENS + | OP_PR_REFLEXIVITY + | OP_PR_SYMMETRY + | OP_PR_TRANSITIVITY + | OP_PR_TRANSITIVITY_STAR + | OP_PR_MONOTONICITY + | OP_PR_QUANT_INTRO + | OP_PR_DISTRIBUTIVITY + | OP_PR_AND_ELIM + | OP_PR_NOT_OR_ELIM + | OP_PR_REWRITE + | OP_PR_REWRITE_STAR + | OP_PR_PULL_QUANT + | OP_PR_PULL_QUANT_STAR + | OP_PR_PUSH_QUANT + | OP_PR_ELIM_UNUSED_VARS + | OP_PR_DER + | OP_PR_QUANT_INST + | OP_PR_HYPOTHESIS + | OP_PR_LEMMA + | OP_PR_UNIT_RESOLUTION + | OP_PR_IFF_TRUE + | OP_PR_IFF_FALSE + | OP_PR_COMMUTATIVITY + | OP_PR_DEF_AXIOM + | OP_PR_DEF_INTRO + | OP_PR_APPLY_DEF + | OP_PR_IFF_OEQ + | OP_PR_NNF_POS + | OP_PR_NNF_NEG + | OP_PR_NNF_STAR + | OP_PR_CNF_STAR + | OP_PR_SKOLEMIZE + | OP_PR_MODUS_PONENS_OEQ + | OP_PR_TH_LEMMA + | OP_RA_STORE + | OP_RA_EMPTY + | OP_RA_IS_EMPTY + | OP_RA_JOIN + | OP_RA_UNION + | OP_RA_WIDEN + | OP_RA_PROJECT + | OP_RA_FILTER + | OP_RA_NEGATION_FILTER + | OP_RA_RENAME + | OP_RA_COMPLEMENT + | OP_RA_SELECT + | OP_RA_CLONE + | OP_FD_LT + | OP_LABEL + | OP_LABEL_LIT + | OP_DT_CONSTRUCTOR + | OP_DT_RECOGNISER + | OP_DT_ACCESSOR + | OP_UNINTERPRETED + +and param_kind = + | PK_UINT + | PK_BOOL + | PK_DOUBLE + | PK_SYMBOL + | PK_STRING + | PK_OTHER + | PK_INVALID + +and search_failure = + | NO_FAILURE + | UNKNOWN + | TIMEOUT + | MEMOUT_WATERMARK + | CANCELED + | NUM_CONFLICTS + | THEORY + | QUANTIFIERS + +and ast_print_mode = + | PRINT_SMTLIB_FULL + | PRINT_LOW_LEVEL + | PRINT_SMTLIB_COMPLIANT + | PRINT_SMTLIB2_COMPLIANT + + +(** + + +*) +(** + {2 {L Types}} + + + Most of the types in the API are abstract. + + + - [context]: manager of all other Z3 objects, global configuration options, etc. + - [symbol]: Lisp-like symbol used to name types, constants, and functions. A symbol can be created using string or integers. + - [ast]: abstract syntax tree node. That is, the data-structure used in Z3 to represent terms, formulas and types. + - [sort]: kind of AST used to represent types. + - [func_decl]: kind of AST used to represent function symbols. + - [app]: kind of AST used to represent function applications. + - [pattern]: kind of AST used to represent pattern and multi-patterns used to guide quantifier instantiation. + + - [params]: parameter set used to configure many components such as: simplifiers, tactics, solvers, etc. + - [model]: model for the constraints asserted into the logical context. + - [func_interp]: interpretation of a function in a model. + - [func_entry]: representation of the value of a [func_interp] at a particular point. + - [fixedpoint]: context for the recursive predicate solver. + - [ast_vector]: vector of [ast] objects. + - [ast_map]: mapping from [ast] to [ast] objects. + - [goal]: set of formulas that can be solved and/or transformed using tactics and solvers. + - [tactic]: basic building block for creating custom solvers for specific problem domains. + - [probe]: function/predicate used to inspect a goal and collect information that may be used to decide which solver and/or preprocessing step will be used. + - [apply_result]: collection of subgoals resulting from applying of a tactic to a goal. + - [solver]: (incremental) solver, possibly specialized by a particular tactic or logic. + - [stats]: statistical data for a solver. +*) +(** + {!lbool} + Lifted Boolean type: [false], [undefined], [true]. +*) +(** + {!symbol_kind} + The different kinds of symbol. + In Z3, a symbol can be represented using integers and strings (See {!get_symbol_kind}). + + - {b See also}: {!mk_int_symbol} + - {b See also}: {!mk_string_symbol} +*) +(** + {!parameter_kind} + The different kinds of parameters that can be associated with function symbols. + - {b See also}: {!get_decl_num_parameters} + - {b See also}: {!get_decl_parameter_kind} + + - PARAMETER_INT is used for integer parameters. + - PARAMETER_DOUBLE is used for double parameters. + - PARAMETER_RATIONAL is used for parameters that are rational numbers. + - PARAMETER_SYMBOL is used for parameters that are symbols. + - PARAMETER_SORT is used for sort parameters. + - PARAMETER_AST is used for expression parameters. + - PARAMETER_FUNC_DECL is used for function declaration parameters. +*) +(** + {!sort_kind} + The different kinds of Z3 types (See {!get_sort_kind}). +*) +(** + {!ast_kind} + The different kinds of Z3 AST (abstract syntax trees). That is, terms, formulas and types. + + - APP_AST: constant and applications + - NUMERAL_AST: numeral constants + - VAR_AST: bound variables + - QUANTIFIER_AST: quantifiers + - SORT_AST: sort + - FUNC_DECL_AST: function declaration + - UNKNOWN_AST: internal +*) +(** + {!decl_kind} + The different kinds of interpreted function kinds. + + - OP_TRUE The constant true. + + - OP_FALSE The constant false. + + - OP_EQ The equality predicate. + + - OP_DISTINCT The n-ary distinct predicate (every argument is mutually distinct). + + - OP_ITE The ternary if-then-else term. + + - OP_AND n-ary conjunction. + + - OP_OR n-ary disjunction. + + - OP_IFF equivalence (binary). + + - OP_XOR Exclusive or. + + - OP_NOT Negation. + + - OP_IMPLIES Implication. + + - OP_OEQ Binary equivalence modulo namings. This binary predicate is used in proof terms. + It captures equisatisfiability and equivalence modulo renamings. + + - OP_ANUM Arithmetic numeral. + + - OP_AGNUM Arithmetic algebraic numeral. Algebraic numbers are used to represent irrational numbers in Z3. + + - OP_LE <=. + + - OP_GE >=. + + - OP_LT <. + + - OP_GT >. + + - OP_ADD Addition - Binary. + + - OP_SUB Binary subtraction. + + - OP_UMINUS Unary minus. + + - OP_MUL Multiplication - Binary. + + - OP_DIV Division - Binary. + + - OP_IDIV Integer division - Binary. + + - OP_REM Remainder - Binary. + + - OP_MOD Modulus - Binary. + + - OP_TO_REAL Coercion of integer to real - Unary. + + - OP_TO_INT Coercion of real to integer - Unary. + + - OP_IS_INT Check if real is also an integer - Unary. + + - OP_POWER Power operator x^y. + + - OP_STORE Array store. It satisfies select(store(a,i,v),j) = if i = j then v else select(a,j). + Array store takes at least 3 arguments. + + - OP_SELECT Array select. + + - OP_CONST_ARRAY The constant array. For example, select(const(v),i) = v holds for every v and i. The function is unary. + + - OP_ARRAY_DEFAULT Default value of arrays. For example default(const(v)) = v. The function is unary. + + - OP_ARRAY_MAP Array map operator. + It satisfies map[f](a1,..,a_n)[i] = f(a1[i],...,a_n[i]) for every i. + + - OP_SET_UNION Set union between two Booelan arrays (two arrays whose range type is Boolean). The function is binary. + + - OP_SET_INTERSECT Set intersection between two Boolean arrays. The function is binary. + + - OP_SET_DIFFERENCE Set difference between two Boolean arrays. The function is binary. + + - OP_SET_COMPLEMENT Set complement of a Boolean array. The function is unary. + + - OP_SET_SUBSET Subset predicate between two Boolean arrays. The relation is binary. + + - OP_AS_ARRAY An array value that behaves as the function graph of the + function passed as parameter. + + - OP_BNUM Bit-vector numeral. + + - OP_BIT1 One bit bit-vector. + + - OP_BIT0 Zero bit bit-vector. + + - OP_BNEG Unary minus. + + - OP_BADD Binary addition. + + - OP_BSUB Binary subtraction. + + - OP_BMUL Binary multiplication. + + - OP_BSDIV Binary signed division. + + - OP_BUDIV Binary unsigned int division. + + - OP_BSREM Binary signed remainder. + + - OP_BUREM Binary unsigned int remainder. + + - OP_BSMOD Binary signed modulus. + + - OP_BSDIV0 Unary function. bsdiv(x,0) is congruent to bsdiv0(x). + + - OP_BUDIV0 Unary function. budiv(x,0) is congruent to budiv0(x). + + - OP_BSREM0 Unary function. bsrem(x,0) is congruent to bsrem0(x). + + - OP_BUREM0 Unary function. burem(x,0) is congruent to burem0(x). + + - OP_BSMOD0 Unary function. bsmod(x,0) is congruent to bsmod0(x). + + - OP_ULEQ Unsigned bit-vector <= - Binary relation. + + - OP_SLEQ Signed bit-vector <= - Binary relation. + + - OP_UGEQ Unsigned bit-vector >= - Binary relation. + + - OP_SGEQ Signed bit-vector >= - Binary relation. + + - OP_ULT Unsigned bit-vector < - Binary relation. + + - OP_SLT Signed bit-vector < - Binary relation. + + - OP_UGT Unsigned bit-vector > - Binary relation. + + - OP_SGT Signed bit-vector > - Binary relation. + + - OP_BAND Bit-wise and - Binary. + + - OP_BOR Bit-wise or - Binary. + + - OP_BNOT Bit-wise not - Unary. + + - OP_BXOR Bit-wise xor - Binary. + + - OP_BNAND Bit-wise nand - Binary. + + - OP_BNOR Bit-wise nor - Binary. + + - OP_BXNOR Bit-wise xnor - Binary. + + - OP_CONCAT Bit-vector concatenation - Binary. + + - OP_SIGN_EXT Bit-vector sign extension. + + - OP_ZERO_EXT Bit-vector zero extension. + + - OP_EXTRACT Bit-vector extraction. + + - OP_REPEAT Repeat bit-vector n times. + + - OP_BREDOR Bit-vector reduce or - Unary. + + - OP_BREDAND Bit-vector reduce and - Unary. + + - OP_BCOMP . + + - OP_BSHL Shift left. + + - OP_BLSHR Logical shift right. + + - OP_BASHR Arithmetical shift right. + + - OP_ROTATE_LEFT Left rotation. + + - OP_ROTATE_RIGHT Right rotation. + + - OP_EXT_ROTATE_LEFT (extended) Left rotation. Similar to OP_ROTATE_LEFT, but it is a binary operator instead of a parametric one. + + - OP_EXT_ROTATE_RIGHT (extended) Right rotation. Similar to OP_ROTATE_RIGHT, but it is a binary operator instead of a parametric one. + + - OP_INT2BV Coerce integer to bit-vector. NB. This function + is not supported by the decision procedures. Only the most + rudimentary simplification rules are applied to this function. + + - OP_BV2INT Coerce bit-vector to integer. NB. This function + is not supported by the decision procedures. Only the most + rudimentary simplification rules are applied to this function. + + - OP_CARRY Compute the carry bit in a full-adder. + The meaning is given by the equivalence + (carry l1 l2 l3) <=> (or (and l1 l2) (and l1 l3) (and l2 l3))) + + - OP_XOR3 Compute ternary XOR. + The meaning is given by the equivalence + (xor3 l1 l2 l3) <=> (xor (xor l1 l2) l3) + + - OP_PR_UNDEF: Undef/Null proof object. + + - OP_PR_TRUE: Proof for the expression 'true'. + + - OP_PR_ASSERTED: Proof for a fact asserted by the user. + + - OP_PR_GOAL: Proof for a fact (tagged as goal) asserted by the user. + + - OP_PR_MODUS_PONENS: Given a proof for p and a proof for (implies p q), produces a proof for q. + {e + T1: p + T2: (implies p q) + [mp T1 T2]: q + } + The second antecedents may also be a proof for (iff p q). + + - OP_PR_REFLEXIVITY: A proof for (R t t), where R is a reflexive relation. This proof object has no antecedents. + The only reflexive relations that are used are + equivalence modulo namings, equality and equivalence. + That is, R is either '~', '=' or 'iff'. + + - OP_PR_SYMMETRY: Given an symmetric relation R and a proof for (R t s), produces a proof for (R s t). + {e + T1: (R t s) + [symmetry T1]: (R s t) + } + T1 is the antecedent of this proof object. + + - OP_PR_TRANSITIVITY: Given a transitive relation R, and proofs for (R t s) and (R s u), produces a proof + for (R t u). + {e + T1: (R t s) + T2: (R s u) + [trans T1 T2]: (R t u) + } + + - OP_PR_TRANSITIVITY_STAR: Condensed transitivity proof. This proof object is only used if the parameter PROOF_MODE is 1. + It combines several symmetry and transitivity proofs. + + Example: + {e + T1: (R a b) + T2: (R c b) + T3: (R c d) + [trans* T1 T2 T3]: (R a d) + } + R must be a symmetric and transitive relation. + + Assuming that this proof object is a proof for (R s t), then + a proof checker must check if it is possible to prove (R s t) + using the antecedents, symmetry and transitivity. That is, + if there is a path from s to t, if we view every + antecedent (R a b) as an edge between a and b. + + - OP_PR_MONOTONICITY: Monotonicity proof object. + {e + T1: (R t_1 s_1) + ... + Tn: (R t_n s_n) + [monotonicity T1 ... Tn]: (R (f t_1 ... t_n) (f s_1 ... s_n)) + } + Remark: if t_i == s_i, then the antecedent Ti is suppressed. + That is, reflexivity proofs are supressed to save space. + + - OP_PR_QUANT_INTRO: Given a proof for (~ p q), produces a proof for (~ (forall (x) p) (forall (x) q)). + + T1: (~ p q) + [quant-intro T1]: (~ (forall (x) p) (forall (x) q)) + + - OP_PR_DISTRIBUTIVITY: Distributivity proof object. + Given that f (= or) distributes over g (= and), produces a proof for + + (= (f a (g c d)) + (g (f a c) (f a d))) + + If f and g are associative, this proof also justifies the following equality: + + (= (f (g a b) (g c d)) + (g (f a c) (f a d) (f b c) (f b d))) + + where each f and g can have arbitrary number of arguments. + + This proof object has no antecedents. + Remark. This rule is used by the CNF conversion pass and + instantiated by f = or, and g = and. + + - OP_PR_AND_ELIM: Given a proof for (and l_1 ... l_n), produces a proof for l_i + + {e + T1: (and l_1 ... l_n) + [and-elim T1]: l_i + } + - OP_PR_NOT_OR_ELIM: Given a proof for (not (or l_1 ... l_n)), produces a proof for (not l_i). + + {e + T1: (not (or l_1 ... l_n)) + [not-or-elim T1]: (not l_i) + } + + - OP_PR_REWRITE: A proof for a local rewriting step (= t s). + The head function symbol of t is interpreted. + + This proof object has no antecedents. + The conclusion of a rewrite rule is either an equality (= t s), + an equivalence (iff t s), or equi-satisfiability (~ t s). + Remark: if f is bool, then = is iff. + + + Examples: + {e + (= (+ x 0) x) + (= (+ x 1 2) (+ 3 x)) + (iff (or x false) x) + } + + - OP_PR_REWRITE_STAR: A proof for rewriting an expression t into an expression s. + This proof object is used if the parameter PROOF_MODE is 1. + This proof object can have n antecedents. + The antecedents are proofs for equalities used as substitution rules. + The object is also used in a few cases if the parameter PROOF_MODE is 2. + The cases are: + - When applying contextual simplification (CONTEXT_SIMPLIFIER=true) + - When converting bit-vectors to Booleans (BIT2BOOL=true) + - When pulling ite expression up (PULL_CHEAP_ITE_TREES=true) + + - OP_PR_PULL_QUANT: A proof for (iff (f (forall (x) q(x)) r) (forall (x) (f (q x) r))). This proof object has no antecedents. + + - OP_PR_PULL_QUANT_STAR: A proof for (iff P Q) where Q is in prenex normal form. + This proof object is only used if the parameter PROOF_MODE is 1. + This proof object has no antecedents. + + - OP_PR_PUSH_QUANT: A proof for: + + {e + (iff (forall (x_1 ... x_m) (and p_1[x_1 ... x_m] ... p_n[x_1 ... x_m])) + (and (forall (x_1 ... x_m) p_1[x_1 ... x_m]) + ... + (forall (x_1 ... x_m) p_n[x_1 ... x_m]))) + } + This proof object has no antecedents. + + - OP_PR_ELIM_UNUSED_VARS: + A proof for (iff (forall (x_1 ... x_n y_1 ... y_m) p[x_1 ... x_n]) + (forall (x_1 ... x_n) p[x_1 ... x_n])) + + It is used to justify the elimination of unused variables. + This proof object has no antecedents. + + - OP_PR_DER: A proof for destructive equality resolution: + (iff (forall (x) (or (not (= x t)) P[x])) P[t]) + if x does not occur in t. + + This proof object has no antecedents. + + Several variables can be eliminated simultaneously. + + - OP_PR_QUANT_INST: A proof of (or (not (forall (x) (P x))) (P a)) + + - OP_PR_HYPOTHESIS: Mark a hypothesis in a natural deduction style proof. + + - OP_PR_LEMMA: + + {e + T1: false + [lemma T1]: (or (not l_1) ... (not l_n)) + } + This proof object has one antecedent: a hypothetical proof for false. + It converts the proof in a proof for (or (not l_1) ... (not l_n)), + when T1 contains the hypotheses: l_1, ..., l_n. + + - OP_PR_UNIT_RESOLUTION: + {e + T1: (or l_1 ... l_n l_1' ... l_m') + T2: (not l_1) + ... + T(n+1): (not l_n) + [unit-resolution T1 ... T(n+1)]: (or l_1' ... l_m') + } + + - OP_PR_IFF_TRUE: + {e + T1: p + [iff-true T1]: (iff p true) + } + + - OP_PR_IFF_FALSE: + {e + T1: (not p) + [iff-false T1]: (iff p false) + } + + - OP_PR_COMMUTATIVITY: + + [comm]: (= (f a b) (f b a)) + + f is a commutative operator. + + This proof object has no antecedents. + Remark: if f is bool, then = is iff. + + - OP_PR_DEF_AXIOM: Proof object used to justify Tseitin's like axioms: + + {e + (or (not (and p q)) p) + (or (not (and p q)) q) + (or (not (and p q r)) p) + (or (not (and p q r)) q) + (or (not (and p q r)) r) + ... + (or (and p q) (not p) (not q)) + (or (not (or p q)) p q) + (or (or p q) (not p)) + (or (or p q) (not q)) + (or (not (iff p q)) (not p) q) + (or (not (iff p q)) p (not q)) + (or (iff p q) (not p) (not q)) + (or (iff p q) p q) + (or (not (ite a b c)) (not a) b) + (or (not (ite a b c)) a c) + (or (ite a b c) (not a) (not b)) + (or (ite a b c) a (not c)) + (or (not (not a)) (not a)) + (or (not a) a) + } + This proof object has no antecedents. + Note: all axioms are propositional tautologies. + Note also that 'and' and 'or' can take multiple arguments. + You can recover the propositional tautologies by + unfolding the Boolean connectives in the axioms a small + bounded number of steps (=3). + + - OP_PR_DEF_INTRO: Introduces a name for a formula/term. + Suppose e is an expression with free variables x, and def-intro + introduces the name n(x). The possible cases are: + + When e is of Boolean type: + [def-intro]: (and (or n (not e)) (or (not n) e)) + + or: + [def-intro]: (or (not n) e) + when e only occurs positively. + + When e is of the form (ite cond th el): + [def-intro]: (and (or (not cond) (= n th)) (or cond (= n el))) + + Otherwise: + [def-intro]: (= n e) + + - OP_PR_APPLY_DEF: + [apply-def T1]: F ~ n + F is 'equivalent' to n, given that T1 is a proof that + n is a name for F. + + - OP_PR_IFF_OEQ: + T1: (iff p q) + [iff~ T1]: (~ p q) + + - OP_PR_NNF_POS: Proof for a (positive) NNF step. Example: + {e + T1: (not s_1) ~ r_1 + T2: (not s_2) ~ r_2 + T3: s_1 ~ r_1' + T4: s_2 ~ r_2' + [nnf-pos T1 T2 T3 T4]: (~ (iff s_1 s_2) + (and (or r_1 r_2') (or r_1' r_2))) + } + The negation normal form steps NNF_POS and NNF_NEG are used in the following cases: + (a) When creating the NNF of a positive force quantifier. + The quantifier is retained (unless the bound variables are eliminated). + Example + {e + T1: q ~ q_new + [nnf-pos T1]: (~ (forall (x T) q) (forall (x T) q_new)) + } + (b) When recursively creating NNF over Boolean formulas, where the top-level + connective is changed during NNF conversion. The relevant Boolean connectives + for NNF_POS are 'implies', 'iff', 'xor', 'ite'. + NNF_NEG furthermore handles the case where negation is pushed + over Boolean connectives 'and' and 'or'. + + + - OP_PR_NFF_NEG: Proof for a (negative) NNF step. Examples: + {e + T1: (not s_1) ~ r_1 + ... + Tn: (not s_n) ~ r_n + [nnf-neg T1 ... Tn]: (not (and s_1 ... s_n)) ~ (or r_1 ... r_n) + and + T1: (not s_1) ~ r_1 + ... + Tn: (not s_n) ~ r_n + [nnf-neg T1 ... Tn]: (not (or s_1 ... s_n)) ~ (and r_1 ... r_n) + and + T1: (not s_1) ~ r_1 + T2: (not s_2) ~ r_2 + T3: s_1 ~ r_1' + T4: s_2 ~ r_2' + [nnf-neg T1 T2 T3 T4]: (~ (not (iff s_1 s_2)) + (and (or r_1 r_2) (or r_1' r_2'))) + } + - OP_PR_NNF_STAR: A proof for (~ P Q) where Q is in negation normal form. + + This proof object is only used if the parameter PROOF_MODE is 1. + + This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. + + - OP_PR_CNF_STAR: A proof for (~ P Q) where Q is in conjunctive normal form. + This proof object is only used if the parameter PROOF_MODE is 1. + This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. + + - OP_PR_SKOLEMIZE: Proof for: + + {e + [sk]: (~ (not (forall x (p x y))) (not (p (sk y) y))) + [sk]: (~ (exists x (p x y)) (p (sk y) y)) + } + + This proof object has no antecedents. + + - OP_PR_MODUS_PONENS_OEQ: Modus ponens style rule for equi-satisfiability. + {e + T1: p + T2: (~ p q) + [mp~ T1 T2]: q + } + + - OP_PR_TH_LEMMA: Generic proof for theory lemmas. + + The theory lemma function comes with one or more parameters. + The first parameter indicates the name of the theory. + For the theory of arithmetic, additional parameters provide hints for + checking the theory lemma. + The hints for arithmetic are: + + - farkas - followed by rational coefficients. Multiply the coefficients to the + inequalities in the lemma, add the (negated) inequalities and obtain a contradiction. + + - triangle-eq - Indicates a lemma related to the equivalence: + {e + (iff (= t1 t2) (and (<= t1 t2) (<= t2 t1))) + } + + - gcd-test - Indicates an integer linear arithmetic lemma that uses a gcd test. + + + - OP_RA_STORE: Insert a record into a relation. + The function takes [n+1] arguments, where the first argument is the relation and the remaining [n] elements + correspond to the [n] columns of the relation. + + - OP_RA_EMPTY: Creates the empty relation. + + - OP_RA_IS_EMPTY: Tests if the relation is empty. + + - OP_RA_JOIN: Create the relational join. + + - OP_RA_UNION: Create the union or convex hull of two relations. + The function takes two arguments. + + - OP_RA_WIDEN: Widen two relations. + The function takes two arguments. + + - OP_RA_PROJECT: Project the columns (provided as numbers in the parameters). + The function takes one argument. + + - OP_RA_FILTER: Filter (restrict) a relation with respect to a predicate. + The first argument is a relation. + The second argument is a predicate with free de-Brujin indices + corresponding to the columns of the relation. + So the first column in the relation has index 0. + + - OP_RA_NEGATION_FILTER: Intersect the first relation with respect to negation + of the second relation (the function takes two arguments). + Logically, the specification can be described by a function + + target = filter_by_negation(pos, neg, columns) + + where columns are pairs c1, d1, .., cN, dN of columns from pos and neg, such that + target are elements in x in pos, such that there is no y in neg that agrees with + x on the columns c1, d1, .., cN, dN. + + + - OP_RA_RENAME: rename columns in the relation. + The function takes one argument. + The parameters contain the renaming as a cycle. + + - OP_RA_COMPLEMENT: Complement the relation. + + - OP_RA_SELECT: Check if a record is an element of the relation. + The function takes [n+1] arguments, where the first argument is a relation, + and the remaining [n] arguments correspond to a record. + + - OP_RA_CLONE: Create a fresh copy (clone) of a relation. + The function is logically the identity, but + in the context of a register machine allows + for [OP_RA_UNION] + to perform destructive updates to the first argument. + + + - OP_FD_LT: A less than predicate over the finite domain FINITE_DOMAIN_SORT. + + - OP_LABEL: A label (used by the Boogie Verification condition generator). + The label has two parameters, a string and a Boolean polarity. + It takes one argument, a formula. + + - OP_LABEL_LIT: A label literal (used by the Boogie Verification condition generator). + A label literal has a set of string parameters. It takes no arguments. + + - OP_DT_CONSTRUCTOR: datatype constructor. + + - OP_DT_RECOGNISER: datatype recognizer. + + - OP_DT_ACCESSOR: datatype accessor. + + - OP_UNINTERPRETED: kind used for uninterpreted symbols. +*) +(** + {!param_kind} + + The different kinds of parameters that can be associated with parameter sets. + (see {!mk_params}). + + - PK_UINT integer parameters. + - PK_BOOL boolean parameters. + - PK_DOUBLE double parameters. + - PK_SYMBOL symbol parameters. + - PK_STRING string parameters. + - PK_OTHER all internal parameter kinds which are not exposed in the API. + - PK_INVALID invalid parameter. +*) +(** + {!search_failure} + The different kinds of search failure types. + + - NO_FAILURE: The last search was successful + - UNKNOWN: Undocumented failure reason + - TIMEOUT: Timeout + - MEMOUT_WATERMAK: Search hit a memory high-watermak limit + - CANCELED: External cancel flag was set + - NUM_CONFLICTS: Maximum number of conflicts was reached + - THEORY: Theory is incomplete + - QUANTIFIERS: Logical context contains universal quantifiers +*) +(** + {!ast_print_mode} + Z3 pretty printing modes (See {!set_ast_print_mode}). + + - PRINT_SMTLIB_FULL: Print AST nodes in SMTLIB verbose format. + - PRINT_LOW_LEVEL: Print AST nodes using a low-level format. + - PRINT_SMTLIB_COMPLIANT: Print AST nodes in SMTLIB 1.x compliant format. + - PRINT_SMTLIB2_COMPLIANT: Print AST nodes in SMTLIB 2.x compliant format. +*) +(** + {2 {L Create configuration}} +*) +(** + Summary: Create a configuration. + + Configurations are created in order to assign parameters prior to creating + contexts for Z3 interaction. For example, if the users wishes to use model + generation, then call: + + [set_param_value cfg "MODEL" "true"] + + - {b Remarks}: Consider using {!mk_context_x} instead of using + explicit configuration objects. The function {!mk_context_x} + receives an array of string pairs. This array represents the + configuration options. + + - {b See also}: {!set_param_value} + - {b See also}: {!del_config} +*) +external mk_config : unit -> config + = "camlidl_z3V3_Z3_mk_config" + +(** + Summary: Delete the given configuration object. + + - {b See also}: {!mk_config} +*) +external del_config : config -> unit + = "camlidl_z3V3_Z3_del_config" + +(** + Summary: Set a configuration parameter. + + The list of all configuration parameters can be obtained using the Z3 executable: + + {v + z3.exe -ini? + v} + + - {b See also}: {!mk_config} +*) +external set_param_value : config -> string -> string -> unit + = "camlidl_z3V3_Z3_set_param_value" + +(** + {2 {L Create context}} +*) +(** + Summary: Create a context using the given configuration. + + After a context is created, the configuration cannot be changed, + although some parameters can be changed using {!update_param_value}. + All main interaction with Z3 happens in the context of a [context]. + + + + +*) +external mk_context : config -> context + = "camlidl_z3V3_Z3_mk_context" + +(** + Summary: Delete the given logical context. + + - {b See also}: {!mk_context} +*) +external del_context : context -> unit + = "camlidl_z3V3_Z3_del_context" + +(** + Summary: Update a mutable configuration parameter. + + The list of all configuration parameters can be obtained using the Z3 executable: + + {v + z3.exe -ini? + v} + + Only a few configuration parameters are mutable once the context is created. + The error handler is invoked when trying to modify an immutable parameter. + + + - {b See also}: {!mk_context } +*) +external update_param_value : context -> string -> string -> unit + = "camlidl_z3V3_Z3_update_param_value" + +(** + Summary: Get a configuration parameter. + + Returns [None] + if the parameter value does not exist. + + + + - {b See also}: {!mk_context } +*) +external get_param_value : context -> string -> string option + = "camlidl_z3V3_Z3_get_param_value" + +(** + {2 {L Symbols}} +*) +(** + {4 {L Redundant low-level API}} +*) +(** + Summary: Create a Z3 symbol using an integer. + + Symbols are used to name several term and type constructors. + + NB. Not all integers can be passed to this function. + The legal range of unsigned int integers is 0 to 2^30-1. + + - {b See also}: {!mk_string_symbol} +*) +external mk_int_symbol : context -> int -> symbol + = "camlidl_z3V3_Z3_mk_int_symbol" + +(** + Summary: Create a Z3 symbol using a C string. + + Symbols are used to name several term and type constructors. + + - {b See also}: {!mk_int_symbol} +*) +external mk_string_symbol : context -> string -> symbol + = "camlidl_z3V3_Z3_mk_string_symbol" + +(** + {2 {L Sorts}} +*) +(** + {4 {L Redundant low-level API}} +*) +(** + Summary: Create a free (uninterpreted) type using the given name (symbol). + + Two free types are considered the same iff the have the same name. +*) +external mk_uninterpreted_sort : context -> symbol -> sort + = "camlidl_z3V3_Z3_mk_uninterpreted_sort" + +(** + Summary: Create the Boolean type. + + This type is used to create propositional variables and predicates. +*) +external mk_bool_sort : context -> sort + = "camlidl_z3V3_Z3_mk_bool_sort" + +(** + Summary: Create the integer type. + + This type is not the int type found in programming languages. + A machine integer can be represented using bit-vectors. The function + {!mk_bv_sort} creates a bit-vector type. + + - {b See also}: {!mk_bv_sort} +*) +external mk_int_sort : context -> sort + = "camlidl_z3V3_Z3_mk_int_sort" + +(** + Summary: Create the real type. + + This type is not a floating point number. + Z3 does not have support for floating point numbers yet. +*) +external mk_real_sort : context -> sort + = "camlidl_z3V3_Z3_mk_real_sort" + +(** + Summary: Create a bit-vector type of the given size. + + This type can also be seen as a machine integer. + + - {b Remarks}: The size of the bitvector type must be greater than zero. +*) +external mk_bv_sort : context -> int -> sort + = "camlidl_z3V3_Z3_mk_bv_sort" + +(** + Summary: Create a named finite domain sort. + + To create constants that belong to the finite domain, + use the APIs for creating numerals and pass a numeric + constant together with the sort returned by this call. + + - {b See also}: {!get_finite_domain_sort_size.} +*) +external mk_finite_domain_sort : context -> symbol -> int64 -> sort + = "camlidl_z3V3_Z3_mk_finite_domain_sort" + +(** + Summary: Create an array type. + + We usually represent the array type as: {e [domain -> range] }. + Arrays are usually used to model the heap/memory in software verification. + + - {b See also}: {!mk_select} + - {b See also}: {!mk_store} +*) +external mk_array_sort : context -> sort -> sort -> sort + = "camlidl_z3V3_Z3_mk_array_sort" + +(** + Summary: Create a tuple type. + + [mk_tuple_sort c name field_names field_sorts] creates a tuple with a constructor named [name], + a [n] fields, where [n] is the size of the arrays [field_names] and [field_sorts]. + + + + + + @param c logical context + @param mk_tuple_name name of the constructor function associated with the tuple type. + @param num_fields number of fields in the tuple type. + @param field_names name of the projection functions. + @param field_sorts type of the tuple fields. + @param mk_tuple_decl output parameter that will contain the constructor declaration. + @param proj_decl output parameter that will contain the projection function declarations. This field must be a buffer of size [num_fields] allocated by the user. +*) +external mk_tuple_sort : context -> symbol -> symbol array -> sort array -> sort * func_decl * func_decl array + = "camlidl_z3V3_Z3_mk_tuple_sort" + +(** + Summary: Create a enumeration sort. + + [mk_enumeration_sort c enums] creates an enumeration sort with enumeration names [enums], + it also returns [n] predicates, where [n] is the number of [enums] corresponding + to testing whether an element is one of the enumerants. + + + + + + @param c logical context + @param name name of the enumeration sort. + @param n number of elemenets in enumeration sort. + @param enum_names names of the enumerated elements. + @param enum_consts constants corresponding to the enumerated elements. + @param enum_testers predicates testing if terms of the enumeration sort correspond to an enumeration. + + For example, if this function is called with three symbols A, B, C and the name S, then + [s] is a sort whose name is S, and the function returns three terms corresponding to A, B, C in + [enum_consts]. The array [enum_testers] has three predicates of type {e (s -> Bool) }. + The first predicate (corresponding to A) is true when applied to A, and false otherwise. + Similarly for the other predicates. +*) +external mk_enumeration_sort : context -> symbol -> symbol array -> sort * func_decl array * func_decl array + = "camlidl_z3V3_Z3_mk_enumeration_sort" + +(** + Summary: Create a list sort + + [mk_list_sort c name elem_sort] creates a list sort of [name], over elements of sort [elem_sort]. + + + + + + @param c logical context + @param name name of the list sort. + @param elem_sort sort of list elements. + @param nil_decl declaration for the empty list. + @param is_nil_decl test for the empty list. + @param cons_decl declaration for a cons cell. + @param is_cons_decl cons cell test. + @param head_decl list head. + @param tail_decl list tail. +*) +external mk_list_sort : context -> symbol -> sort -> sort * func_decl * func_decl * func_decl * func_decl * func_decl * func_decl + = "camlidl_z3V3_Z3_mk_list_sort" + +(** + Summary: Create a constructor. + + @param c logical context. + @param name constructor name. + @param recognizer name of recognizer function. + @param num_fields number of fields in constructor. + @param field_names names of the constructor fields. + @param sorts field sorts, [None] + if the field sort refers to a recursive sort. + @param sort_refs reference to datatype sort that is an argument to the constructor; if the corresponding + sort reference is [None], + then the value in sort_refs should be an index referring to + one of the recursive datatypes that is declared. +*) +external mk_constructor : context -> symbol -> symbol -> symbol array -> sort array -> int array -> constructor + = "camlidl_z3_Z3_mk_constructor_bytecode" "camlidl_z3V3_Z3_mk_constructor" + +(** + Summary: Reclaim memory allocated to constructor. + + @param c logical context. + @param constr constructor. +*) +external del_constructor : context -> constructor -> unit + = "camlidl_z3V3_Z3_del_constructor" + +(** + Summary: Create datatype, such as lists, trees, records, enumerations or unions of records. + The datatype may be recursive. Return the datatype sort. + + @param c logical context. + @param name name of datatype. + @param num_constructors number of constructors passed in. + @param constructors array of constructor containers. +*) +external mk_datatype : context -> symbol -> constructor array -> sort * constructor array + = "camlidl_z3V3_Z3_mk_datatype" + +(** + Summary: Create list of constructors. + + @param c logical context. + @param num_constructors number of constructors in list. + @param constructors list of constructors. +*) +external mk_constructor_list : context -> constructor array -> constructor_list + = "camlidl_z3V3_Z3_mk_constructor_list" + +(** + Summary: Reclaim memory allocated for constructor list. + + Each constructor inside the constructor list must be independently reclaimed using {!del_constructor}. + + @param c logical context. + @param clist constructor list container. + +*) +external del_constructor_list : context -> constructor_list -> unit + = "camlidl_z3V3_Z3_del_constructor_list" + +(** + Summary: Create mutually recursive datatypes. + + @param c logical context. + @param num_sorts number of datatype sorts. + @param sort_names names of datatype sorts. + @param sorts array of datattype sorts. + @param constructor_lists list of constructors, one list per sort. +*) +external mk_datatypes : context -> symbol array -> constructor_list array -> sort array * constructor_list array + = "camlidl_z3V3_Z3_mk_datatypes" + +(** + Summary: Query constructor for declared functions. + + @param c logical context. + @param constr constructor container. The container must have been passed in to a {!mk_datatype} call. + @param num_fields number of accessor fields in the constructor. + @param constructor constructor function declaration. + @param tester constructor test function declaration. + @param accessors array of accessor function declarations. +*) +external query_constructor : context -> constructor -> int -> func_decl * func_decl * func_decl array + = "camlidl_z3V3_Z3_query_constructor" + +(** + {2 {L Constants and Applications}} +*) +(** + Summary: Declare a constant or function. + + [mk_func_decl c n d r] creates a function with name [n], domain [d], and range [r]. + The arity of the function is the size of the array [d]. + + @param c logical context. + @param s name of the constant or function. + @param domain_size number of arguments. It is 0 when declaring a constant. + @param domain array containing the sort of each argument. The array must contain domain_size elements. It is 0 when declaring a constant. + @param range sort of the constant or the return sort of the function. + + After declaring a constant or function, the function + {!mk_app} can be used to create a constant or function + application. + + - {b See also}: {!mk_app} +*) +external mk_func_decl : context -> symbol -> sort array -> sort -> func_decl + = "camlidl_z3V3_Z3_mk_func_decl" + +(** + Summary: Create a constant or function application. + + - {b See also}: {!mk_func_decl} +*) +external mk_app : context -> func_decl -> ast array -> ast + = "camlidl_z3V3_Z3_mk_app" + +(** + Summary: Declare and create a constant. + + + + + + + + [mk_const c s t] is a shorthand for [mk_app c (mk_func_decl c s [||] t) [||]] + + - {b See also}: {!mk_func_decl} + - {b See also}: {!mk_app} +*) +external mk_const : context -> symbol -> sort -> ast + = "camlidl_z3V3_Z3_mk_const" + +(** + Summary: Declare a fresh constant or function. + + Z3 will generate an unique name for this function declaration. + + + + + - {b See also}: {!mk_func_decl} +*) +external mk_fresh_func_decl : context -> string -> sort array -> sort -> func_decl + = "camlidl_z3V3_Z3_mk_fresh_func_decl" + +(** + Summary: Declare and create a fresh constant. + + + + + [mk_fresh_const c p t] is a shorthand for [mk_app c (mk_fresh_func_decl c p [||] t) [||]]. + + + + - {b See also}: {!mk_func_decl} + - {b See also}: {!mk_app} +*) +external mk_fresh_const : context -> string -> sort -> ast + = "camlidl_z3V3_Z3_mk_fresh_const" + +(** + {2 {L Propositional Logic and Equality}} +*) +(** + Summary: Create an AST node representing [true]. +*) +external mk_true : context -> ast + = "camlidl_z3V3_Z3_mk_true" + +(** + Summary: Create an AST node representing [false]. +*) +external mk_false : context -> ast + = "camlidl_z3V3_Z3_mk_false" + +(** + Summary: \[ [ mk_eq c l r ] \] + Create an AST node representing {e l = r }. + + The nodes [l] and [r] must have the same type. +*) +external mk_eq : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_eq" + +(** + + Summary: \[ [mk_distinct c [| t_1; ...; t_n |]] \] Create an AST + node represeting a distinct construct. It is used for declaring + the arguments t_i pairwise distinct. + + The [distinct] construct is used for declaring the arguments pairwise distinct. + That is, {e Forall 0 <= i < j < num_args. not args[i] = args[j] }. + + All arguments must have the same sort. + + - {b Remarks}: The number of arguments of a distinct construct must be greater than one. +*) +external mk_distinct : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_distinct" + +(** + Summary: \[ [ mk_not c a ] \] + Create an AST node representing {e not(a) }. + + The node [a] must have Boolean sort. +*) +external mk_not : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_not" + +(** + Summary: \[ [ mk_ite c t1 t2 t2 ] \] + Create an AST node representing an if-then-else: {e ite(t1, t2, + t3) }. + + The node [t1] must have Boolean sort, [t2] and [t3] must have the same sort. + The sort of the new node is equal to the sort of [t2] and [t3]. +*) +external mk_ite : context -> ast -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_ite" + +(** + Summary: \[ [ mk_iff c t1 t2 ] \] + Create an AST node representing {e t1 iff t2 }. + + The nodes [t1] and [t2] must have Boolean sort. +*) +external mk_iff : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_iff" + +(** + Summary: \[ [ mk_implies c t1 t2 ] \] + Create an AST node representing {e t1 implies t2 }. + + The nodes [t1] and [t2] must have Boolean sort. +*) +external mk_implies : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_implies" + +(** + Summary: \[ [ mk_xor c t1 t2 ] \] + Create an AST node representing {e t1 xor t2 }. + + The nodes [t1] and [t2] must have Boolean sort. +*) +external mk_xor : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_xor" + +(** + + Summary: \[ [mk_and c [| t_1; ...; t_n |]] \] Create the conjunction: {e t_1 and ... and t_n}. + + + All arguments must have Boolean sort. + + - {b Remarks}: The number of arguments must be greater than zero. +*) +external mk_and : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_and" + +(** + + Summary: \[ [mk_or c [| t_1; ...; t_n |]] \] Create the disjunction: {e t_1 or ... or t_n}. + + + All arguments must have Boolean sort. + + - {b Remarks}: The number of arguments must be greater than zero. +*) +external mk_or : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_or" + +(** + {2 {L Arithmetic: Integers and Reals}} +*) +(** + + Summary: \[ [mk_add c [| t_1; ...; t_n |]] \] Create the term: {e t_1 + ... + t_n}. + + + All arguments must have int or real sort. + + - {b Remarks}: The number of arguments must be greater than zero. +*) +external mk_add : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_add" + +(** + + Summary: \[ [mk_mul c [| t_1; ...; t_n |]] \] Create the term: {e t_1 * ... * t_n}. + + + All arguments must have int or real sort. + + - {b Remarks}: Z3 has limited support for non-linear arithmetic. + - {b Remarks}: The number of arguments must be greater than zero. +*) +external mk_mul : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_mul" + +(** + + Summary: \[ [mk_sub c [| t_1; ...; t_n |]] \] Create the term: {e t_1 - ... - t_n}. + + + All arguments must have int or real sort. + + - {b Remarks}: The number of arguments must be greater than zero. +*) +external mk_sub : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_sub" + +(** + + Summary: \[ [mk_unary_minus c arg] \] Create the term: {e - arg}. + + The arguments must have int or real type. +*) +external mk_unary_minus : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_unary_minus" + +(** + + Summary: \[ [mk_div c t_1 t_2] \] Create the term: {e t_1 div t_2}. + + The arguments must either both have int type or both have real type. + If the arguments have int type, then the result type is an int type, otherwise the + the result type is real. + +*) +external mk_div : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_div" + +(** + + Summary: \[ [mk_mod c t_1 t_2] \] Create the term: {e t_1 mod t_2}. + + The arguments must have int type. + +*) +external mk_mod : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_mod" + +(** + + Summary: \[ [mk_rem c t_1 t_2] \] Create the term: {e t_1 rem t_2}. + + The arguments must have int type. + +*) +external mk_rem : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_rem" + +(** + + + The arguments must have int or real type. +*) +external mk_power : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_power" + +(** + Summary: \[ [ mk_lt c t1 t2 ] \] + Create less than. + + The nodes [t1] and [t2] must have the same sort, and must be int or real. +*) +external mk_lt : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_lt" + +(** + Summary: \[ [ mk_le c t1 t2 ] \] + Create less than or equal to. + + The nodes [t1] and [t2] must have the same sort, and must be int or real. +*) +external mk_le : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_le" + +(** + Summary: \[ [ mk_gt c t1 t2 ] \] + Create greater than. + + The nodes [t1] and [t2] must have the same sort, and must be int or real. +*) +external mk_gt : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_gt" + +(** + Summary: \[ [ mk_ge c t1 t2 ] \] + Create greater than or equal to. + + The nodes [t1] and [t2] must have the same sort, and must be int or real. +*) +external mk_ge : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_ge" + +(** + Summary: \[ [ mk_int2real c t1 ] \] + Coerce an integer to a real. + + There is also a converse operation exposed. + It follows the semantics prescribed by the SMT-LIB standard. + + You can take the floor of a real by + creating an auxiliary integer constant [k] and + and asserting {e mk_int2real(k) <= t1 < mk_int2real(k)+1 }. + + The node [t1] must have sort integer. + + - {b See also}: {!mk_real2int} + - {b See also}: {!mk_is_int} +*) +external mk_int2real : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_int2real" + +(** + Summary: \[ [ mk_real2int c t1 ] \] + Coerce a real to an integer. + + The semantics of this function follows the SMT-LIB standard + for the function to_int + + - {b See also}: {!mk_int2real} + - {b See also}: {!mk_is_int} +*) +external mk_real2int : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_real2int" + +(** + Summary: \[ [ mk_is_int c t1 ] \] + Check if a real number is an integer. + + - {b See also}: {!mk_int2real} + - {b See also}: {!mk_real2int} +*) +external mk_is_int : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_is_int" + +(** + {2 {L Bit-vectors}} +*) +(** + Summary: \[ [ mk_bvnot c t1 ] \] + Bitwise negation. + + The node [t1] must have a bit-vector sort. +*) +external mk_bvnot : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvnot" + +(** + Summary: \[ [ mk_bvredand c t1 ] \] + Take conjunction of bits in vector, return vector of length 1. + + The node [t1] must have a bit-vector sort. +*) +external mk_bvredand : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvredand" + +(** + Summary: \[ [ mk_bvredor c t1 ] \] + Take disjunction of bits in vector, return vector of length 1. + + The node [t1] must have a bit-vector sort. +*) +external mk_bvredor : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvredor" + +(** + Summary: \[ [ mk_bvand c t1 t2 ] \] + Bitwise and. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvand : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvand" + +(** + Summary: \[ [ mk_bvor c t1 t2 ] \] + Bitwise or. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvor : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvor" + +(** + Summary: \[ [ mk_bvxor c t1 t2 ] \] + Bitwise exclusive-or. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvxor : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvxor" + +(** + Summary: \[ [ mk_bvnand c t1 t2 ] \] + Bitwise nand. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvnand : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvnand" + +(** + Summary: \[ [ mk_bvnor c t1 t2 ] \] + Bitwise nor. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvnor : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvnor" + +(** + Summary: \[ [ mk_bvxnor c t1 t2 ] \] + Bitwise xnor. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvxnor : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvxnor" + +(** + Summary: \[ [ mk_bvneg c t1 ] \] + Standard two's complement unary minus. + + The node [t1] must have bit-vector sort. +*) +external mk_bvneg : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvneg" + +(** + Summary: \[ [ mk_bvadd c t1 t2 ] \] + Standard two's complement addition. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvadd : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvadd" + +(** + Summary: \[ [ mk_bvsub c t1 t2 ] \] + Standard two's complement subtraction. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsub : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsub" + +(** + Summary: \[ [ mk_bvmul c t1 t2 ] \] + Standard two's complement multiplication. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvmul : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvmul" + +(** + Summary: \[ [ mk_bvudiv c t1 t2 ] \] + Unsigned division. + + It is defined as the [floor] of {e t1/t2 } if [t2] is + different from zero. If {e t2 } is zero, then the result + is undefined. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvudiv : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvudiv" + +(** + Summary: \[ [ mk_bvsdiv c t1 t2 ] \] + Two's complement signed division. + + It is defined in the following way: + + - The [floor] of {e t1/t2 } if [t2] is different from zero, and {e t1*t2 >= 0 }. + + - The [ceiling] of {e t1/t2 } if [t2] is different from zero, and {e t1*t2 < 0 }. + + If {e t2 } is zero, then the result is undefined. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsdiv : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsdiv" + +(** + Summary: \[ [ mk_bvurem c t1 t2 ] \] + Unsigned remainder. + + It is defined as {e t1 - (t1 /u t2) * t2 }, where {e /u } represents unsigned int division. + + If {e t2 } is zero, then the result is undefined. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvurem : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvurem" + +(** + Summary: \[ [ mk_bvsrem c t1 t2 ] \] + Two's complement signed remainder (sign follows dividend). + + It is defined as {e t1 - (t1 /s t2) * t2 }, where {e /s } represents signed division. + The most significant bit (sign) of the result is equal to the most significant bit of [t1]. + + If {e t2 } is zero, then the result is undefined. + + The nodes [t1] and [t2] must have the same bit-vector sort. + + - {b See also}: {!mk_bvsmod} +*) +external mk_bvsrem : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsrem" + +(** + Summary: \[ [ mk_bvsmod c t1 t2 ] \] + Two's complement signed remainder (sign follows divisor). + + If {e t2 } is zero, then the result is undefined. + + The nodes [t1] and [t2] must have the same bit-vector sort. + + - {b See also}: {!mk_bvsrem} +*) +external mk_bvsmod : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsmod" + +(** + Summary: \[ [ mk_bvult c t1 t2 ] \] + Unsigned less than. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvult : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvult" + +(** + Summary: \[ [ mk_bvslt c t1 t2 ] \] + Two's complement signed less than. + + It abbreviates: + {v + (or (and (= (extract[|m-1|:|m-1|] t1) bit1) + (= (extract[|m-1|:|m-1|] t2) bit0)) + (and (= (extract[|m-1|:|m-1|] t1) (extract[|m-1|:|m-1|] t2)) + (bvult t1 t2))) + v} + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvslt : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvslt" + +(** + Summary: \[ [ mk_bvule c t1 t2 ] \] + Unsigned less than or equal to. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvule : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvule" + +(** + Summary: \[ [ mk_bvsle c t1 t2 ] \] + Two's complement signed less than or equal to. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsle : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsle" + +(** + Summary: \[ [ mk_bvuge c t1 t2 ] \] + Unsigned greater than or equal to. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvuge : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvuge" + +(** + Summary: \[ [ mk_bvsge c t1 t2 ] \] + Two's complement signed greater than or equal to. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsge : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsge" + +(** + Summary: \[ [ mk_bvugt c t1 t2 ] \] + Unsigned greater than. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvugt : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvugt" + +(** + Summary: \[ [ mk_bvsgt c t1 t2 ] \] + Two's complement signed greater than. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsgt : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsgt" + +(** + Summary: \[ [ mk_concat c t1 t2 ] \] + Concatenate the given bit-vectors. + + The nodes [t1] and [t2] must have (possibly different) bit-vector sorts + + The result is a bit-vector of size {e n1+n2 }, where [n1] ([n2)] is the size + of [t1] ([t2)]. +*) +external mk_concat : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_concat" + +(** + Summary: \[ [ mk_extract c high low t1 ] \] + Extract the bits [high] down to [low] from a bitvector of + size [m] to yield a new bitvector of size [n], where {e n = + high - low + 1 }. + + The node [t1] must have a bit-vector sort. +*) +external mk_extract : context -> int -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_extract" + +(** + Summary: \[ [ mk_sign_ext c i t1 ] \] + Sign-extend of the given bit-vector to the (signed) equivalent bitvector of + size {e m+i }, where [m] is the size of the given + bit-vector. + + The node [t1] must have a bit-vector sort. +*) +external mk_sign_ext : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_sign_ext" + +(** + Summary: \[ [ mk_zero_ext c i t1 ] \] + Extend the given bit-vector with zeros to the (unsigned int) equivalent + bitvector of size {e m+i }, where [m] is the size of the + given bit-vector. + + The node [t1] must have a bit-vector sort. +*) +external mk_zero_ext : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_zero_ext" + +(** + Summary: \[ [ mk_repeat c i t1 ] \] + Repeat the given bit-vector up length {e i }. + + The node [t1] must have a bit-vector sort. +*) +external mk_repeat : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_repeat" + +(** + Summary: \[ [ mk_bvshl c t1 t2 ] \] + Shift left. + + It is equivalent to multiplication by {e 2^x } where [x] is the value of the + third argument. + + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the + programming language or assembly architecture you are modeling. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvshl : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvshl" + +(** + Summary: \[ [ mk_bvlshr c t1 t2 ] \] + Logical shift right. + + It is equivalent to unsigned int division by {e 2^x } where [x] is the + value of the third argument. + + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the + programming language or assembly architecture you are modeling. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvlshr : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvlshr" + +(** + Summary: \[ [ mk_bvashr c t1 t2 ] \] + Arithmetic shift right. + + It is like logical shift right except that the most significant + bits of the result always copy the most significant bit of the + second argument. + + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the + programming language or assembly architecture you are modeling. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvashr : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvashr" + +(** + Summary: \[ [ mk_rotate_left c i t1 ] \] + Rotate bits of [t1] to the left [i] times. + + The node [t1] must have a bit-vector sort. +*) +external mk_rotate_left : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_rotate_left" + +(** + Summary: \[ [ mk_rotate_right c i t1 ] \] + Rotate bits of [t1] to the right [i] times. + + The node [t1] must have a bit-vector sort. +*) +external mk_rotate_right : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_rotate_right" + +(** + Summary: \[ [ mk_ext_rotate_left c t1 t2 ] \] + Rotate bits of [t1] to the left [t2] times. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_ext_rotate_left : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_ext_rotate_left" + +(** + Summary: \[ [ mk_ext_rotate_right c t1 t2 ] \] + Rotate bits of [t1] to the right [t2] times. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_ext_rotate_right : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_ext_rotate_right" + +(** + Summary: \[ [ mk_int2bv c n t1 ] \] + Create an [n] bit bit-vector from the integer argument [t1]. + + NB. This function is essentially treated as uninterpreted. + So you cannot expect Z3 to precisely reflect the semantics of this function + when solving constraints with this function. + + The node [t1] must have integer sort. +*) +external mk_int2bv : context -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_int2bv" + +(** + Summary: \[ [ mk_bv2int c t1 is_signed ] \] + Create an integer from the bit-vector argument [t1]. + If [is_signed] is false, then the bit-vector [t1] is treated as unsigned int. + So the result is non-negative + and in the range {e [0..2^N-1] }, where N are the number of bits in [t1]. + If [is_signed] is true, [t1] is treated as a signed bit-vector. + + NB. This function is essentially treated as uninterpreted. + So you cannot expect Z3 to precisely reflect the semantics of this function + when solving constraints with this function. + + The node [t1] must have a bit-vector sort. +*) +external mk_bv2int : context -> ast -> bool -> ast + = "camlidl_z3V3_Z3_mk_bv2int" + +(** + Summary: \[ [ mk_bvadd_no_overflow c t1 t2 is_signed ] \] + Create a predicate that checks that the bit-wise addition + of [t1] and [t2] does not overflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvadd_no_overflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3V3_Z3_mk_bvadd_no_overflow" + +(** + Summary: \[ [ mk_bvadd_no_underflow c t1 t2 ] \] + Create a predicate that checks that the bit-wise signed addition + of [t1] and [t2] does not underflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvadd_no_underflow : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvadd_no_underflow" + +(** + Summary: \[ [ mk_bvsub_no_overflow c t1 t2 ] \] + Create a predicate that checks that the bit-wise signed subtraction + of [t1] and [t2] does not overflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsub_no_overflow : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsub_no_overflow" + +(** + Summary: \[ [ mk_bvsub_no_underflow c t1 t2 is_signed ] \] + Create a predicate that checks that the bit-wise subtraction + of [t1] and [t2] does not underflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsub_no_underflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3V3_Z3_mk_bvsub_no_underflow" + +(** + Summary: \[ [ mk_bvsdiv_no_overflow c t1 t2 ] \] + Create a predicate that checks that the bit-wise signed division + of [t1] and [t2] does not overflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvsdiv_no_overflow : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvsdiv_no_overflow" + +(** + Summary: \[ [ mk_bvneg_no_overflow c t1 ] \] + Check that bit-wise negation does not overflow when + [t1] is interpreted as a signed bit-vector. + + The node [t1] must have bit-vector sort. +*) +external mk_bvneg_no_overflow : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvneg_no_overflow" + +(** + Summary: \[ [ mk_bvmul_no_overflow c t1 t2 is_signed ] \] + Create a predicate that checks that the bit-wise multiplication + of [t1] and [t2] does not overflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvmul_no_overflow : context -> ast -> ast -> bool -> ast + = "camlidl_z3V3_Z3_mk_bvmul_no_overflow" + +(** + Summary: \[ [ mk_bvmul_no_underflow c t1 t2 ] \] + Create a predicate that checks that the bit-wise signed multiplication + of [t1] and [t2] does not underflow. + + The nodes [t1] and [t2] must have the same bit-vector sort. +*) +external mk_bvmul_no_underflow : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_bvmul_no_underflow" + +(** + {2 {L Arrays}} +*) +(** + Summary: \[ [ mk_select c a i ] \] + Array read. + The argument [a] is the array and [i] is the index of the array that gets read. + + The node [a] must have an array sort {e [domain -> range] }, + and [i] must have the sort [domain]. + The sort of the result is [range]. + + - {b See also}: {!mk_array_sort} + - {b See also}: {!mk_store} +*) +external mk_select : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_select" + +(** + Summary: \[ [ mk_store c a i v ] \] + Array update. + + The node [a] must have an array sort {e [domain -> range] }, [i] must have sort [domain], + [v] must have sort range. The sort of the result is {e [domain -> range] }. + The semantics of this function is given by the theory of arrays described in the SMT-LIB + standard. See http: + The result of this function is an array that is equal to [a] (with respect to [select)] + on all indices except for [i], where it maps to [v] (and the [select] of [a] with + respect to [i] may be a different value). + + - {b See also}: {!mk_array_sort} + - {b See also}: {!mk_select} +*) +external mk_store : context -> ast -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_store" + +(** + Summary: Create the constant array. + + The resulting term is an array, such that a [select] on an arbitrary index + produces the value [v]. + + @param c logical context. + @param domain domain sort for the array. + @param v value that the array maps to. +*) +external mk_const_array : context -> sort -> ast -> ast + = "camlidl_z3V3_Z3_mk_const_array" + +(** + Summary: \[ [ mk_map f n args ] \] + map f on the the argument arrays. + + The [n] nodes [args] must be of array sorts {e [domain_i -> range_i] }. + The function declaration [f] must have type {e range_1 .. range_n -> range }. + [v] must have sort range. The sort of the result is {e [domain_i -> range] }. + + - {b See also}: {!mk_array_sort} + - {b See also}: {!mk_store} + - {b See also}: {!mk_select} +*) +external mk_map : context -> func_decl -> int -> ast -> ast + = "camlidl_z3V3_Z3_mk_map" + +(** + Summary: Access the array default value. + Produces the default range value, for arrays that can be represented as + finite maps with a default range value. + + @param c logical context. + @param array array value whose default range value is accessed. + +*) +external mk_array_default : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_array_default" + +(** + {2 {L Sets}} +*) +(** + Summary: Create Set type. +*) +external mk_set_sort : context -> sort -> sort + = "camlidl_z3V3_Z3_mk_set_sort" + +(** + Summary: Create the empty set. +*) +external mk_empty_set : context -> sort -> ast + = "camlidl_z3V3_Z3_mk_empty_set" + +(** + Summary: Create the full set. +*) +external mk_full_set : context -> sort -> ast + = "camlidl_z3V3_Z3_mk_full_set" + +(** + Summary: Add an element to a set. + + The first argument must be a set, the second an element. +*) +external mk_set_add : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_add" + +(** + Summary: Remove an element to a set. + + The first argument must be a set, the second an element. +*) +external mk_set_del : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_del" + +(** + Summary: Take the union of a list of sets. +*) +external mk_set_union : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_set_union" + +(** + Summary: Take the intersection of a list of sets. +*) +external mk_set_intersect : context -> ast array -> ast + = "camlidl_z3V3_Z3_mk_set_intersect" + +(** + Summary: Take the set difference between two sets. +*) +external mk_set_difference : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_difference" + +(** + Summary: Take the complement of a set. +*) +external mk_set_complement : context -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_complement" + +(** + Summary: Check for set membership. + + The first argument should be an element type of the set. +*) +external mk_set_member : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_member" + +(** + Summary: Check for subsetness of sets. +*) +external mk_set_subset : context -> ast -> ast -> ast + = "camlidl_z3V3_Z3_mk_set_subset" + +(** + {2 {L Numerals}} +*) +(** + {4 {L Redundant low-level API}} +*) +(** + Summary: Create a numeral of a given sort. + + @param c logical context. + @param numeral A string representing the numeral value in decimal notation. If the given sort is a real, then the numeral can be a rational, that is, a string of the form {e [num]* / [num]* }. + @param ty The sort of the numeral. In the current implementation, the given sort can be an int, real, finite-domain, or bit-vectors of arbitrary size. + + - {b See also}: {!mk_int} + +*) +external mk_numeral : context -> string -> sort -> ast + = "camlidl_z3V3_Z3_mk_numeral" + +(** + Summary: Create a real from a fraction. + + @param c logical context. + @param num numerator of rational. + @param den denomerator of rational. + + - {b Precondition}: den != 0 + + - {b See also}: {!mk_numeral} + - {b See also}: {!mk_int} + +*) +external mk_real : context -> int -> int -> ast + = "camlidl_z3V3_Z3_mk_real" + +(** + Summary: Create a numeral of an int, bit-vector, or finite-domain sort. + + This function can be use to create numerals that fit in a machine integer. + It is slightly faster than {!mk_numeral} since it is not necessary to parse a string. + + - {b See also}: {!mk_numeral} +*) +external mk_int : context -> int -> sort -> ast + = "camlidl_z3V3_Z3_mk_int" + +(** + Summary: Create a numeral of a int, bit-vector, or finite-domain sort. + + This function can be use to create numerals that fit in a machine long long integer. + It is slightly faster than {!mk_numeral} since it is not necessary to parse a string. + + - {b See also}: {!mk_numeral} +*) +external mk_int64 : context -> int64 -> sort -> ast + = "camlidl_z3V3_Z3_mk_int64" + +(** + {2 {L Quantifiers}} +*) +(** + Summary: Create a pattern for quantifier instantiation. + + Z3 uses pattern matching to instantiate quantifiers. If a + pattern is not provided for a quantifier, then Z3 will + automatically compute a set of patterns for it. However, for + optimal performance, the user should provide the patterns. + + Patterns comprise a list of terms. The list should be + non-empty. If the list comprises of more than one term, it is + a called a multi-pattern. + + In general, one can pass in a list of (multi-)patterns in the + quantifier constructor. + + + - {b See also}: {!mk_forall} + - {b See also}: {!mk_exists} +*) +external mk_pattern : context -> ast array -> pattern + = "camlidl_z3V3_Z3_mk_pattern" + +(** + Summary: Create a bound variable. + + Bound variables are indexed by de-Bruijn indices. It is perhaps easiest to explain + the meaning of de-Bruijn indices by indicating the compilation process from + non-de-Bruijn formulas to de-Bruijn format. + + {v + abs(forall (x1) phi) = forall (x1) abs1(phi, x1, 0) + abs(forall (x1, x2) phi) = abs(forall (x1) abs(forall (x2) phi)) + abs1(x, x, n) = b_n + abs1(y, x, n) = y + abs1(f(t1,...,tn), x, n) = f(abs1(t1,x,n), ..., abs1(tn,x,n)) + abs1(forall (x1) phi, x, n) = forall (x1) (abs1(phi, x, n+1)) + v} + + The last line is significant: the index of a bound variable is different depending + on the scope in which it appears. The deeper x appears, the higher is its + index. + + @param c logical context + @param index de-Bruijn index + @param ty sort of the bound variable + + - {b See also}: {!mk_forall} + - {b See also}: {!mk_exists} +*) +external mk_bound : context -> int -> sort -> ast + = "camlidl_z3V3_Z3_mk_bound" + +(** + Summary: Create a forall formula. It takes an expression [body] that contains bound variables + of the same sorts as the sorts listed in the array [sorts]. The bound variables are de-Bruijn indices created + using {!mk_bound}. The array [decl_names] contains the names that the quantified formula uses for the + bound variables. Z3 applies the convention that the last element in the [decl_names] and [sorts] array + refers to the variable with index 0, the second to last element of [decl_names] and [sorts] refers + to the variable with index 1, etc. + + + [mk_forall c w p t n b] creates a forall formula, where + [w] is the weight, [p] is an array of patterns, [t] is an array + with the sorts of the bound variables, [n] is an array with the + 'names' of the bound variables, and [b] is the body of the + quantifier. Quantifiers are associated with weights indicating + the importance of using the quantifier during + instantiation. + + + @param c logical context. + @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. + @param num_patterns number of patterns. + @param patterns array containing the patterns created using {!mk_pattern}. + @param num_decls number of variables to be bound. + @param sorts the sorts of the bound variables. + @param decl_names names of the bound variables + @param body the body of the quantifier. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_bound} + - {b See also}: {!mk_exists} +*) +external mk_forall : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_forall_bytecode" "camlidl_z3V3_Z3_mk_forall" + +(** + Summary: Create an exists formula. Similar to {!mk_forall}. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_bound} + - {b See also}: {!mk_forall} + - {b See also}: {!mk_quantifier} +*) +external mk_exists : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_exists_bytecode" "camlidl_z3V3_Z3_mk_exists" + +(** + Summary: Create a quantifier - universal or existential, with pattern hints. + See the documentation for {!mk_forall} for an explanation of the parameters. + + @param c logical context. + @param is_forall flag to indicate if this is a universal or existential quantifier. + @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. + @param num_patterns number of patterns. + @param patterns array containing the patterns created using {!mk_pattern}. + @param num_decls number of variables to be bound. + @param sorts array of sorts of the bound variables. + @param decl_names names of the bound variables. + @param body the body of the quantifier. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_bound} + - {b See also}: {!mk_forall} + - {b See also}: {!mk_exists} +*) +external mk_quantifier : context -> bool -> int -> pattern array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_bytecode" "camlidl_z3V3_Z3_mk_quantifier" + +(** + Summary: Create a quantifier - universal or existential, with pattern hints, no patterns, and attributes + + @param c logical context. + @param is_forall flag to indicate if this is a universal or existential quantifier. + @param quantifier_id identifier to identify quantifier + @param skolem_id identifier to identify skolem constants introduced by quantifier. + @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. + @param num_patterns number of patterns. + @param patterns array containing the patterns created using {!mk_pattern}. + @param num_no_patterns number of patterns. + @param no_patterns array containing the patterns created using {!mk_pattern}. + @param num_decls number of variables to be bound. + @param sorts array of sorts of the bound variables. + @param decl_names names of the bound variables. + @param body the body of the quantifier. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_bound} + - {b See also}: {!mk_forall} + - {b See also}: {!mk_exists} +*) +external mk_quantifier_ex : context -> bool -> int -> symbol -> symbol -> pattern array -> ast array -> sort array -> symbol array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_ex" + +(** + Summary: Create a universal quantifier using a list of constants that + will form the set of bound variables. + + @param c logical context. + @param weight quantifiers are associated with weights indicating the importance of using + the quantifier during instantiation. By default, pass the weight 0. + @param num_bound number of constants to be abstracted into bound variables. + @param bound array of constants to be abstracted into bound variables. + @param num_patterns number of patterns. + @param patterns array containing the patterns created using {!mk_pattern}. + @param body the body of the quantifier. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_exists_const} + +*) +external mk_forall_const : context -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3V3_Z3_mk_forall_const" + +(** + Summary: Similar to {!mk_forall_const}. + + Summary: Create an existential quantifier using a list of constants that + will form the set of bound variables. + + @param c logical context. + @param weight quantifiers are associated with weights indicating the importance of using + the quantifier during instantiation. By default, pass the weight 0. + @param num_bound number of constants to be abstracted into bound variables. + @param bound array of constants to be abstracted into bound variables. + @param num_patterns number of patterns. + @param patterns array containing the patterns created using {!mk_pattern}. + @param body the body of the quantifier. + + - {b See also}: {!mk_pattern} + - {b See also}: {!mk_forall_const} +*) +external mk_exists_const : context -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3V3_Z3_mk_exists_const" + +(** + Summary: Create a universal or existential + quantifier using a list of constants that + will form the set of bound variables. +*) +external mk_quantifier_const : context -> bool -> int -> app array -> pattern array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_const_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const" + +(** + Summary: Create a universal or existential + quantifier using a list of constants that + will form the set of bound variables. +*) +external mk_quantifier_const_ex : context -> bool -> int -> symbol -> symbol -> app array -> pattern array -> ast array -> ast -> ast + = "camlidl_z3_Z3_mk_quantifier_const_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const_ex" + +(** + {2 {L Accessors}} +*) +(** + {3 {L Symbols}} +*) +(** + {4 {L Redundant low-level API}} +*) +(** + Summary: Return [INT_SYMBOL] if the symbol was constructed + using {!mk_int_symbol}, and [STRING_SYMBOL] if the symbol + was constructed using {!mk_string_symbol}. +*) +external get_symbol_kind : context -> symbol -> symbol_kind + = "camlidl_z3V3_Z3_get_symbol_kind" + +(** + Summary: \[ [ get_symbol_int c s ] \] + Return the symbol int value. + + - {b Precondition}: get_symbol_kind s == INT_SYMBOL + + - {b See also}: {!mk_int_symbol} +*) +external get_symbol_int : context -> symbol -> int + = "camlidl_z3V3_Z3_get_symbol_int" + +(** + Summary: \[ [ get_symbol_string c s ] \] + Return the symbol name. + + - {b Precondition}: get_symbol_string s == STRING_SYMBOL + + + + + + - {b See also}: {!mk_string_symbol} +*) +external get_symbol_string : context -> symbol -> string + = "camlidl_z3V3_Z3_get_symbol_string" + +(** + {3 {L Sorts}} +*) +(** + Summary: Return the sort name as a symbol. +*) +external get_sort_name : context -> sort -> symbol + = "camlidl_z3V3_Z3_get_sort_name" + +(** + Summary: Return a unique identifier for [s]. + - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. +*) +external get_sort_id : context -> sort -> int + = "camlidl_z3V3_Z3_get_sort_id" + +(** + {4 {L Redundant low-level API}} +*) +(** + Summary: Convert a [sort] into [ast]. + - {b Remarks}: [sort_to_ast c s] can be replaced by [(s :> ast)]. +*) +external sort_to_ast : context -> sort -> ast + = "camlidl_z3V3_Z3_sort_to_ast" + +(** + Summary: compare sorts. + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. +*) +external is_eq_sort : context -> sort -> sort -> bool + = "camlidl_z3V3_Z3_is_eq_sort" + +(** + Summary: Return the sort kind (e.g., array, tuple, int, bool, etc). + + - {b See also}: {!sort_kind} +*) +external get_sort_kind : context -> sort -> sort_kind + = "camlidl_z3V3_Z3_get_sort_kind" + +(** + Summary: \[ [ get_bv_sort_size c t ] \] + Return the size of the given bit-vector sort. + + - {b Precondition}: get_sort_kind c t == BV_SORT + + - {b See also}: {!mk_bv_sort} + - {b See also}: {!get_sort_kind} +*) +external get_bv_sort_size : context -> sort -> int + = "camlidl_z3V3_Z3_get_bv_sort_size" + +(** + + Summary: Return the size of the sort in [r]. Return [None] if the call failed. + That is, get_sort_kind(s) == FINITE_DOMAIN_SORT +*) +external get_finite_domain_sort_size : context -> sort -> int64 option + = "camlidl_z3V3_Z3_get_finite_domain_sort_size" + +(** + Summary: \[ [ get_array_sort_domain c t ] \] + Return the domain of the given array sort. + + - {b Precondition}: get_sort_kind c t == ARRAY_SORT + + - {b See also}: {!mk_array_sort} + - {b See also}: {!get_sort_kind} +*) +external get_array_sort_domain : context -> sort -> sort + = "camlidl_z3V3_Z3_get_array_sort_domain" + +(** + Summary: \[ [ get_array_sort_range c t ] \] + Return the range of the given array sort. + + - {b Precondition}: get_sort_kind c t == ARRAY_SORT + + - {b See also}: {!mk_array_sort} + - {b See also}: {!get_sort_kind} +*) +external get_array_sort_range : context -> sort -> sort + = "camlidl_z3V3_Z3_get_array_sort_range" + +(** + Summary: \[ [ get_tuple_sort_mk_decl c t ] \] + Return the constructor declaration of the given tuple + sort. + + - {b Precondition}: get_sort_kind c t == DATATYPE_SORT + + - {b See also}: {!mk_tuple_sort} + - {b See also}: {!get_sort_kind} +*) +external get_tuple_sort_mk_decl : context -> sort -> func_decl + = "camlidl_z3V3_Z3_get_tuple_sort_mk_decl" + +(** + Summary: \[ [ get_tuple_sort_num_fields c t ] \] + Return the number of fields of the given tuple sort. + + - {b Precondition}: get_sort_kind c t == DATATYPE_SORT + + - {b See also}: {!mk_tuple_sort} + - {b See also}: {!get_sort_kind} +*) +external get_tuple_sort_num_fields : context -> sort -> int + = "camlidl_z3V3_Z3_get_tuple_sort_num_fields" + +(** + Summary: \[ [ get_tuple_sort_field_decl c t i ] \] + Return the i-th field declaration (i.e., projection function declaration) + of the given tuple sort. + + - {b Precondition}: get_sort_kind t == DATATYPE_SORT + - {b Precondition}: i < get_tuple_sort_num_fields c t + + - {b See also}: {!mk_tuple_sort} + - {b See also}: {!get_sort_kind} +*) +external get_tuple_sort_field_decl : context -> sort -> int -> func_decl + = "camlidl_z3V3_Z3_get_tuple_sort_field_decl" + +(** + Summary: Return number of constructors for datatype. + + - {b Precondition}: get_sort_kind t == DATATYPE_SORT + + - {b See also}: {!get_datatype_sort_constructor} + - {b See also}: {!get_datatype_sort_recognizer} + - {b See also}: {!get_datatype_sort_constructor_accessor} + +*) +external get_datatype_sort_num_constructors : context -> sort -> int + = "camlidl_z3V3_Z3_get_datatype_sort_num_constructors" + +(** + Summary: Return idx'th constructor. + + - {b Precondition}: get_sort_kind t == DATATYPE_SORT + - {b Precondition}: idx < get_datatype_sort_num_constructors c t + + - {b See also}: {!get_datatype_sort_num_constructors} + - {b See also}: {!get_datatype_sort_recognizer} + - {b See also}: {!get_datatype_sort_constructor_accessor} + +*) +external get_datatype_sort_constructor : context -> sort -> int -> func_decl + = "camlidl_z3V3_Z3_get_datatype_sort_constructor" + +(** + Summary: Return idx'th recognizer. + + - {b Precondition}: get_sort_kind t == DATATYPE_SORT + - {b Precondition}: idx < get_datatype_sort_num_constructors c t + + - {b See also}: {!get_datatype_sort_num_constructors} + - {b See also}: {!get_datatype_sort_constructor} + - {b See also}: {!get_datatype_sort_constructor_accessor} + +*) +external get_datatype_sort_recognizer : context -> sort -> int -> func_decl + = "camlidl_z3V3_Z3_get_datatype_sort_recognizer" + +(** + Summary: Return idx_a'th accessor for the idx_c'th constructor. + + - {b Precondition}: get_sort_kind t == DATATYPE_SORT + - {b Precondition}: idx_c < get_datatype_sort_num_constructors c t + - {b Precondition}: idx_a < get_domain_size c get_datatype_sort_constructor c idx_c + + - {b See also}: {!get_datatype_sort_num_constructors} + - {b See also}: {!get_datatype_sort_constructor} + - {b See also}: {!get_datatype_sort_recognizer} +*) +external get_datatype_sort_constructor_accessor : context -> sort -> int -> int -> func_decl + = "camlidl_z3V3_Z3_get_datatype_sort_constructor_accessor" + +(** + Summary: Return arity of relation. + + - {b Precondition}: get_sort_kind s == RELATION_SORT + + - {b See also}: {!get_relation_column} +*) +external get_relation_arity : context -> sort -> int + = "camlidl_z3V3_Z3_get_relation_arity" + +(** + Summary: Return sort at i'th column of relation sort. + + - {b Precondition}: get_sort_kind c s == RELATION_SORT + - {b Precondition}: col < get_relation_arity c s + + - {b See also}: {!get_relation_arity} +*) +external get_relation_column : context -> sort -> int -> sort + = "camlidl_z3V3_Z3_get_relation_column" + +(** + {3 {L Function Declarations}} +*) +(** + Summary: Convert a [func_decl] into [ast]. + - {b Remarks}: [func_decl_to_ast c f] can be replaced by [(f :> ast)]. +*) +external func_decl_to_ast : context -> func_decl -> ast + = "camlidl_z3V3_Z3_func_decl_to_ast" + +(** + Summary: compare terms. + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. +*) +external is_eq_func_decl : context -> func_decl -> func_decl -> bool + = "camlidl_z3V3_Z3_is_eq_func_decl" + +(** + Summary: Return a unique identifier for [f]. + - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. +*) +external get_func_decl_id : context -> func_decl -> int + = "camlidl_z3V3_Z3_get_func_decl_id" + +(** + Summary: Return the constant declaration name as a symbol. +*) +external get_decl_name : context -> func_decl -> symbol + = "camlidl_z3V3_Z3_get_decl_name" + +(** + Summary: Return declaration kind corresponding to declaration. +*) +external get_decl_kind : context -> func_decl -> decl_kind + = "camlidl_z3V3_Z3_get_decl_kind" + +(** + Summary: Return the number of parameters of the given declaration. + + - {b See also}: {!get_arity} +*) +external get_domain_size : context -> func_decl -> int + = "camlidl_z3V3_Z3_get_domain_size" + +(** + Summary: Alias for [get_domain_size]. + + - {b See also}: {!get_domain_size} +*) +external get_arity : context -> func_decl -> int + = "camlidl_z3V3_Z3_get_arity" + +(** + Summary: \[ [ get_domain c d i ] \] + Return the sort of the i-th parameter of the given function declaration. + + - {b Precondition}: i < get_domain_size d + + - {b See also}: {!get_domain_size} +*) +external get_domain : context -> func_decl -> int -> sort + = "camlidl_z3V3_Z3_get_domain" + +(** + Summary: \[ [ get_range c d ] \] + Return the range of the given declaration. + + If [d] is a constant (i.e., has zero arguments), then this + function returns the sort of the constant. +*) +external get_range : context -> func_decl -> sort + = "camlidl_z3V3_Z3_get_range" + +(** + Summary: Return the number of parameters associated with a declaration. +*) +external get_decl_num_parameters : context -> func_decl -> int + = "camlidl_z3V3_Z3_get_decl_num_parameters" + +(** + Summary: Return the parameter type associated with a declaration. + + @param c the context + @param d the function declaration + @param idx is the index of the named parameter it should be between 0 and the number of parameters. +*) +external get_decl_parameter_kind : context -> func_decl -> int -> parameter_kind + = "camlidl_z3V3_Z3_get_decl_parameter_kind" + +(** + Summary: Return the integer value associated with an integer parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_INT +*) +external get_decl_int_parameter : context -> func_decl -> int -> int + = "camlidl_z3V3_Z3_get_decl_int_parameter" + +(** + Summary: Return the double value associated with an double parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_DOUBLE +*) +external get_decl_double_parameter : context -> func_decl -> int -> float + = "camlidl_z3V3_Z3_get_decl_double_parameter" + +(** + Summary: Return the double value associated with an double parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_SYMBOL +*) +external get_decl_symbol_parameter : context -> func_decl -> int -> symbol + = "camlidl_z3V3_Z3_get_decl_symbol_parameter" + +(** + Summary: Return the sort value associated with a sort parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_SORT +*) +external get_decl_sort_parameter : context -> func_decl -> int -> sort + = "camlidl_z3V3_Z3_get_decl_sort_parameter" + +(** + Summary: Return the expresson value associated with an expression parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_AST +*) +external get_decl_ast_parameter : context -> func_decl -> int -> ast + = "camlidl_z3V3_Z3_get_decl_ast_parameter" + +(** + Summary: Return the expresson value associated with an expression parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_FUNC_DECL +*) +external get_decl_func_decl_parameter : context -> func_decl -> int -> func_decl + = "camlidl_z3V3_Z3_get_decl_func_decl_parameter" + +(** + Summary: Return the rational value, as a string, associated with a rational parameter. + + - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_RATIONAL +*) +external get_decl_rational_parameter : context -> func_decl -> int -> string + = "camlidl_z3V3_Z3_get_decl_rational_parameter" + +(** + {3 {L Applications}} +*) +(** + Summary: Convert a [app] into [ast]. + - {b Remarks}: [app_to_ast c a] can be replaced by [(a :> ast)]. +*) +external app_to_ast : context -> app -> ast + = "camlidl_z3V3_Z3_app_to_ast" + +(** + Summary: Return the declaration of a constant or function application. +*) +external get_app_decl : context -> app -> func_decl + = "camlidl_z3V3_Z3_get_app_decl" + +(** + Summary: \[ [ get_app_num_args c a ] \] + Return the number of argument of an application. If [t] + is an constant, then the number of arguments is 0. +*) +external get_app_num_args : context -> app -> int + = "camlidl_z3V3_Z3_get_app_num_args" + +(** + Summary: \[ [ get_app_arg c a i ] \] + Return the i-th argument of the given application. + + - {b Precondition}: i < get_num_args c a +*) +external get_app_arg : context -> app -> int -> ast + = "camlidl_z3V3_Z3_get_app_arg" + +(** + {3 {L Terms}} +*) +(** + Summary: compare terms. + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. +*) +external is_eq_ast : context -> ast -> ast -> bool + = "camlidl_z3V3_Z3_is_eq_ast" + +(** + Summary: Return a unique identifier for [t]. + - {b Remarks}: Implicitly used by [Pervasives.compare] for values of type [ast], [app], [sort], [func_decl], and [pattern]. +*) +external get_ast_id : context -> ast -> int + = "camlidl_z3V3_Z3_get_ast_id" + +(** + Summary: Return a hash code for the given AST. + - {b Remarks}: Implicitly used by [Hashtbl.hash] for values of type [ast], [app], [sort], [func_decl], and [pattern]. +*) +external get_ast_hash : context -> ast -> int + = "camlidl_z3V3_Z3_get_ast_hash" + +(** + Summary: Return the sort of an AST node. + + The AST node must be a constant, application, numeral, bound variable, or quantifier. + +*) +external get_sort : context -> ast -> sort + = "camlidl_z3V3_Z3_get_sort" + +(** + Summary: Return true if the given expression [t] is well sorted. +*) +external is_well_sorted : context -> ast -> bool + = "camlidl_z3V3_Z3_is_well_sorted" + +(** + Summary: Return L_TRUE if [a] is true, L_FALSE if it is false, and L_UNDEF otherwise. +*) +external get_bool_value : context -> ast -> lbool + = "camlidl_z3V3_Z3_get_bool_value" + +(** + Summary: Return the kind of the given AST. +*) +external get_ast_kind : context -> ast -> ast_kind + = "camlidl_z3V3_Z3_get_ast_kind" + +external is_app : context -> ast -> bool + = "camlidl_z3V3_Z3_is_app" + +external is_numeral_ast : context -> ast -> bool + = "camlidl_z3V3_Z3_is_numeral_ast" + +(** + Summary: Return true if the give AST is a real algebraic number. +*) +external is_algebraic_number : context -> ast -> bool + = "camlidl_z3V3_Z3_is_algebraic_number" + +(** + Summary: Convert an [ast] into an [APP_AST]. + + - {b Precondition}: {v get_ast_kind c a == [APP_AST] v} +*) +external to_app : context -> ast -> app + = "camlidl_z3V3_Z3_to_app" + +(** + Summary: Convert an AST into a FUNC_DECL_AST. This is just type casting. + + - {b Precondition}: {v get_ast_kind c a == FUNC_DECL_AST v} +*) +external to_func_decl : context -> ast -> func_decl + = "camlidl_z3V3_Z3_to_func_decl" + +(** + {4 {L Numerals}} +*) +(** + {5 {L Low-level API}} +*) +(** + Summary: Return numeral value, as a string of a numeric constant term + + - {b Precondition}: get_ast_kind c a == NUMERAL_AST +*) +external get_numeral_string : context -> ast -> string + = "camlidl_z3V3_Z3_get_numeral_string" + +(** + Summary: Return numeral as a string in decimal notation. + The result has at most [precision] decimal places. + + - {b Precondition}: get_ast_kind c a == NUMERAL_AST || is_algebraic_number c a +*) +external get_numeral_decimal_string : context -> ast -> int -> string + = "camlidl_z3V3_Z3_get_numeral_decimal_string" + +(** + Summary: Return the numerator (as a numeral AST) of a numeral AST of sort Real. + + - {b Precondition}: get_ast_kind c a == NUMERAL_AST +*) +external get_numerator : context -> ast -> ast + = "camlidl_z3V3_Z3_get_numerator" + +(** + Summary: Return the denominator (as a numeral AST) of a numeral AST of sort Real. + + - {b Precondition}: get_ast_kind c a == NUMERAL_AST +*) +external get_denominator : context -> ast -> ast + = "camlidl_z3V3_Z3_get_denominator" + +(** + Summary: Return numeral value, as a pair of 64 bit numbers if the representation fits. + + @param c logical context. + @param a term. + @param num numerator. + @param den denominator. + + Return [TRUE] if the numeral value fits in 64 bit numerals, [FALSE] otherwise. + + - {b Precondition}: get_ast_kind a == NUMERAL_AST +*) +external get_numeral_small : context -> ast -> bool * int64 * int64 + = "camlidl_z3V3_Z3_get_numeral_small" + +(** + Summary: \[ [ get_numeral_int c v ] \] + Similar to {!get_numeral_string}, but only succeeds if + the value can fit in a machine int. Return TRUE if the call succeeded. + + - {b Precondition}: get_ast_kind c v == NUMERAL_AST + + - {b See also}: {!get_numeral_string} +*) +external get_numeral_int : context -> ast -> bool * int + = "camlidl_z3V3_Z3_get_numeral_int" + +(** + Summary: \[ [ get_numeral_int64 c v ] \] + Similar to {!get_numeral_string}, but only succeeds if + the value can fit in a machine long long int. Return TRUE if the call succeeded. + + - {b Precondition}: get_ast_kind c v == NUMERAL_AST + + - {b See also}: {!get_numeral_string} +*) +external get_numeral_int64 : context -> ast -> bool * int64 + = "camlidl_z3V3_Z3_get_numeral_int64" + +(** + Summary: \[ [ get_numeral_rational_int64 c x y] \] + Similar to {!get_numeral_string}, but only succeeds if + the value can fit as a rational number as machine long long int. Return TRUE if the call succeeded. + + - {b Precondition}: get_ast_kind c v == NUMERAL_AST + + - {b See also}: {!get_numeral_string} +*) +external get_numeral_rational_int64 : context -> ast -> bool * int64 * int64 + = "camlidl_z3V3_Z3_get_numeral_rational_int64" + +(** + Summary: Return a lower bound for the given real algebraic number. + The interval isolating the number is smaller than 1/10^precision. + The result is a numeral AST of sort Real. + + - {b Precondition}: is_algebraic_number c a +*) +external get_algebraic_number_lower : context -> ast -> int -> ast + = "camlidl_z3V3_Z3_get_algebraic_number_lower" + +(** + Summary: Return a upper bound for the given real algebraic number. + The interval isolating the number is smaller than 1/10^precision. + The result is a numeral AST of sort Real. + + - {b Precondition}: is_algebraic_number c a +*) +external get_algebraic_number_upper : context -> ast -> int -> ast + = "camlidl_z3V3_Z3_get_algebraic_number_upper" + +(** + {4 {L Patterns}} +*) +(** + Summary: Convert a pattern into ast. + - {b Remarks}: [pattern_to_ast c p] can be replaced by [(p :> ast)]. +*) +external pattern_to_ast : context -> pattern -> ast + = "camlidl_z3V3_Z3_pattern_to_ast" + +(** + Summary: Return number of terms in pattern. +*) +external get_pattern_num_terms : context -> pattern -> int + = "camlidl_z3V3_Z3_get_pattern_num_terms" + +(** + Summary: Return i'th ast in pattern. +*) +external get_pattern : context -> pattern -> int -> ast + = "camlidl_z3V3_Z3_get_pattern" + +(** + {4 {L Quantifiers}} +*) +(** + Summary: Return index of de-Brujin bound variable. + + - {b Precondition}: get_ast_kind a == VAR_AST +*) +external get_index_value : context -> ast -> int + = "camlidl_z3V3_Z3_get_index_value" + +(** + Summary: Determine if quantifier is universal. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external is_quantifier_forall : context -> ast -> bool + = "camlidl_z3V3_Z3_is_quantifier_forall" + +(** + Summary: Obtain weight of quantifier. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_weight : context -> ast -> int + = "camlidl_z3V3_Z3_get_quantifier_weight" + +(** + Summary: Return number of patterns used in quantifier. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_num_patterns : context -> ast -> int + = "camlidl_z3V3_Z3_get_quantifier_num_patterns" + +(** + Summary: Return i'th pattern. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_pattern_ast : context -> ast -> int -> pattern + = "camlidl_z3V3_Z3_get_quantifier_pattern_ast" + +(** + Summary: Return number of no_patterns used in quantifier. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_num_no_patterns : context -> ast -> int + = "camlidl_z3V3_Z3_get_quantifier_num_no_patterns" + +(** + Summary: Return i'th no_pattern. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_no_pattern_ast : context -> ast -> int -> ast + = "camlidl_z3V3_Z3_get_quantifier_no_pattern_ast" + +(** + Summary: Return symbol of the i'th bound variable. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_bound_name : context -> ast -> int -> symbol + = "camlidl_z3V3_Z3_get_quantifier_bound_name" + +(** + Summary: Return sort of the i'th bound variable. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_bound_sort : context -> ast -> int -> sort + = "camlidl_z3V3_Z3_get_quantifier_bound_sort" + +(** + Summary: Return body of quantifier. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_body : context -> ast -> ast + = "camlidl_z3V3_Z3_get_quantifier_body" + +(** + Summary: Return number of bound variables of quantifier. + + - {b Precondition}: get_ast_kind a == QUANTIFIER_AST +*) +external get_quantifier_num_bound : context -> ast -> int + = "camlidl_z3V3_Z3_get_quantifier_num_bound" + +(** + {3 {L Simplification}} +*) +(** + Summary: Interface to simplifier. + + Provides an interface to the AST simplifier used by Z3. +*) +external simplify : context -> ast -> ast + = "camlidl_z3V3_Z3_simplify" + +(** + {2 {L Modifiers}} +*) +(** + Summary: Update the arguments of term [a] using the arguments [args]. + The number of arguments [num_args] should coincide + with the number of arguments to [a]. + If [a] is a quantifier, then num_args has to be 1. +*) +external update_term : context -> ast -> ast array -> ast + = "camlidl_z3V3_Z3_update_term" + +(** + Summary: Substitute every occurrence of {e from[i] } in [a] with {e to[i] }, for [i] smaller than [num_exprs]. + The result is the new AST. The arrays [from] and [to] must have size [num_exprs]. + For every [i] smaller than [num_exprs], we must have that sort of {e from[i] } must be equal to sort of {e to[i] }. +*) +external substitute : context -> ast -> ast array -> ast array -> ast + = "camlidl_z3V3_Z3_substitute" + +(** + Summary: Substitute the free variables in [a] with the expressions in [to]. + For every [i] smaller than [num_exprs], the variable with de-Bruijn index [i] is replaced with term {e to[i] }. +*) +external substitute_vars : context -> ast -> ast array -> ast + = "camlidl_z3V3_Z3_substitute_vars" + +(** + {2 {L Interaction logging.}} +*) +(** + Summary: Log interaction to a file. +*) +external open_log : string -> bool + = "camlidl_z3V3_Z3_open_log" + +(** + Summary: Append user-defined string to interaction log. + + The interaction log is opened using open_log. + It contains the formulas that are checked using Z3. + You can use this command to append comments, for instance. +*) +external append_log : string -> unit + = "camlidl_z3V3_Z3_append_log" + +(** + Summary: Close interaction log. +*) +external close_log : unit -> unit + = "camlidl_z3V3_Z3_close_log" + +(** + Summary: Enable/disable printing warning messages to the console. + + Warnings are printed after passing [true], warning messages are + suppressed after calling this method with [false]. +*) +external toggle_warning_messages : bool -> unit + = "camlidl_z3V3_Z3_toggle_warning_messages" + +(** + {2 {L String conversion}} +*) +(** + Summary: Select mode for the format used for pretty-printing AST nodes. + + The default mode for pretty printing AST nodes is to produce + SMT-LIB style output where common subexpressions are printed + at each occurrence. The mode is called PRINT_SMTLIB_FULL. + To print shared common subexpressions only once, + use the PRINT_LOW_LEVEL mode. + To print in way that conforms to SMT-LIB standards and uses let + expressions to share common sub-expressions use PRINT_SMTLIB_COMPLIANT. + + - {b See also}: {!ast_to_string} + - {b See also}: {!pattern_to_string} + - {b See also}: {!func_decl_to_string} + +*) +external set_ast_print_mode : context -> ast_print_mode -> unit + = "camlidl_z3V3_Z3_set_ast_print_mode" + +(** + Summary: Convert the given AST node into a string. + + + + + - {b See also}: {!pattern_to_string} + - {b See also}: {!sort_to_string} +*) +external ast_to_string : context -> ast -> string + = "camlidl_z3V3_Z3_ast_to_string" + +external pattern_to_string : context -> pattern -> string + = "camlidl_z3V3_Z3_pattern_to_string" + +external sort_to_string : context -> sort -> string + = "camlidl_z3V3_Z3_sort_to_string" + +external func_decl_to_string : context -> func_decl -> string + = "camlidl_z3V3_Z3_func_decl_to_string" + +(** + Summary: Convert the given model into a string. + + + + +*) +external model_to_string : context -> model -> string + = "camlidl_z3V3_Z3_model_to_string" + +(** + Summary: Convert the given benchmark into SMT-LIB formatted string. + + + + + + @param c - context. + @param name - name of benchmark. The argument is optional. + @param logic - the benchmark logic. + @param status - the status string (sat, unsat, or unknown) + @param attributes - other attributes, such as source, difficulty or category. + @param num_assumptions - number of assumptions. + @param assumptions - auxiliary assumptions. + @param formula - formula to be checked for consistency in conjunction with assumptions. +*) +external benchmark_to_smtlib_string : context -> string -> string -> string -> string -> ast array -> ast -> string + = "camlidl_z3_Z3_benchmark_to_smtlib_string_bytecode" "camlidl_z3V3_Z3_benchmark_to_smtlib_string" + +(** + {2 {L Parser interface}} +*) +(** + Summary: \[ [ parse_smtlib2_string c str ] \] + Parse the given string using the SMT-LIB2 parser. + + It returns a formula comprising of the conjunction of assertions in the scope + (up to push/pop) at the end of the string. +*) +external parse_smtlib2_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + = "camlidl_z3_Z3_parse_smtlib2_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_string" + +(** + Summary: Similar to {!parse_smtlib2_string}, but reads the benchmark from a file. +*) +external parse_smtlib2_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + = "camlidl_z3_Z3_parse_smtlib2_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_file" + +(** + {4 {L Low-level API}} +*) +(** + Summary: \[ [ parse_smtlib_string c str sort_names sorts decl_names decls ] \] + Parse the given string using the SMT-LIB parser. + + The symbol table of the parser can be initialized using the given sorts and declarations. + The symbols in the arrays [sort_names] and [decl_names] don't need to match the names + of the sorts and declarations in the arrays [sorts] and [decls]. This is an useful feature + since we can use arbitrary names to reference sorts and declarations defined using the C API. + + The formulas, assumptions and declarations defined in [str] can be extracted using the functions: + {!get_smtlib_num_formulas}, {!get_smtlib_formula}, {!get_smtlib_num_assumptions}, {!get_smtlib_assumption}, + {!get_smtlib_num_decls}, and {!get_smtlib_decl}. +*) +external parse_smtlib_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit + = "camlidl_z3_Z3_parse_smtlib_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib_string" + +(** + Summary: Similar to {!parse_smtlib_string}, but reads the benchmark from a file. +*) +external parse_smtlib_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit + = "camlidl_z3_Z3_parse_smtlib_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib_file" + +(** + Summary: Return the number of SMTLIB formulas parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. +*) +external get_smtlib_num_formulas : context -> int + = "camlidl_z3V3_Z3_get_smtlib_num_formulas" + +(** + Summary: \[ [ get_smtlib_formula c i ] \] + Return the i-th formula parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + - {b Precondition}: i < get_smtlib_num_formulas c +*) +external get_smtlib_formula : context -> int -> ast + = "camlidl_z3V3_Z3_get_smtlib_formula" + +(** + Summary: Return the number of SMTLIB assumptions parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. +*) +external get_smtlib_num_assumptions : context -> int + = "camlidl_z3V3_Z3_get_smtlib_num_assumptions" + +(** + Summary: \[ [ get_smtlib_assumption c i ] \] + Return the i-th assumption parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + - {b Precondition}: i < get_smtlib_num_assumptions c +*) +external get_smtlib_assumption : context -> int -> ast + = "camlidl_z3V3_Z3_get_smtlib_assumption" + +(** + Summary: Return the number of declarations parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. +*) +external get_smtlib_num_decls : context -> int + = "camlidl_z3V3_Z3_get_smtlib_num_decls" + +(** + Summary: \[ [ get_smtlib_decl c i ] \] + Return the i-th declaration parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + - {b Precondition}: i < get_smtlib_num_decls c +*) +external get_smtlib_decl : context -> int -> func_decl + = "camlidl_z3V3_Z3_get_smtlib_decl" + +(** + Summary: Return the number of sorts parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. +*) +external get_smtlib_num_sorts : context -> int + = "camlidl_z3V3_Z3_get_smtlib_num_sorts" + +(** + Summary: \[ [ get_smtlib_sort c i ] \] + Return the i-th sort parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + - {b Precondition}: i < get_smtlib_num_sorts c +*) +external get_smtlib_sort : context -> int -> sort + = "camlidl_z3V3_Z3_get_smtlib_sort" + +(** + Summary: \[ [ get_smtlib_error c ] \] + Retrieve that last error message information generated from parsing. +*) +external get_smtlib_error : context -> string + = "camlidl_z3V3_Z3_get_smtlib_error" + +(** + Summary: \[ [ parse_z3_string c str ] \] + Parse the given string using the Z3 native parser. + + Return the conjunction of asserts made in the input. +*) +external parse_z3_string : context -> string -> ast + = "camlidl_z3_Z3_parse_z3V3_string" + +(** + Summary: Similar to {!parse_z3_string}, but reads the benchmark from a file. +*) +external parse_z3_file : context -> string -> ast + = "camlidl_z3_Z3_parse_z3V3_file" + +(** + {2 {L Miscellaneous}} +*) +(** + Summary: Return Z3 version number information. +*) +external get_version : unit -> int * int * int * int + = "camlidl_z3V3_Z3_get_version" + +(** + Summary: Reset all allocated resources. + + Use this facility on out-of memory errors. + It allows discharging the previous state and resuming afresh. + Any pointers previously returned by the API + become invalid. +*) +external reset_memory : unit -> unit + = "camlidl_z3V3_Z3_reset_memory" + +(** + {2 {L External Theory Plugins}} +*) +(** + Summary: Create an interpreted theory sort. +*) +external theory_mk_sort : context -> theory -> symbol -> sort + = "camlidl_z3V3_Z3_theory_mk_sort" + +(** + Summary: Create an interpreted theory constant value. Values are assumed to be different from each other. +*) +external theory_mk_value : context -> theory -> symbol -> sort -> ast + = "camlidl_z3V3_Z3_theory_mk_value" + +(** + Summary: Create an interpreted constant for the given theory. +*) +external theory_mk_constant : context -> theory -> symbol -> sort -> ast + = "camlidl_z3V3_Z3_theory_mk_constant" + +(** + Summary: Create an interpreted function declaration for the given theory. +*) +external theory_mk_func_decl : context -> theory -> symbol -> sort array -> sort -> func_decl + = "camlidl_z3V3_Z3_theory_mk_func_decl" + +(** + Summary: Return the context where the given theory is installed. +*) +external theory_get_context : theory -> context + = "camlidl_z3V3_Z3_theory_get_context" + +(** + Summary: Assert a theory axiom/lemmas during the search. + + An axiom added at search level [n] will remain in the logical context until + level [n] is backtracked. + + The callbacks for push ({!set_push_callback}) and pop + ({!set_pop_callback}) can be used to track when the search + level is increased (i.e., new case-split) and decreased (i.e., + case-split is backtracked). + + Z3 tracks the theory axioms asserted. So, multiple assertions of the same axiom are + ignored. +*) +external theory_assert_axiom : theory -> ast -> unit + = "camlidl_z3V3_Z3_theory_assert_axiom" + +(** + Summary: Inform to the logical context that [lhs] and [rhs] have the same interpretation + in the model being built by theory [t]. If lhs = rhs is inconsistent with other theories, + then the logical context will backtrack. + + For more information, see the paper "Model-Based Theory Combination" in the Z3 website. +*) +external theory_assume_eq : theory -> ast -> ast -> unit + = "camlidl_z3V3_Z3_theory_assume_eq" + +(** + Summary: Enable/disable the simplification of theory axioms asserted using {!theory_assert_axiom}. + By default, the simplification of theory specific operators is disabled. + That is, the reduce theory callbacks are not invoked for theory axioms. + The default behavior is useful when asserting axioms stating properties of theory operators. +*) +external theory_enable_axiom_simplification : theory -> bool -> unit + = "camlidl_z3V3_Z3_theory_enable_axiom_simplification" + +(** + Summary: Return the root of the equivalence class containing [n]. +*) +external theory_get_eqc_root : theory -> ast -> ast + = "camlidl_z3V3_Z3_theory_get_eqc_root" + +(** + Summary: Return the next element in the equivalence class containing [n]. + + The elements in an equivalence class are organized in a circular list. + You can traverse the list by calling this function multiple times + using the result from the previous call. This is illustrated in the + code snippet below. + {v + ast curr = n; + do + curr = theory_get_eqc_next(theory, curr); + while (curr != n); + v} +*) +external theory_get_eqc_next : theory -> ast -> ast + = "camlidl_z3V3_Z3_theory_get_eqc_next" + +(** + Summary: Return the number of parents of [n] that are operators of the given theory. +*) +external theory_get_num_parents : theory -> ast -> int + = "camlidl_z3V3_Z3_theory_get_num_parents" + +(** + Summary: Return the i-th parent of [n]. + See {!theory_get_num_parents}. +*) +external theory_get_parent : theory -> ast -> int -> ast + = "camlidl_z3V3_Z3_theory_get_parent" + +(** + Summary: Return [TRUE] if [n] is an interpreted theory value. +*) +external theory_is_value : theory -> ast -> bool + = "camlidl_z3V3_Z3_theory_is_value" + +(** + Summary: Return [TRUE] if [d] is an interpreted theory declaration. +*) +external theory_is_decl : theory -> func_decl -> bool + = "camlidl_z3V3_Z3_theory_is_decl" + +(** + Summary: Return the number of expressions of the given theory in + the logical context. These are the expressions notified using the + callback {!set_new_elem_callback}. +*) +external theory_get_num_elems : theory -> int + = "camlidl_z3V3_Z3_theory_get_num_elems" + +(** + Summary: Return the i-th elem of the given theory in the logical context. + + - {b See}: {!theory_get_num_elems} +*) +external theory_get_elem : theory -> int -> ast + = "camlidl_z3V3_Z3_theory_get_elem" + +(** + Summary: Return the number of theory applications in the logical + context. These are the expressions notified using the callback + {!set_new_app_callback}. +*) +external theory_get_num_apps : theory -> int + = "camlidl_z3V3_Z3_theory_get_num_apps" + +(** + Summary: Return the i-th application of the given theory in the logical context. + + - {b See}: {!theory_get_num_apps} +*) +external theory_get_app : theory -> int -> ast + = "camlidl_z3V3_Z3_theory_get_app" + +(** + {2 {L Deprecated Injective functions API}} +*) +(** + Summary: Create injective function declaration + + @deprecated This method just asserts a (universally quantified) formula that asserts that + the new function is injective. It is compatible with the old interface for solving: + {!assert_cnstr}, {!check_assumptions}, etc. +*) +external mk_injective_function : context -> symbol -> sort array -> sort -> func_decl + = "camlidl_z3V3_Z3_mk_injective_function" + +(** + {2 {L Deprecated Constraints API}} +*) +(** + Summary: Set the SMTLIB logic to be used in the given logical context. + It is incorrect to invoke this function after invoking + {!check}, {!check_and_get_model}, {!check_assumptions} and {!push}. + Return [TRUE] if the logic was changed successfully, and [FALSE] otherwise. + + @deprecated Subsumed by {!mk_solver_for_logic} +*) +external set_logic : context -> string -> bool + = "camlidl_z3V3_Z3_set_logic" + +(** + Summary: Create a backtracking point. + + The logical context can be viewed as a stack of contexts. The + scope level is the number of elements on this stack. The stack + of contexts is simulated using trail (undo) stacks. + + - {b See also}: {!pop} + + @deprecated Subsumed by {!solver_push} +*) +external push : context -> unit + = "camlidl_z3V3_Z3_push" + +(** + Summary: Backtrack. + + Restores the context from the top of the stack, and pops it off the + stack. Any changes to the logical context (by {!assert_cnstr} or + other functions) between the matching {!push} and [pop] + operators are flushed, and the context is completely restored to + what it was right before the {!push}. + + - {b See also}: {!push} + + @deprecated Subsumed by {!solver_pop} +*) +external pop : context -> int -> unit + = "camlidl_z3V3_Z3_pop" + +(** + Summary: Retrieve the current scope level. + + It retrieves the number of scopes that have been pushed, but not yet popped. + + - {b See also}: {!push} + - {b See also}: {!pop} + + @deprecated Subsumed by {!solver_get_num_scopes}. +*) +external get_num_scopes : context -> int + = "camlidl_z3V3_Z3_get_num_scopes" + +(** + + + + + + + + + + + + + + + + + @deprecated This function has no effect. +*) +external persist_ast : context -> ast -> int -> unit + = "camlidl_z3V3_Z3_persist_ast" + +(** + Summary: Assert a constraint into the logical context. + + After one assertion, the logical context may become + inconsistent. + + The functions {!check} or {!check_and_get_model} should be + used to check whether the logical context is consistent or not. + + - {b See also}: {!check} + - {b See also}: {!check_and_get_model} + + @deprecated Subsumed by {!solver_assert} +*) +external assert_cnstr : context -> ast -> unit + = "camlidl_z3V3_Z3_assert_cnstr" + +(** + Summary: Check whether the given logical context is consistent or not. + + If the logical context is not unsatisfiable (i.e., the return value is different from [L_FALSE)] + and model construction is enabled (see {!mk_config}), + + then a valid model is returned. Otherwise, it is unsafe to use the returned model. + + + + + + + - {b Remarks}: Model construction must be enabled using configuration + parameters (See, {!mk_config}). + + - {b See also}: {!check} + + + @deprecated Subsumed by {!solver_check} +*) +external check_and_get_model : context -> lbool * model + = "camlidl_z3V3_Z3_check_and_get_model" + +(** + Summary: Check whether the given logical context is consistent or not. + + The function {!check_and_get_model} should be used when models are needed. + + - {b See also}: {!check_and_get_model} + + @deprecated Subsumed by {!solver_check} +*) +external check : context -> lbool + = "camlidl_z3V3_Z3_check" + +(** + Summary: Check whether the given logical context and optional assumptions is consistent or not. + + If the logical context is not unsatisfiable (i.e., the return value is different from [L_FALSE)], + + and model construction is enabled (see {!mk_config}), + + then a valid model is returned. Otherwise, it is unsafe to use the returned model. + + + + + + @param c logical context. + @param num_assumptions number of auxiliary assumptions. + @param assumptions array of auxiliary assumptions + @param m optional pointer to a model. + @param proof optional pointer to a proof term. + @param core_size size of unsatisfiable core. + @param core pointer to an array receiving unsatisfiable core. + The unsatisfiable core is a subset of the assumptions, so the array has the same size as the assumptions. + The [core] array is not populated if [core_size] is set to 0. + + - {b Precondition}: assumptions comprises of propositional literals. + In other words, you cannot use compound formulas for assumptions, + but should use propositional variables or negations of propositional variables. + + + + + + - {b See also}: {!check} + + + @deprecated Subsumed by {!solver_check_assumptions} +*) +external check_assumptions : context -> ast array -> int -> ast array -> lbool * model * ast * int * ast array + = "camlidl_z3V3_Z3_check_assumptions" + +(** + Summary: Retrieve congruence class representatives for terms. + + The function can be used for relying on Z3 to identify equal terms under the current + set of assumptions. The array of terms and array of class identifiers should have + the same length. The class identifiers are numerals that are assigned to the same + value for their corresponding terms if the current context forces the terms to be + equal. You cannot deduce that terms corresponding to different numerals must be all different, + (especially when using non-convex theories). + All implied equalities are returned by this call. + This means that two terms map to the same class identifier if and only if + the current context implies that they are equal. + + A side-effect of the function is a satisfiability check. + The function return L_FALSE if the current assertions are not satisfiable. + + - {b See also}: {!check_and_get_model} + - {b See also}: {!check} + + @deprecated Subsumed by solver API +*) +external get_implied_equalities : context -> ast array -> lbool * int array + = "camlidl_z3V3_Z3_get_implied_equalities" + +(** + Summary: Delete a model object. + + - {b See also}: {!check_and_get_model} + + @deprecated Subsumed by solver API +*) +external del_model : context -> model -> unit + = "camlidl_z3V3_Z3_del_model" + +(** + {2 {L Deprecated Search control API}} +*) +(** + Summary: Cancel an ongoing check. + + Notifies the current check to abort and return. + This method should be called from a different thread + than the one performing the check. + + @deprecated Use {!interrupt} instead. +*) +external soft_check_cancel : context -> unit + = "camlidl_z3V3_Z3_soft_check_cancel" + +(** + Summary: Retrieve reason for search failure. + + If a call to {!check} or {!check_and_get_model} returns L_UNDEF, + use this facility to determine the more detailed cause of search failure. + + @deprecated Subsumed by {!solver_get_reason_unknown} +*) +external get_search_failure : context -> search_failure + = "camlidl_z3V3_Z3_get_search_failure" + +(** + {2 {L Deprecated Labels API}} +*) +(** + Summary: Create a labeled formula. + + @param c logical context. + @param s name of the label. + @param is_pos label polarity. + @param f formula being labeled. + + A label behaves as an identity function, so the truth value of the + labeled formula is unchanged. Labels are used for identifying + useful sub-formulas when generating counter-examples. + + @deprecated Labels are only supported by the old Solver API. + This feature is not essential (it can be simulated using auxiliary Boolean variables). + It is only available for backward compatibility. +*) +external mk_label : context -> symbol -> bool -> ast -> ast + = "camlidl_z3V3_Z3_mk_label" + +(** + Summary: Retrieve the set of labels that were relevant in + the context of the current satisfied context. + + - {b See also}: {!del_literals} + - {b See also}: {!get_num_literals} + - {b See also}: {!get_label_symbol} + - {b See also}: {!get_literal} + + @deprecated This procedure is based on the old Solver API. +*) +external get_relevant_labels : context -> literals + = "camlidl_z3V3_Z3_get_relevant_labels" + +(** + Summary: Retrieve the set of literals that satisfy the current context. + + - {b See also}: {!del_literals} + - {b See also}: {!get_num_literals} + - {b See also}: {!get_label_symbol} + - {b See also}: {!get_literal} + + @deprecated This procedure is based on the old Solver API. +*) +external get_relevant_literals : context -> literals + = "camlidl_z3V3_Z3_get_relevant_literals" + +(** + Summary: Retrieve the set of literals that whose assignment were + guess, but not propagated during the search. + + - {b See also}: {!del_literals} + - {b See also}: {!get_num_literals} + - {b See also}: {!get_label_symbol} + - {b See also}: {!get_literal} + + @deprecated This procedure is based on the old Solver API. +*) +external get_guessed_literals : context -> literals + = "camlidl_z3V3_Z3_get_guessed_literals" + +(** + Summary: Delete a labels context. + + - {b See also}: {!get_relevant_labels} + + @deprecated This procedure is based on the old Solver API. +*) +external del_literals : context -> literals -> unit + = "camlidl_z3V3_Z3_del_literals" + +(** + Summary: Retrieve the number of label symbols that were returned. + + - {b See also}: {!get_relevant_labels} + + @deprecated This procedure is based on the old Solver API. +*) +external get_num_literals : context -> literals -> int + = "camlidl_z3V3_Z3_get_num_literals" + +(** + Summary: Retrieve label symbol at idx. + + @deprecated This procedure is based on the old Solver API. +*) +external get_label_symbol : context -> literals -> int -> symbol + = "camlidl_z3V3_Z3_get_label_symbol" + +(** + Summary: Retrieve literal expression at idx. + + @deprecated This procedure is based on the old Solver API. +*) +external get_literal : context -> literals -> int -> ast + = "camlidl_z3V3_Z3_get_literal" + +(** + Summary: Disable label. + + The disabled label is not going to be used when blocking the subsequent search. + + - {b See also}: {!block_literals} + + @deprecated This procedure is based on the old Solver API. +*) +external disable_literal : context -> literals -> int -> unit + = "camlidl_z3V3_Z3_disable_literal" + +(** + Summary: Block subsequent checks using the remaining enabled labels. + + @deprecated This procedure is based on the old Solver API. +*) +external block_literals : context -> literals -> unit + = "camlidl_z3V3_Z3_block_literals" + +(** + {2 {L Deprecated Model API}} +*) +(** + Summary: Return the number of constants assigned by the given model. + + - {b Remarks}: Consider using {!get_model_constants}. + + - {b See also}: {!get_model_constant} + + @deprecated use {!model_get_num_consts} +*) +external get_model_num_constants : context -> model -> int + = "camlidl_z3V3_Z3_get_model_num_constants" + +(** + Summary: \[ [ get_model_constant c m i ] \] + Return the i-th constant in the given model. + + - {b Remarks}: Consider using {!get_model_constants}. + + - {b Precondition}: i < get_model_num_constants c m + + @deprecated use {!model_get_const_decl} +*) +external get_model_constant : context -> model -> int -> func_decl + = "camlidl_z3V3_Z3_get_model_constant" + +(** + Summary: Return the number of function interpretations in the given model. + + A function interpretation is represented as a finite map and an 'else' value. + Each entry in the finite map represents the value of a function given a set of arguments. + + @deprecated use {!model_get_num_funcs} +*) +external get_model_num_funcs : context -> model -> int + = "camlidl_z3V3_Z3_get_model_num_funcs" + +(** + Summary: \[ [ get_model_func_decl c m i ] \] + Return the declaration of the i-th function in the given model. + + - {b Precondition}: i < get_model_num_funcs c m + + - {b See also}: {!get_model_num_funcs} + + @deprecated use {!model_get_func_decl} +*) +external get_model_func_decl : context -> model -> int -> func_decl + = "camlidl_z3V3_Z3_get_model_func_decl" + +(** + Summary: Return the value of the given constant or function + in the given model. + + @deprecated Consider using {!model_eval} or {!model_get_func_interp} +*) +external eval_func_decl : context -> model -> func_decl -> bool * ast + = "camlidl_z3V3_Z3_eval_func_decl" + +(** + Summary: \[ [ is_array_value c v ] \] + Determine whether the term encodes an array value. + A term encodes an array value if it is a nested sequence of + applications of store on top of a constant array. + The indices to the stores have to be values (for example, integer constants) + so that equality between the indices can be evaluated. + Array values are useful for representing interpretations for arrays. + + Return the number of entries mapping to non-default values of the array. + + @deprecated Use {!is_as_array} +*) +external is_array_value : context -> model -> ast -> bool * int + = "camlidl_z3V3_Z3_is_array_value" + +(** + Summary: \[ [ get_array_value c v ] \] + An array values is represented as a dictionary plus a + default (else) value. This function returns the array graph. + + - {b Precondition}: TRUE == is_array_value c v &num_entries + + @deprecated Use func_interp objects and {!get_as_array_func_decl} +*) +external get_array_value : context -> model -> ast -> ast array -> ast array -> ast array * ast array * ast + = "camlidl_z3V3_Z3_get_array_value" + +(** + Summary: \[ [ get_model_func_else c m i ] \] + Return the 'else' value of the i-th function interpretation in the given model. + + A function interpretation is represented as a finite map and an 'else' value. + + - {b Remarks}: Consider using {!get_model_funcs}. + + - {b Precondition}: i < get_model_num_funcs c m + + - {b See also}: {!get_model_num_funcs} + - {b See also}: {!get_model_func_num_entries} + - {b See also}: {!get_model_func_entry_num_args} + - {b See also}: {!get_model_func_entry_arg} + + @deprecated Use func_interp objects +*) +external get_model_func_else : context -> model -> int -> ast + = "camlidl_z3V3_Z3_get_model_func_else" + +(** + Summary: \[ [ get_model_func_num_entries c m i ] \] + Return the number of entries of the i-th function interpretation in the given model. + + A function interpretation is represented as a finite map and an 'else' value. + + - {b Remarks}: Consider using {!get_model_funcs}. + + - {b Precondition}: i < get_model_num_funcs c m + + - {b See also}: {!get_model_num_funcs} + - {b See also}: {!get_model_func_else} + - {b See also}: {!get_model_func_entry_num_args} + - {b See also}: {!get_model_func_entry_arg} + + @deprecated Use func_interp objects +*) +external get_model_func_num_entries : context -> model -> int -> int + = "camlidl_z3V3_Z3_get_model_func_num_entries" + +(** + Summary: \[ [ get_model_func_entry_num_args c m i j ] \] + Return the number of arguments of the j-th entry of the i-th function interpretation in the given + model. + + A function interpretation is represented as a finite map and an 'else' value. + This function returns the j-th entry of this map. + + An entry represents the value of a function given a set of arguments. + + + - {b Remarks}: Consider using {!get_model_funcs}. + + - {b Precondition}: i < get_model_num_funcs c m + - {b Precondition}: j < get_model_func_num_entries c m i + + - {b See also}: {!get_model_num_funcs} + - {b See also}: {!get_model_func_num_entries } + - {b See also}: {!get_model_func_entry_arg} + + @deprecated Use func_interp objects +*) +external get_model_func_entry_num_args : context -> model -> int -> int -> int + = "camlidl_z3V3_Z3_get_model_func_entry_num_args" + +(** + Summary: \[ [ get_model_func_entry_arg c m i j k ] \] + Return the k-th argument of the j-th entry of the i-th function interpretation in the given + model. + + A function interpretation is represented as a finite map and an 'else' value. + This function returns the j-th entry of this map. + + An entry represents the value of a function given a set of arguments. + + + - {b Remarks}: Consider using {!get_model_funcs}. + + - {b Precondition}: i < get_model_num_funcs c m + - {b Precondition}: j < get_model_func_num_entries c m i + - {b Precondition}: k < get_model_func_entry_num_args c m i j + + - {b See also}: {!get_model_num_funcs} + - {b See also}: {!get_model_func_num_entries } + - {b See also}: {!get_model_func_entry_num_args} + + @deprecated Use func_interp objects +*) +external get_model_func_entry_arg : context -> model -> int -> int -> int -> ast + = "camlidl_z3V3_Z3_get_model_func_entry_arg" + +(** + Summary: \[ [ get_model_func_entry_value c m i j ] \] + Return the return value of the j-th entry of the i-th function interpretation in the given + model. + + A function interpretation is represented as a finite map and an 'else' value. + This function returns the j-th entry of this map. + + An entry represents the value of a function given a set of arguments. + + + - {b Remarks}: Consider using {!get_model_funcs}. + + - {b Precondition}: i < get_model_num_funcs c m + - {b Precondition}: j < get_model_func_num_entries c m i + + - {b See also}: {!get_model_num_funcs} + - {b See also}: {!get_model_func_num_entries } + + @deprecated Use func_interp objects +*) +external get_model_func_entry_value : context -> model -> int -> int -> ast + = "camlidl_z3V3_Z3_get_model_func_entry_value" + +(** + Summary: \[ [ eval c m t ] \] + Evaluate the AST node [t] in the given model. + + Return a pair: Boolean and value. The Boolean is true if the term was successfully evaluated. + + The evaluation may fail for the following reasons: + + - [t] contains a quantifier. + + - the model [m] is partial, that is, it doesn't have a complete interpretation for uninterpreted functions. + That is, the option {e MODEL_PARTIAL=true } was used. + + - [t] is type incorrect. + + @deprecated Use {!model_eval} +*) +external eval : context -> model -> ast -> bool * ast + = "camlidl_z3V3_Z3_eval" + +(** + Summary: Evaluate declaration given values. + + Provides direct way to evaluate declarations + without going over terms. + + @deprecated Consider using {!model_eval} and {!substitute_vars} +*) +external eval_decl : context -> model -> func_decl -> ast array -> bool * ast + = "camlidl_z3V3_Z3_eval_decl" + +(** + {2 {L Deprecated String conversion API}} +*) +(** + Summary: Convert the given logical context into a string. + + This function is mainly used for debugging purposes. It displays + the internal structure of a logical context. + + + + + + @deprecated This method is obsolete. It just displays the internal representation of + the global solver available for backward compatibility reasons. +*) +external context_to_string : context -> string + = "camlidl_z3V3_Z3_context_to_string" + +(** + Summary: Return runtime statistics as a string. + + This function is mainly used for debugging purposes. It displays + statistics of the search activity. + + + + + + @deprecated This method is based on the old solver API. + Use {!stats_to_string} when using the new solver API. +*) +external statistics_to_string : context -> string + = "camlidl_z3V3_Z3_statistics_to_string" + +(** + Summary: Extract satisfying assignment from context as a conjunction. + + This function can be used for debugging purposes. It returns a conjunction + of formulas that are assigned to true in the current context. + This conjunction will contain not only the assertions that are set to true + under the current assignment, but will also include additional literals + if there has been a call to {!check} or {!check_and_get_model}. + + @deprecated This method is based on the old solver API. +*) +external get_context_assignment : context -> ast + = "camlidl_z3V3_Z3_get_context_assignment" + + + +(** {2 {L ML Extensions}} *) + +(** + \[ [ mk_context_x configs] \] is a shorthand for the context with configurations in [configs]. +*) +val mk_context_x: (string * string) array -> context;; + +(** + \[ [ get_app_args c a ] \] is the array of arguments of an application. If [t] is a constant, then the array is empty. + + - {b See also}: {!get_app_num_args} + - {b See also}: {!get_app_arg} +*) +val get_app_args: context -> app -> ast array + +(** + \[ [ get_app_args c d ] \] is the array of parameters of [d]. + + - {b See also}: {!get_domain_size} + - {b See also}: {!get_domain} +*) +val get_domains: context -> func_decl -> sort array + +(** + \[ [ get_array_sort c t ] \] is the domain and the range of [t]. + + - {b See also}: {!get_array_sort_domain} + - {b See also}: {!get_array_sort_range} +*) +val get_array_sort: context -> sort -> sort * sort + +(** + \[ [ get_tuple_sort c ty ] \] is the pair [(mk_decl, fields)] where [mk_decl] is the constructor declaration of [ty], and [fields] is the array of fields in [ty]. + + - {b See also}: {!get_tuple_sort_mk_decl} + - {b See also}: {!get_tuple_sort_num_fields} + - {b See also}: {!get_tuple_sort_field_decl} +*) +val get_tuple_sort: context -> sort -> (func_decl * func_decl array) + +(** + \[ [ datatype_constructor_refined ] \] is the refinement of a datatype constructor. + + It contains the constructor declaration, recognizer, and list of accessor functions. +*) +type datatype_constructor_refined = { + constructor : func_decl; + recognizer : func_decl; + accessors : func_decl array +} + +(** + \[ [ get_datatype_sort c ty ] \] is the array of triples [(constructor, recognizer, fields)] where [constructor] is the constructor declaration of [ty], [recognizer] is the recognizer for the [constructor], and [fields] is the array of fields in [ty]. + + - {b See also}: {!get_datatype_sort_num_constructors} + - {b See also}: {!get_datatype_sort_constructor} + - {b See also}: {!get_datatype_sort_recognizer} + - {b See also}: {!get_datatype_sort_constructor_accessor} +*) + + +val get_datatype_sort: context -> sort -> datatype_constructor_refined array + +(** + \[ [ get_model_constants c m ] \] is the array of constants in the model [m]. + + - {b See also}: {!get_model_num_constants} + - {b See also}: {!get_model_constant} +*) +val get_model_constants: context -> model -> func_decl array + + +(** + \[ [ get_model_func_entry c m i j ] \] is the [j]'th entry in the [i]'th function in the model [m]. + + - {b See also}: {!get_model_func_entry_num_args} + - {b See also}: {!get_model_func_entry_arg} + - {b See also}: {!get_model_func_entry_value} +*) +val get_model_func_entry: context -> model -> int -> int -> (ast array * ast);; + +(** + \[ [ get_model_func_entries c m i ] \] is the array of entries in the [i]'th function in the model [m]. + + - {b See also}: {!get_model_func_num_entries} + - {b See also}: {!get_model_func_entry} +*) +val get_model_func_entries: context -> model -> int -> (ast array * ast) array;; + +(** + \[ [ get_model_funcs c m ] \] is the array of functions in the model [m]. Each function is represented by the triple [(decl, entries, else)], where [decl] is the declaration name for the function, [entries] is the array of entries in the function, and [else] is the default (else) value for the function. + + - {b See also}: {!get_model_num_funcs} + - {b See also}: {!get_model_func_decl} + - {b See also}: {!get_model_func_entries} + - {b See also}: {!get_model_func_else} +*) +val get_model_funcs: context -> model -> + (symbol * + (ast array * ast) array * + ast) array + +(** + \[ [ get_smtlib_formulas c ] \] is the array of formulas created by a preceding call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + Recommend use {!parse_smtlib_string_x} or {!parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. + + - {b See also}: {!parse_smtlib_string_x} + - {b See also}: {!parse_smtlib_file_x} + - {b See also}: {!parse_smtlib_string} + - {b See also}: {!parse_smtlib_file} + - {b See also}: {!get_smtlib_num_formulas} + - {b See also}: {!get_smtlib_formula} +*) +val get_smtlib_formulas: context -> ast array + +(** + \[ [get_smtlib_assumptions c] \] is the array of assumptions created by a preceding call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + Recommend use {!parse_smtlib_string_x} or {!parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. + + + - {b See also}: {!parse_smtlib_string_x} + - {b See also}: {!parse_smtlib_file_x} + - {b See also}: {!parse_smtlib_string} + - {b See also}: {!parse_smtlib_file} + - {b See also}: {!get_smtlib_num_assumptions} + - {b See also}: {!get_smtlib_assumption} +*) +val get_smtlib_assumptions: context -> ast array + +(** + \[ [ get_smtlib_decls c ] \] is the array of declarations created by a preceding call to {!parse_smtlib_string} or {!parse_smtlib_file}. + + Recommend use {!parse_smtlib_string_x} or {!parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. + + + - {b See also}: {!parse_smtlib_string_x} + - {b See also}: {!parse_smtlib_file_x} + - {b See also}: {!parse_smtlib_string} + - {b See also}: {!parse_smtlib_file} + - {b See also}: {!get_smtlib_num_decls} + - {b See also}: {!get_smtlib_decl} +*) +val get_smtlib_decls: context -> func_decl array + +(** + \[ [ get_smtlib_parse_results c ] \] is the triple [(get_smtlib_formulas c, get_smtlib_assumptions c, get_smtlib_decls c)]. + + Recommend use {!parse_smtlib_string_x} or {!parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. + + + - {b See also}: {!parse_smtlib_string_x} + - {b See also}: {!parse_smtlib_file_x} + - {b See also}: {!parse_smtlib_string} + - {b See also}: {!parse_smtlib_file} + - {b See also}: {!get_smtlib_formulas} + - {b See also}: {!get_smtlib_assumptions} + - {b See also}: {!get_smtlib_decls} +*) +val get_smtlib_parse_results: context -> (ast array * ast array * func_decl array) + +(** + \[ [ parse_smtlib_string_formula c ... ] \] calls [(parse_smtlib_string c ...)] and returns the single formula produced. + + Recommended for functional style interface to the SMT-LIB parser. + + - {b See also}: {!parse_smtlib_file_formula} + - {b See also}: {!parse_smtlib_string_x} +*) +val parse_smtlib_string_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + +(** + \[ [ parse_smtlib_file_formula c ... ] \] calls [(parse_smtlib_file c ...)] and returns the single formula produced. + + Recommended for functional style interface to the SMT-LIB parser. + + - {b See also}: {!parse_smtlib_file_formula} + - {b See also}: {!parse_smtlib_file_x} +*) +val parse_smtlib_file_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast + +(** + \[ [ parse_smtlib_string_x c ... ] \] is [(parse_smtlib_string c ...; get_smtlib_parse_results c)] + + Recommended for functional style interface to the SMT-LIB parser. + + - {b See also}: {!parse_smtlib_file_x} + - {b See also}: {!parse_smtlib_string} + - {b See also}: {!get_smtlib_parse_results} +*) +val parse_smtlib_string_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) + +(** + \[ [ parse_smtlib_file_x c ... ] \] is [(parse_smtlib_file c ...; get_smtlib_parse_results c)] + + Recommended for functional style interface to the SMT-LIB parser. + + - {b See also}: {!parse_smtlib_string_x} + - {b See also}: {!parse_smtlib_file} + - {b See also}: {!get_smtlib_parse_results} +*) +val parse_smtlib_file_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) + +(** + \[ [ symbol_refined ] \] is the refinement of a {!symbol} . + + - {b See also}: {!symbol_refine} + - {b See also}: {!get_symbol_kind} +*) +type symbol_refined = + | Symbol_int of int + | Symbol_string of string + | Symbol_unknown;; + +(** + \[ [ symbol_refine c s ] \] is the refined symbol of [s]. + + - {b See also}: {!symbol_refined} + - {b See also}: {!get_symbol_kind} +*) +val symbol_refine: context -> symbol -> symbol_refined;; + +(** + \[ [ sort_refined ] \] is the refinement of a {!sort} . + + - {b See also}: {!sort_refine} + - {b See also}: {!get_sort_kind} +*) + + +type sort_refined = + | Sort_uninterpreted of symbol + | Sort_bool + | Sort_int + | Sort_real + | Sort_bv of int + | Sort_array of (sort * sort) + | Sort_datatype of datatype_constructor_refined array + | Sort_relation + | Sort_finite_domain + | Sort_unknown of symbol + +(** + \[ [ sort_refine c t ] \] is the refined sort of [t]. + + - {b See also}: {!sort_refined} + - {b See also}: {!get_sort_kind} +*) +val sort_refine: context -> sort -> sort_refined;; + +(** + \[ [ binder_type ] \] is a universal or existential quantifier. + + - {b See also}: {!term_refined} +*) +type binder_type = | Forall | Exists + +(** + \[ [ numeral_refined ] \] is the refinement of a numeral . + + Numerals whose fractional representation can be fit with + 64 bit integers are treated as small. + +*) +type numeral_refined = + | Numeral_small of int64 * int64 + | Numeral_large of string + +(** + \[ [ term_refined ] \] is the refinement of a {!ast} . + + - {b See also}: {!term_refine} +*) +type term_refined = + | Term_app of decl_kind * func_decl * ast array + | Term_quantifier of binder_type * int * ast array array * (symbol * sort) array * ast + | Term_numeral of numeral_refined * sort + | Term_var of int * sort + +(** + \[ [ term_refine c a ] \] is the refined term of [a]. + + - {b See also}: {!term_refined} +*) +val term_refine : context -> ast -> term_refined + +(** + \[ [mk_theory c name ] \] create a custom theory. + +*) +val mk_theory : context -> string -> theory + +(** + \[ [set_delete_callback th cb] \] set callback when theory gets deleted. +*) +val set_delete_callback : theory -> (unit -> unit) -> unit + +(** + \[ [set_reduce_app_callback th cb] \] set callback for simplifying theory terms. +*) +val set_reduce_app_callback : theory -> (func_decl -> ast array -> ast option) -> unit + +(** + \[ [set_reduce_eq_callback th cb] \] set callback for simplifying equalities over theory terms. +*) +val set_reduce_eq_callback : theory -> (ast -> ast -> ast option) -> unit + +(** + \[ [set_reduce_distinct_callback th cb] \] set callback for simplifying disequalities over theory terms. +*) +val set_reduce_distinct_callback : theory -> (ast array -> ast option) -> unit + +(** + \[ [set_new_app_callback th cb] \] set callback for registering new application. +*) +val set_new_app_callback : theory -> (ast -> unit) -> unit + +(** + \[ [set_new_elem_callback th cb] \] set callback for registering new element. + + - {b See also}: the help for the corresponding C API function. +*) +val set_new_elem_callback : theory -> (ast -> unit) -> unit + +(** + \[ [set_init_search_callback th cb] \] set callback when Z3 starts searching for a satisfying assignment. +*) +val set_init_search_callback : theory -> (unit -> unit) -> unit + +(** + \[ [set_push_callback th cb] \] set callback for a logical context push. +*) +val set_push_callback : theory -> (unit -> unit) -> unit + +(** + \[ [set_pop_callback th cb] \] set callback for a logical context pop. +*) +val set_pop_callback : theory -> (unit -> unit) -> unit + +(** + \[ [set_restart_callback th cb] \] set callback for search restart. +*) +val set_restart_callback : theory -> (unit -> unit) -> unit + +val set_reset_callback : theory -> (unit -> unit) -> unit + +val set_final_check_callback : theory -> (unit -> bool) -> unit + +val set_new_eq_callback : theory -> (ast -> ast -> unit) -> unit + +val set_new_diseq_callback : theory -> (ast -> ast -> unit) -> unit + +val set_new_assignment_callback : theory -> (ast -> bool -> unit) -> unit + +val set_new_relevant_callback : theory -> (ast -> unit) -> unit + + + +end + diff --git a/ml/z3.proj b/ml/z3.proj new file mode 100644 index 000000000..44ea4947d --- /dev/null +++ b/ml/z3.proj @@ -0,0 +1,11 @@ + + + + + + + + $(MLFlags) -I $(SLAMSRC)\slam\engine\slam2\z3 + + + diff --git a/ml/z3_stubs.c b/ml/z3_stubs.c new file mode 100644 index 000000000..71df56462 --- /dev/null +++ b/ml/z3_stubs.c @@ -0,0 +1,18966 @@ +/* File generated from z3.idl */ + +#include +#include +#include +#include +#include +#include +#include +#ifdef Custom_tag +#include +#include +#endif +#include + + +#include "z3.h" + +#define xstr(s) str(s) +#define str(s) #s +#pragma warning(disable:4090) + +void check_error_code (Z3_context c); + +Z3_context last_ctx; + + + + value caml_final_register (value f, value v); + + void register_finalizer(value** closure, char* name, Z3_context ctx, value v) + { + if (*closure == NULL) { + *closure = caml_named_value(name); + if (*closure == NULL) { + Z3_set_error(ctx, Z3_INTERNAL_FATAL); + return; + } + } + caml_final_register(**closure, v); + } + + value c2ml_Z3_context (Z3_context* c) + { + static value* finalize_Z3_context_closure = NULL; + value v; + v = caml_alloc_small(1, Abstract_tag); + Field(v, 0) = (value) *c; + register_finalizer(&finalize_Z3_context_closure, "finalize_Z3_context", + (Z3_context) *c, v); + return v; + } + + void ml2c_Z3_context (value v, Z3_context* c) + { + *c = (Z3_context) Field(v, 0); + last_ctx = *c; + } + + value finalize_Z3_context (value v) + { + Z3_context c; + c = (Z3_context) Field(v, 0); + Z3_del_context(c); + return Val_unit; + } + +#define camlidl_ml2c_z3_Z3_context(v,c,ctx) ml2c_Z3_context(v,c) + +#define camlidl_c2ml_z3_Z3_context(c,ctx) c2ml_Z3_context(c) + +void camlidl_ml2c_z3_Z3_symbol(value _v1, Z3_symbol * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_symbol *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3_Z3_symbol(Z3_symbol * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_symbol) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_symbol *) Bp_val(_v1)) = *_c2; + return _v1; +} + + +typedef struct _Z3_ast_context { + Z3_ast ast; + Z3_context ctx; +} Z3_ast_context; + +void ml2c_Z3_ast (value v, Z3_ast* c) +{ + *c = ((Z3_ast_context*) Data_custom_val(v))->ast; +} + +static int compare_Z3_ast (value v1, value v2) +{ + Z3_ast_context* ac1; + Z3_ast_context* ac2; + unsigned int id1, id2; + ac1 = Data_custom_val(v1); + ac2 = Data_custom_val(v2); + id1 = Z3_get_ast_id(ac1->ctx, ac1->ast); + check_error_code(ac1->ctx); + id2 = Z3_get_ast_id(ac2->ctx, ac2->ast); + check_error_code(ac2->ctx); + return id2 - id1; +} + +static intnat hash_Z3_ast (value v) +{ + Z3_ast_context* ac; + unsigned int hash; + ac = Data_custom_val(v); + hash = Z3_get_ast_hash(ac->ctx, ac->ast); + check_error_code(ac->ctx); + return hash; +} + + + value finalize_Z3_ast (value v) + { + Z3_ast_context* ac; + ac = Data_custom_val(v); + Z3_dec_ref(ac->ctx, ac->ast); + check_error_code(ac->ctx); + return Val_unit; + } + + static struct custom_operations cops_Z3_ast = { + NULL, + custom_finalize_default, + compare_Z3_ast, + hash_Z3_ast, + custom_serialize_default, + custom_deserialize_default + }; + + value c2ml_Z3_ast (Z3_ast* c) + { + static value* finalize_Z3_ast_closure = NULL; + value v; + Z3_ast_context* ac; + check_error_code(last_ctx); + v = caml_alloc_custom(&cops_Z3_ast, sizeof(Z3_ast_context), 0, 1); + ac = Data_custom_val(v); + ac->ast = *c; + ac->ctx = last_ctx; + register_finalizer(&finalize_Z3_ast_closure, "finalize_Z3_ast", + (Z3_context) *c, v); + Z3_inc_ref(last_ctx, *c); + return v; + } + +#define camlidl_ml2c_z3_Z3_ast(v,c,ctx) ml2c_Z3_ast(v,c) + +#define camlidl_c2ml_z3_Z3_ast(c,ctx) c2ml_Z3_ast(c) + +#define DEFINE_SUBAST_OPS(T) void ml2c_ ## T (value v, T * a) { ml2c_Z3_ast(v, (Z3_ast*) a); } value c2ml_ ## T (T * a) { return c2ml_Z3_ast((Z3_ast*) a); } +DEFINE_SUBAST_OPS(Z3_sort) +#define camlidl_ml2c_z3_Z3_sort(v,c,ctx) ml2c_Z3_sort(v,c) + +#define camlidl_c2ml_z3_Z3_sort(c,ctx) c2ml_Z3_sort(c) + +DEFINE_SUBAST_OPS(Z3_func_decl) +#define camlidl_ml2c_z3_Z3_func_decl(v,c,ctx) ml2c_Z3_func_decl(v,c) + +#define camlidl_c2ml_z3_Z3_func_decl(c,ctx) c2ml_Z3_func_decl(c) + +DEFINE_SUBAST_OPS(Z3_app) +#define camlidl_ml2c_z3_Z3_app(v,c,ctx) ml2c_Z3_app(v,c) + +#define camlidl_c2ml_z3_Z3_app(c,ctx) c2ml_Z3_app(c) + +DEFINE_SUBAST_OPS(Z3_pattern) +#define camlidl_ml2c_z3_Z3_pattern(v,c,ctx) ml2c_Z3_pattern(v,c) + +#define camlidl_c2ml_z3_Z3_pattern(c,ctx) c2ml_Z3_pattern(c) + +#define DEFINE_RC_OPS(T) value c2ml_ ## T (T * c) { static value* finalize_ ## T ## _closure = NULL; value v; check_error_code(last_ctx); v = caml_alloc_small(2, Abstract_tag); Field(v, 0) = (value) *c; Field(v, 1) = (value) last_ctx; register_finalizer(&finalize_ ## T ## _closure, xstr(finalize_ ## T), (Z3_context) *c, v); T ## _inc_ref(last_ctx, *c); return v; } void ml2c_ ## T (value v, T * c) { *c = (T) Field(v, 0); } value finalize_ ## T (value v) { Z3_context c; c = (Z3_context) Field(v, 1); T ## _dec_ref(c, (T) Field(v, 0)); check_error_code(c); return Val_unit; } +DEFINE_RC_OPS(Z3_params) +#define camlidl_ml2c_z3_Z3_params(v,c,ctx) ml2c_Z3_params(v,c) + +#define camlidl_c2ml_z3_Z3_params(c,ctx) c2ml_Z3_params(c) + +DEFINE_RC_OPS(Z3_param_descrs) +#define camlidl_ml2c_z3_Z3_param_descrs(v,c,ctx) ml2c_Z3_param_descrs(v,c) + +#define camlidl_c2ml_z3_Z3_param_descrs(c,ctx) c2ml_Z3_param_descrs(c) + +DEFINE_RC_OPS(Z3_model) +#define camlidl_ml2c_z3_Z3_model(v,c,ctx) ml2c_Z3_model(v,c) + +#define camlidl_c2ml_z3_Z3_model(c,ctx) c2ml_Z3_model(c) + +DEFINE_RC_OPS(Z3_func_interp) +#define camlidl_ml2c_z3_Z3_func_interp(v,c,ctx) ml2c_Z3_func_interp(v,c) + +#define camlidl_c2ml_z3_Z3_func_interp(c,ctx) c2ml_Z3_func_interp(c) + +DEFINE_RC_OPS(Z3_func_entry) +#define camlidl_ml2c_z3_Z3_func_entry(v,c,ctx) ml2c_Z3_func_entry(v,c) + +#define camlidl_c2ml_z3_Z3_func_entry(c,ctx) c2ml_Z3_func_entry(c) + +DEFINE_RC_OPS(Z3_fixedpoint) +#define camlidl_ml2c_z3_Z3_fixedpoint(v,c,ctx) ml2c_Z3_fixedpoint(v,c) + +#define camlidl_c2ml_z3_Z3_fixedpoint(c,ctx) c2ml_Z3_fixedpoint(c) + +DEFINE_RC_OPS(Z3_ast_vector) +#define camlidl_ml2c_z3_Z3_ast_vector(v,c,ctx) ml2c_Z3_ast_vector(v,c) + +#define camlidl_c2ml_z3_Z3_ast_vector(c,ctx) c2ml_Z3_ast_vector(c) + +DEFINE_RC_OPS(Z3_ast_map) +#define camlidl_ml2c_z3_Z3_ast_map(v,c,ctx) ml2c_Z3_ast_map(v,c) + +#define camlidl_c2ml_z3_Z3_ast_map(c,ctx) c2ml_Z3_ast_map(c) + +DEFINE_RC_OPS(Z3_goal) +#define camlidl_ml2c_z3_Z3_goal(v,c,ctx) ml2c_Z3_goal(v,c) + +#define camlidl_c2ml_z3_Z3_goal(c,ctx) c2ml_Z3_goal(c) + +DEFINE_RC_OPS(Z3_tactic) +#define camlidl_ml2c_z3_Z3_tactic(v,c,ctx) ml2c_Z3_tactic(v,c) + +#define camlidl_c2ml_z3_Z3_tactic(c,ctx) c2ml_Z3_tactic(c) + +DEFINE_RC_OPS(Z3_probe) +#define camlidl_ml2c_z3_Z3_probe(v,c,ctx) ml2c_Z3_probe(v,c) + +#define camlidl_c2ml_z3_Z3_probe(c,ctx) c2ml_Z3_probe(c) + +DEFINE_RC_OPS(Z3_apply_result) +#define camlidl_ml2c_z3_Z3_apply_result(v,c,ctx) ml2c_Z3_apply_result(v,c) + +#define camlidl_c2ml_z3_Z3_apply_result(c,ctx) c2ml_Z3_apply_result(c) + +DEFINE_RC_OPS(Z3_solver) +#define camlidl_ml2c_z3_Z3_solver(v,c,ctx) ml2c_Z3_solver(v,c) + +#define camlidl_c2ml_z3_Z3_solver(c,ctx) c2ml_Z3_solver(c) + +DEFINE_RC_OPS(Z3_stats) +#define camlidl_ml2c_z3_Z3_stats(v,c,ctx) ml2c_Z3_stats(v,c) + +#define camlidl_c2ml_z3_Z3_stats(c,ctx) c2ml_Z3_stats(c) + +#define DEFINE_OPT_OPS(T) void ml2c_ ## T ## _opt (value v, T* c) { struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; if (v != Val_int(0)) { camlidl_ml2c_z3_ ## T(Field(v, 0), c, _ctx); } else { *c = NULL; } } value c2ml_ ## T ## _opt (T* c) { struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; value v; value a; if (*c) { a = camlidl_c2ml_z3_ ## T(c, _ctx); Begin_root(a) v = caml_alloc_small(1, 0); Field(v, 0) = a; End_roots(); } else { v = Val_int(0); } return v; } + +DEFINE_OPT_OPS(Z3_ast) +#define camlidl_ml2c_z3_Z3_ast_opt(v,c,ctx) ml2c_Z3_ast_opt(v,c) + +#define camlidl_c2ml_z3_Z3_ast_opt(c,ctx) c2ml_Z3_ast_opt(c) + +DEFINE_OPT_OPS(Z3_sort) +#define camlidl_ml2c_z3_Z3_sort_opt(v,c,ctx) ml2c_Z3_sort_opt(v,c) + +#define camlidl_c2ml_z3_Z3_sort_opt(c,ctx) c2ml_Z3_sort_opt(c) + +DEFINE_OPT_OPS(Z3_func_interp) +#define camlidl_ml2c_z3_Z3_func_interp_opt(v,c,ctx) ml2c_Z3_func_interp_opt(v,c) + +#define camlidl_c2ml_z3_Z3_func_interp_opt(c,ctx) c2ml_Z3_func_interp_opt(c) + +void camlidl_ml2c_z3_Z3_constructor(value _v1, Z3_constructor * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_constructor *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3_Z3_constructor(Z3_constructor * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_constructor) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_constructor *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3_Z3_constructor_list(value _v1, Z3_constructor_list * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_constructor_list *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3_Z3_constructor_list(Z3_constructor_list * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_constructor_list) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_constructor_list *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3_Z3_string(value _v1, Z3_string * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_malloc_string(_v1, _ctx); +} + +value camlidl_c2ml_z3_Z3_string(Z3_string * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = copy_string((*_c2)); + return _v1; +} + +int camlidl_transl_table_z3_enum_1[3] = { + Z3_L_FALSE, + Z3_L_UNDEF, + Z3_L_TRUE, +}; + +void camlidl_ml2c_z3_Z3_lbool(value _v1, Z3_lbool * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_1[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_lbool(Z3_lbool * _c2, camlidl_ctx _ctx) +{ +value _v1; + switch((*_c2)) { + case Z3_L_FALSE: _v1 = Val_int(0); break; + case Z3_L_UNDEF: _v1 = Val_int(1); break; + case Z3_L_TRUE: _v1 = Val_int(2); break; + default: invalid_argument("typedef Z3_lbool: bad enum value"); + } + return _v1; +} + +int camlidl_transl_table_z3_enum_2[2] = { + Z3_INT_SYMBOL, + Z3_STRING_SYMBOL, +}; + +void camlidl_ml2c_z3_Z3_symbol_kind(value _v1, Z3_symbol_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_2[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_symbol_kind(Z3_symbol_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + switch((*_c2)) { + case Z3_INT_SYMBOL: _v1 = Val_int(0); break; + case Z3_STRING_SYMBOL: _v1 = Val_int(1); break; + default: invalid_argument("typedef Z3_symbol_kind: bad enum value"); + } + return _v1; +} + +int camlidl_transl_table_z3_enum_3[7] = { + Z3_PARAMETER_INT, + Z3_PARAMETER_DOUBLE, + Z3_PARAMETER_RATIONAL, + Z3_PARAMETER_SYMBOL, + Z3_PARAMETER_SORT, + Z3_PARAMETER_AST, + Z3_PARAMETER_FUNC_DECL, +}; + +void camlidl_ml2c_z3_Z3_parameter_kind(value _v1, Z3_parameter_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_3[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_parameter_kind(Z3_parameter_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3_enum_3, 7, "typedef Z3_parameter_kind: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3_enum_4[10] = { + Z3_UNINTERPRETED_SORT, + Z3_BOOL_SORT, + Z3_INT_SORT, + Z3_REAL_SORT, + Z3_BV_SORT, + Z3_ARRAY_SORT, + Z3_DATATYPE_SORT, + Z3_RELATION_SORT, + Z3_FINITE_DOMAIN_SORT, + Z3_UNKNOWN_SORT, +}; + +void camlidl_ml2c_z3_Z3_sort_kind(value _v1, Z3_sort_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_4[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_sort_kind(Z3_sort_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3_enum_4, 10, "typedef Z3_sort_kind: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3_enum_5[7] = { + Z3_NUMERAL_AST, + Z3_APP_AST, + Z3_VAR_AST, + Z3_QUANTIFIER_AST, + Z3_SORT_AST, + Z3_FUNC_DECL_AST, + Z3_UNKNOWN_AST, +}; + +void camlidl_ml2c_z3_Z3_ast_kind(value _v1, Z3_ast_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_5[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_ast_kind(Z3_ast_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3_enum_5, 7, "typedef Z3_ast_kind: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3_enum_6[151] = { + Z3_OP_TRUE, + Z3_OP_FALSE, + Z3_OP_EQ, + Z3_OP_DISTINCT, + Z3_OP_ITE, + Z3_OP_AND, + Z3_OP_OR, + Z3_OP_IFF, + Z3_OP_XOR, + Z3_OP_NOT, + Z3_OP_IMPLIES, + Z3_OP_OEQ, + Z3_OP_ANUM, + Z3_OP_AGNUM, + Z3_OP_LE, + Z3_OP_GE, + Z3_OP_LT, + Z3_OP_GT, + Z3_OP_ADD, + Z3_OP_SUB, + Z3_OP_UMINUS, + Z3_OP_MUL, + Z3_OP_DIV, + Z3_OP_IDIV, + Z3_OP_REM, + Z3_OP_MOD, + Z3_OP_TO_REAL, + Z3_OP_TO_INT, + Z3_OP_IS_INT, + Z3_OP_POWER, + Z3_OP_STORE, + Z3_OP_SELECT, + Z3_OP_CONST_ARRAY, + Z3_OP_ARRAY_MAP, + Z3_OP_ARRAY_DEFAULT, + Z3_OP_SET_UNION, + Z3_OP_SET_INTERSECT, + Z3_OP_SET_DIFFERENCE, + Z3_OP_SET_COMPLEMENT, + Z3_OP_SET_SUBSET, + Z3_OP_AS_ARRAY, + Z3_OP_BNUM, + Z3_OP_BIT1, + Z3_OP_BIT0, + Z3_OP_BNEG, + Z3_OP_BADD, + Z3_OP_BSUB, + Z3_OP_BMUL, + Z3_OP_BSDIV, + Z3_OP_BUDIV, + Z3_OP_BSREM, + Z3_OP_BUREM, + Z3_OP_BSMOD, + Z3_OP_BSDIV0, + Z3_OP_BUDIV0, + Z3_OP_BSREM0, + Z3_OP_BUREM0, + Z3_OP_BSMOD0, + Z3_OP_ULEQ, + Z3_OP_SLEQ, + Z3_OP_UGEQ, + Z3_OP_SGEQ, + Z3_OP_ULT, + Z3_OP_SLT, + Z3_OP_UGT, + Z3_OP_SGT, + Z3_OP_BAND, + Z3_OP_BOR, + Z3_OP_BNOT, + Z3_OP_BXOR, + Z3_OP_BNAND, + Z3_OP_BNOR, + Z3_OP_BXNOR, + Z3_OP_CONCAT, + Z3_OP_SIGN_EXT, + Z3_OP_ZERO_EXT, + Z3_OP_EXTRACT, + Z3_OP_REPEAT, + Z3_OP_BREDOR, + Z3_OP_BREDAND, + Z3_OP_BCOMP, + Z3_OP_BSHL, + Z3_OP_BLSHR, + Z3_OP_BASHR, + Z3_OP_ROTATE_LEFT, + Z3_OP_ROTATE_RIGHT, + Z3_OP_EXT_ROTATE_LEFT, + Z3_OP_EXT_ROTATE_RIGHT, + Z3_OP_INT2BV, + Z3_OP_BV2INT, + Z3_OP_CARRY, + Z3_OP_XOR3, + Z3_OP_PR_UNDEF, + Z3_OP_PR_TRUE, + Z3_OP_PR_ASSERTED, + Z3_OP_PR_GOAL, + Z3_OP_PR_MODUS_PONENS, + Z3_OP_PR_REFLEXIVITY, + Z3_OP_PR_SYMMETRY, + Z3_OP_PR_TRANSITIVITY, + Z3_OP_PR_TRANSITIVITY_STAR, + Z3_OP_PR_MONOTONICITY, + Z3_OP_PR_QUANT_INTRO, + Z3_OP_PR_DISTRIBUTIVITY, + Z3_OP_PR_AND_ELIM, + Z3_OP_PR_NOT_OR_ELIM, + Z3_OP_PR_REWRITE, + Z3_OP_PR_REWRITE_STAR, + Z3_OP_PR_PULL_QUANT, + Z3_OP_PR_PULL_QUANT_STAR, + Z3_OP_PR_PUSH_QUANT, + Z3_OP_PR_ELIM_UNUSED_VARS, + Z3_OP_PR_DER, + Z3_OP_PR_QUANT_INST, + Z3_OP_PR_HYPOTHESIS, + Z3_OP_PR_LEMMA, + Z3_OP_PR_UNIT_RESOLUTION, + Z3_OP_PR_IFF_TRUE, + Z3_OP_PR_IFF_FALSE, + Z3_OP_PR_COMMUTATIVITY, + Z3_OP_PR_DEF_AXIOM, + Z3_OP_PR_DEF_INTRO, + Z3_OP_PR_APPLY_DEF, + Z3_OP_PR_IFF_OEQ, + Z3_OP_PR_NNF_POS, + Z3_OP_PR_NNF_NEG, + Z3_OP_PR_NNF_STAR, + Z3_OP_PR_CNF_STAR, + Z3_OP_PR_SKOLEMIZE, + Z3_OP_PR_MODUS_PONENS_OEQ, + Z3_OP_PR_TH_LEMMA, + Z3_OP_RA_STORE, + Z3_OP_RA_EMPTY, + Z3_OP_RA_IS_EMPTY, + Z3_OP_RA_JOIN, + Z3_OP_RA_UNION, + Z3_OP_RA_WIDEN, + Z3_OP_RA_PROJECT, + Z3_OP_RA_FILTER, + Z3_OP_RA_NEGATION_FILTER, + Z3_OP_RA_RENAME, + Z3_OP_RA_COMPLEMENT, + Z3_OP_RA_SELECT, + Z3_OP_RA_CLONE, + Z3_OP_FD_LT, + Z3_OP_LABEL, + Z3_OP_LABEL_LIT, + Z3_OP_DT_CONSTRUCTOR, + Z3_OP_DT_RECOGNISER, + Z3_OP_DT_ACCESSOR, + Z3_OP_UNINTERPRETED, +}; + +void camlidl_ml2c_z3_Z3_decl_kind(value _v1, Z3_decl_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_6[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_decl_kind(Z3_decl_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3_enum_6, 151, "typedef Z3_decl_kind: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3_enum_7[7] = { + Z3_PK_UINT, + Z3_PK_BOOL, + Z3_PK_DOUBLE, + Z3_PK_SYMBOL, + Z3_PK_STRING, + Z3_PK_OTHER, + Z3_PK_INVALID, +}; + +void camlidl_ml2c_z3_Z3_param_kind(value _v1, Z3_param_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_7[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_param_kind(Z3_param_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3_enum_7, 7, "typedef Z3_param_kind: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3_enum_8[8] = { + Z3_NO_FAILURE, + Z3_UNKNOWN, + Z3_TIMEOUT, + Z3_MEMOUT_WATERMARK, + Z3_CANCELED, + Z3_NUM_CONFLICTS, + Z3_THEORY, + Z3_QUANTIFIERS, +}; + +void camlidl_ml2c_z3_Z3_search_failure(value _v1, Z3_search_failure * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_8[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_search_failure(Z3_search_failure * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3_enum_8, 8, "typedef Z3_search_failure: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3_enum_9[4] = { + Z3_PRINT_SMTLIB_FULL, + Z3_PRINT_LOW_LEVEL, + Z3_PRINT_SMTLIB_COMPLIANT, + Z3_PRINT_SMTLIB2_COMPLIANT, +}; + +void camlidl_ml2c_z3_Z3_ast_print_mode(value _v1, Z3_ast_print_mode * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_9[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_ast_print_mode(Z3_ast_print_mode * _c2, camlidl_ctx _ctx) +{ +value _v1; + switch((*_c2)) { + case Z3_PRINT_SMTLIB_FULL: _v1 = Val_int(0); break; + case Z3_PRINT_LOW_LEVEL: _v1 = Val_int(1); break; + case Z3_PRINT_SMTLIB_COMPLIANT: _v1 = Val_int(2); break; + case Z3_PRINT_SMTLIB2_COMPLIANT: _v1 = Val_int(3); break; + default: invalid_argument("typedef Z3_ast_print_mode: bad enum value"); + } + return _v1; +} + +int camlidl_transl_table_z3_enum_10[13] = { + Z3_OK, + Z3_SORT_ERROR, + Z3_IOB, + Z3_INVALID_ARG, + Z3_PARSER_ERROR, + Z3_NO_PARSER, + Z3_INVALID_PATTERN, + Z3_MEMOUT_FAIL, + Z3_FILE_ACCESS_ERROR, + Z3_INTERNAL_FATAL, + Z3_INVALID_USAGE, + Z3_DEC_REF_ERROR, + Z3_EXCEPTION, +}; + +void camlidl_ml2c_z3_Z3_error_code(value _v1, Z3_error_code * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_10[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_error_code(Z3_error_code * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3_enum_10, 13, "typedef Z3_error_code: bad enum value"); + return _v1; +} + + +value camlidl_c2ml_z3_Z3_error_code(Z3_error_code * _c2, camlidl_ctx _ctx); + + +void check_error_code (Z3_context c) +{ + static struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + value* exn_tag = NULL; + value ctx_err[2]; + Z3_error_code e; + e = Z3_get_error_code(c); + if (e != Z3_OK) { + ctx_err[0] = c2ml_Z3_context(&c); + ctx_err[1] = camlidl_c2ml_z3_Z3_error_code(&e, &_ctxs); + exn_tag = caml_named_value("Z3.Error"); + if (*exn_tag == 0) { + fprintf(stderr, "Z3.Error not found"); + exit(1); + } + caml_raise_with_args(*exn_tag, 2, ctx_err); + } +} + + +void* error_handler_static = NULL; + +int camlidl_transl_table_z3_enum_11[4] = { + Z3_GOAL_PRECISE, + Z3_GOAL_UNDER, + Z3_GOAL_OVER, + Z3_GOAL_UNDER_OVER, +}; + +void camlidl_ml2c_z3_Z3_goal_prec(value _v1, Z3_goal_prec * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3_enum_11[Int_val(_v1)]; +} + +value camlidl_c2ml_z3_Z3_goal_prec(Z3_goal_prec * _c2, camlidl_ctx _ctx) +{ +value _v1; + switch((*_c2)) { + case Z3_GOAL_PRECISE: _v1 = Val_int(0); break; + case Z3_GOAL_UNDER: _v1 = Val_int(1); break; + case Z3_GOAL_OVER: _v1 = Val_int(2); break; + case Z3_GOAL_UNDER_OVER: _v1 = Val_int(3); break; + default: invalid_argument("typedef Z3_goal_prec: bad enum value"); + } + return _v1; +} + + +value caml_z3_mk_context(value key_val_list) +{ + CAMLparam1( key_val_list ); + CAMLlocal4( item, vkey, vval, _vres ); + char * ckey; + char * cval; + Z3_config cfg; + Z3_context _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + + cfg = Z3_mk_config(); + + while (key_val_list != Val_emptylist) + { + item = Field(key_val_list, 0); + vkey = Field(item, 0); + vval = Field(item, 1); + ckey = camlidl_malloc_string(vkey, _ctx); + cval = camlidl_malloc_string(vval, _ctx); + Z3_set_param_value(cfg, ckey, cval); + key_val_list = Field(key_val_list, 1); + } + + _res = Z3_mk_context_rc(cfg); + Z3_del_config(cfg); + _vres = camlidl_c2ml_z3_Z3_context(&_res, _ctx); + camlidl_free(_ctx); + Z3_set_error_handler(_res, error_handler_static); + CAMLreturn(_vres); +} + +value camlidl_z3_Z3_update_param_value( + value _v_c, + value _v_param_id, + value _v_param_value) +{ + Z3_context c; /*in*/ + Z3_string param_id; /*in*/ + Z3_string param_value; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_param_id, ¶m_id, _ctx); + camlidl_ml2c_z3_Z3_string(_v_param_value, ¶m_value, _ctx); + Z3_update_param_value(c, param_id, param_value); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_get_param_value( + value _v_c, + value _v_param_id) +{ + Z3_context c; /*in*/ + Z3_string param_id; /*in*/ + Z3_string *param_value; /*out*/ + Z3_string _c1; + value _v2; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_param_id, ¶m_id, _ctx); + param_value = &_c1; + Z3_get_param_value(c, param_id, param_value); + if (param_value == NULL) { + _vres = Val_int(0); + } else { + _v2 = camlidl_c2ml_z3_Z3_string(&*param_value, _ctx); + Begin_root(_v2) + _vres = camlidl_alloc_small(1, 0); + Field(_vres, 0) = _v2; + End_roots(); + } + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_interrupt( + value _v_c) +{ + Z3_context c; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + Z3_interrupt(c); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_mk_params( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_params _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_params(c); + _vres = camlidl_c2ml_z3_Z3_params(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_params_set_bool( + value _v_c, + value _v_p, + value _v_k, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_params p; /*in*/ + Z3_symbol k; /*in*/ + int v; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_k, &k, _ctx); + v = Int_val(_v_v); + Z3_params_set_bool(c, p, k, v); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_params_set_uint( + value _v_c, + value _v_p, + value _v_k, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_params p; /*in*/ + Z3_symbol k; /*in*/ + unsigned int v; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_k, &k, _ctx); + v = Int_val(_v_v); + Z3_params_set_uint(c, p, k, v); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_params_set_double( + value _v_c, + value _v_p, + value _v_k, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_params p; /*in*/ + Z3_symbol k; /*in*/ + double v; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_k, &k, _ctx); + v = Double_val(_v_v); + Z3_params_set_double(c, p, k, v); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_params_set_symbol( + value _v_c, + value _v_p, + value _v_k, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_params p; /*in*/ + Z3_symbol k; /*in*/ + Z3_symbol v; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_k, &k, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_v, &v, _ctx); + Z3_params_set_symbol(c, p, k, v); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_params_to_string( + value _v_c, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_params p; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + _res = Z3_params_to_string(c, p); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_params_validate( + value _v_c, + value _v_p, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_params p; /*in*/ + Z3_param_descrs d; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + camlidl_ml2c_z3_Z3_param_descrs(_v_d, &d, _ctx); + Z3_params_validate(c, p, d); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_param_descrs_get_kind( + value _v_c, + value _v_p, + value _v_n) +{ + Z3_context c; /*in*/ + Z3_param_descrs p; /*in*/ + Z3_symbol n; /*in*/ + Z3_param_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_param_descrs(_v_p, &p, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_n, &n, _ctx); + _res = Z3_param_descrs_get_kind(c, p, n); + _vres = camlidl_c2ml_z3_Z3_param_kind(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_param_descrs_size( + value _v_c, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_param_descrs p; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_param_descrs(_v_p, &p, _ctx); + _res = Z3_param_descrs_size(c, p); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_param_descrs_get_name( + value _v_c, + value _v_p, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_param_descrs p; /*in*/ + unsigned int i; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_param_descrs(_v_p, &p, _ctx); + i = Int_val(_v_i); + _res = Z3_param_descrs_get_name(c, p, i); + _vres = camlidl_c2ml_z3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_int_symbol( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + int i; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_mk_int_symbol(c, i); + _vres = camlidl_c2ml_z3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_string_symbol( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_string s; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_s, &s, _ctx); + _res = Z3_mk_string_symbol(c, s); + _vres = camlidl_c2ml_z3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_uninterpreted_sort( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_s, &s, _ctx); + _res = Z3_mk_uninterpreted_sort(c, s); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bool_sort( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_bool_sort(c); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_int_sort( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_int_sort(c); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_real_sort( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_real_sort(c); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bv_sort( + value _v_c, + value _v_sz) +{ + Z3_context c; /*in*/ + unsigned int sz; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + sz = Int_val(_v_sz); + _res = Z3_mk_bv_sort(c, sz); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_finite_domain_sort( + value _v_c, + value _v_name, + value _v_size) +{ + Z3_context c; /*in*/ + Z3_symbol name; /*in*/ + __int64 size; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_name, &name, _ctx); + size = Int64_val(_v_size); + _res = Z3_mk_finite_domain_sort(c, name, size); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_array_sort( + value _v_c, + value _v_domain, + value _v_range) +{ + Z3_context c; /*in*/ + Z3_sort domain; /*in*/ + Z3_sort range; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_domain, &domain, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_range, &range, _ctx); + _res = Z3_mk_array_sort(c, domain, range); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_tuple_sort( + value _v_c, + value _v_mk_tuple_name, + value _v_field_names, + value _v_field_sorts) +{ + Z3_context c; /*in*/ + Z3_symbol mk_tuple_name; /*in*/ + unsigned int num_fields; /*in*/ + Z3_symbol const *field_names; /*in*/ + Z3_sort const *field_sorts; /*in*/ + Z3_func_decl *mk_tuple_decl; /*out*/ + Z3_func_decl *proj_decl; /*out*/ + Z3_sort _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + Z3_func_decl _c7; + mlsize_t _c8; + value _v9; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_mk_tuple_name, &mk_tuple_name, _ctx); + _c1 = Wosize_val(_v_field_names); + field_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_field_names, _c2); + camlidl_ml2c_z3_Z3_symbol(_v3, &field_names[_c2], _ctx); + } + num_fields = _c1; + _c4 = Wosize_val(_v_field_sorts); + field_sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_field_sorts, _c5); + camlidl_ml2c_z3_Z3_sort(_v6, &field_sorts[_c5], _ctx); + } + num_fields = _c4; + mk_tuple_decl = &_c7; + proj_decl = camlidl_malloc(num_fields * sizeof(Z3_func_decl ), _ctx); + _res = Z3_mk_tuple_sort(c, mk_tuple_name, num_fields, field_names, field_sorts, mk_tuple_decl, proj_decl); + Begin_roots_block(_vres, 3) + _vres[0] = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + _vres[1] = camlidl_c2ml_z3_Z3_func_decl(&*mk_tuple_decl, _ctx); + _vres[2] = camlidl_alloc(num_fields, 0); + Begin_root(_vres[2]) + for (_c8 = 0; _c8 < num_fields; _c8++) { + _v9 = camlidl_c2ml_z3_Z3_func_decl(&proj_decl[_c8], _ctx); + modify(&Field(_vres[2], _c8), _v9); + } + End_roots() + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vresult; +} + +value camlidl_z3_Z3_mk_enumeration_sort( + value _v_c, + value _v_name, + value _v_enum_names) +{ + Z3_context c; /*in*/ + Z3_symbol name; /*in*/ + unsigned int n; /*in*/ + Z3_symbol const *enum_names; /*in*/ + Z3_func_decl *enum_consts; /*out*/ + Z3_func_decl *enum_testers; /*out*/ + Z3_sort _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + value _v5; + mlsize_t _c6; + value _v7; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_name, &name, _ctx); + _c1 = Wosize_val(_v_enum_names); + enum_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_enum_names, _c2); + camlidl_ml2c_z3_Z3_symbol(_v3, &enum_names[_c2], _ctx); + } + n = _c1; + enum_consts = camlidl_malloc(n * sizeof(Z3_func_decl ), _ctx); + enum_testers = camlidl_malloc(n * sizeof(Z3_func_decl ), _ctx); + _res = Z3_mk_enumeration_sort(c, name, n, enum_names, enum_consts, enum_testers); + Begin_roots_block(_vres, 3) + _vres[0] = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + _vres[1] = camlidl_alloc(n, 0); + Begin_root(_vres[1]) + for (_c4 = 0; _c4 < n; _c4++) { + _v5 = camlidl_c2ml_z3_Z3_func_decl(&enum_consts[_c4], _ctx); + modify(&Field(_vres[1], _c4), _v5); + } + End_roots() + _vres[2] = camlidl_alloc(n, 0); + Begin_root(_vres[2]) + for (_c6 = 0; _c6 < n; _c6++) { + _v7 = camlidl_c2ml_z3_Z3_func_decl(&enum_testers[_c6], _ctx); + modify(&Field(_vres[2], _c6), _v7); + } + End_roots() + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vresult; +} + +value camlidl_z3_Z3_mk_list_sort( + value _v_c, + value _v_name, + value _v_elem_sort) +{ + Z3_context c; /*in*/ + Z3_symbol name; /*in*/ + Z3_sort elem_sort; /*in*/ + Z3_func_decl *nil_decl; /*out*/ + Z3_func_decl *is_nil_decl; /*out*/ + Z3_func_decl *cons_decl; /*out*/ + Z3_func_decl *is_cons_decl; /*out*/ + Z3_func_decl *head_decl; /*out*/ + Z3_func_decl *tail_decl; /*out*/ + Z3_sort _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + Z3_func_decl _c1; + Z3_func_decl _c2; + Z3_func_decl _c3; + Z3_func_decl _c4; + Z3_func_decl _c5; + Z3_func_decl _c6; + value _vresult; + value _vres[7] = { 0, 0, 0, 0, 0, 0, 0, }; + + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_name, &name, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_elem_sort, &elem_sort, _ctx); + nil_decl = &_c1; + is_nil_decl = &_c2; + cons_decl = &_c3; + is_cons_decl = &_c4; + head_decl = &_c5; + tail_decl = &_c6; + _res = Z3_mk_list_sort(c, name, elem_sort, nil_decl, is_nil_decl, cons_decl, is_cons_decl, head_decl, tail_decl); + Begin_roots_block(_vres, 7) + _vres[0] = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + _vres[1] = camlidl_c2ml_z3_Z3_func_decl(&*nil_decl, _ctx); + _vres[2] = camlidl_c2ml_z3_Z3_func_decl(&*is_nil_decl, _ctx); + _vres[3] = camlidl_c2ml_z3_Z3_func_decl(&*cons_decl, _ctx); + _vres[4] = camlidl_c2ml_z3_Z3_func_decl(&*is_cons_decl, _ctx); + _vres[5] = camlidl_c2ml_z3_Z3_func_decl(&*head_decl, _ctx); + _vres[6] = camlidl_c2ml_z3_Z3_func_decl(&*tail_decl, _ctx); + _vresult = camlidl_alloc_small(7, 0); + { mlsize_t _c7; + for (_c7 = 0; _c7 < 7; _c7++) Field(_vresult, _c7) = _vres[_c7]; + } + End_roots() + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vresult; +} + +value camlidl_z3_Z3_mk_constructor( + value _v_c, + value _v_name, + value _v_recognizer, + value _v_field_names, + value _v_sorts, + value _v_sort_refs) +{ + Z3_context c; /*in*/ + Z3_symbol name; /*in*/ + Z3_symbol recognizer; /*in*/ + unsigned int num_fields; /*in*/ + Z3_symbol const *field_names; /*in*/ + Z3_sort_opt const *sorts; /*in*/ + unsigned int *sort_refs; /*in*/ + Z3_constructor _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_name, &name, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_recognizer, &recognizer, _ctx); + _c1 = Wosize_val(_v_field_names); + field_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_field_names, _c2); + camlidl_ml2c_z3_Z3_symbol(_v3, &field_names[_c2], _ctx); + } + num_fields = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort_opt const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3_Z3_sort_opt(_v6, &sorts[_c5], _ctx); + } + num_fields = _c4; + _c7 = Wosize_val(_v_sort_refs); + sort_refs = camlidl_malloc(_c7 * sizeof(unsigned int ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_sort_refs, _c8); + sort_refs[_c8] = Int_val(_v9); + } + num_fields = _c7; + _res = Z3_mk_constructor(c, name, recognizer, num_fields, field_names, sorts, sort_refs); + _vres = camlidl_c2ml_z3_Z3_constructor(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_constructor_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_mk_constructor(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3_Z3_del_constructor( + value _v_c, + value _v_constr) +{ + Z3_context c; /*in*/ + Z3_constructor constr; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_constructor(_v_constr, &constr, _ctx); + Z3_del_constructor(c, constr); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_mk_datatype( + value _v_c, + value _v_name, + value _v_constructors) +{ + Z3_context c; /*in*/ + Z3_symbol name; /*in*/ + unsigned int num_constructors; /*in*/ + Z3_constructor *constructors; /*in,out*/ + Z3_sort _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + value _v5; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_name, &name, _ctx); + _c1 = Wosize_val(_v_constructors); + constructors = camlidl_malloc(_c1 * sizeof(Z3_constructor ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_constructors, _c2); + camlidl_ml2c_z3_Z3_constructor(_v3, &constructors[_c2], _ctx); + } + num_constructors = _c1; + _res = Z3_mk_datatype(c, name, num_constructors, constructors); + Begin_roots_block(_vres, 2) + _vres[0] = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + _vres[1] = camlidl_alloc(num_constructors, 0); + Begin_root(_vres[1]) + for (_c4 = 0; _c4 < num_constructors; _c4++) { + _v5 = camlidl_c2ml_z3_Z3_constructor(&constructors[_c4], _ctx); + modify(&Field(_vres[1], _c4), _v5); + } + End_roots() + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vresult; +} + +value camlidl_z3_Z3_mk_constructor_list( + value _v_c, + value _v_constructors) +{ + Z3_context c; /*in*/ + unsigned int num_constructors; /*in*/ + Z3_constructor const *constructors; /*in*/ + Z3_constructor_list _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_constructors); + constructors = camlidl_malloc(_c1 * sizeof(Z3_constructor const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_constructors, _c2); + camlidl_ml2c_z3_Z3_constructor(_v3, &constructors[_c2], _ctx); + } + num_constructors = _c1; + _res = Z3_mk_constructor_list(c, num_constructors, constructors); + _vres = camlidl_c2ml_z3_Z3_constructor_list(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_del_constructor_list( + value _v_c, + value _v_clist) +{ + Z3_context c; /*in*/ + Z3_constructor_list clist; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_constructor_list(_v_clist, &clist, _ctx); + Z3_del_constructor_list(c, clist); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_mk_datatypes( + value _v_c, + value _v_sort_names, + value _v_constructor_lists) +{ + Z3_context c; /*in*/ + unsigned int num_sorts; /*in*/ + Z3_symbol const *sort_names; /*in*/ + Z3_sort *sorts; /*out*/ + Z3_constructor_list *constructor_lists; /*in,out*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + value _v8; + mlsize_t _c9; + value _v10; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_sort_names); + sort_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_sort_names, _c2); + camlidl_ml2c_z3_Z3_symbol(_v3, &sort_names[_c2], _ctx); + } + num_sorts = _c1; + _c4 = Wosize_val(_v_constructor_lists); + constructor_lists = camlidl_malloc(_c4 * sizeof(Z3_constructor_list ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_constructor_lists, _c5); + camlidl_ml2c_z3_Z3_constructor_list(_v6, &constructor_lists[_c5], _ctx); + } + num_sorts = _c4; + sorts = camlidl_malloc(num_sorts * sizeof(Z3_sort ), _ctx); + Z3_mk_datatypes(c, num_sorts, sort_names, sorts, constructor_lists); + Begin_roots_block(_vres, 2) + _vres[0] = camlidl_alloc(num_sorts, 0); + Begin_root(_vres[0]) + for (_c7 = 0; _c7 < num_sorts; _c7++) { + _v8 = camlidl_c2ml_z3_Z3_sort(&sorts[_c7], _ctx); + modify(&Field(_vres[0], _c7), _v8); + } + End_roots() + _vres[1] = camlidl_alloc(num_sorts, 0); + Begin_root(_vres[1]) + for (_c9 = 0; _c9 < num_sorts; _c9++) { + _v10 = camlidl_c2ml_z3_Z3_constructor_list(&constructor_lists[_c9], _ctx); + modify(&Field(_vres[1], _c9), _v10); + } + End_roots() + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vresult; +} + +value camlidl_z3_Z3_query_constructor( + value _v_c, + value _v_constr, + value _v_num_fields) +{ + Z3_context c; /*in*/ + Z3_constructor constr; /*in*/ + unsigned int num_fields; /*in*/ + Z3_func_decl *constructor; /*out*/ + Z3_func_decl *tester; /*out*/ + Z3_func_decl *accessors; /*out*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + Z3_func_decl _c1; + Z3_func_decl _c2; + mlsize_t _c3; + value _v4; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_constructor(_v_constr, &constr, _ctx); + num_fields = Int_val(_v_num_fields); + constructor = &_c1; + tester = &_c2; + accessors = camlidl_malloc(num_fields * sizeof(Z3_func_decl ), _ctx); + Z3_query_constructor(c, constr, num_fields, constructor, tester, accessors); + Begin_roots_block(_vres, 3) + _vres[0] = camlidl_c2ml_z3_Z3_func_decl(&*constructor, _ctx); + _vres[1] = camlidl_c2ml_z3_Z3_func_decl(&*tester, _ctx); + _vres[2] = camlidl_alloc(num_fields, 0); + Begin_root(_vres[2]) + for (_c3 = 0; _c3 < num_fields; _c3++) { + _v4 = camlidl_c2ml_z3_Z3_func_decl(&accessors[_c3], _ctx); + modify(&Field(_vres[2], _c3), _v4); + } + End_roots() + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vresult; +} + +value camlidl_z3_Z3_mk_func_decl( + value _v_c, + value _v_s, + value _v_domain, + value _v_range) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + unsigned int domain_size; /*in*/ + Z3_sort const *domain; /*in*/ + Z3_sort range; /*in*/ + Z3_func_decl _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_s, &s, _ctx); + _c1 = Wosize_val(_v_domain); + domain = camlidl_malloc(_c1 * sizeof(Z3_sort const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_domain, _c2); + camlidl_ml2c_z3_Z3_sort(_v3, &domain[_c2], _ctx); + } + domain_size = _c1; + camlidl_ml2c_z3_Z3_sort(_v_range, &range, _ctx); + _res = Z3_mk_func_decl(c, s, domain_size, domain, range); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_app( + value _v_c, + value _v_d, + value _v_args) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_app(c, d, num_args, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_const( + value _v_c, + value _v_s, + value _v_ty) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_s, &s, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_const(c, s, ty); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_fresh_func_decl( + value _v_c, + value _v_prefix, + value _v_domain, + value _v_range) +{ + Z3_context c; /*in*/ + Z3_string prefix; /*in*/ + unsigned int domain_size; /*in*/ + Z3_sort const *domain; /*in*/ + Z3_sort range; /*in*/ + Z3_func_decl _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_prefix, &prefix, _ctx); + _c1 = Wosize_val(_v_domain); + domain = camlidl_malloc(_c1 * sizeof(Z3_sort const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_domain, _c2); + camlidl_ml2c_z3_Z3_sort(_v3, &domain[_c2], _ctx); + } + domain_size = _c1; + camlidl_ml2c_z3_Z3_sort(_v_range, &range, _ctx); + _res = Z3_mk_fresh_func_decl(c, prefix, domain_size, domain, range); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_fresh_const( + value _v_c, + value _v_prefix, + value _v_ty) +{ + Z3_context c; /*in*/ + Z3_string prefix; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_prefix, &prefix, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_fresh_const(c, prefix, ty); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_true( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_true(c); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_false( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_false(c); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_eq( + value _v_c, + value _v_l, + value _v_r) +{ + Z3_context c; /*in*/ + Z3_ast l; /*in*/ + Z3_ast r; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_l, &l, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_r, &r, _ctx); + _res = Z3_mk_eq(c, l, r); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_distinct( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_distinct(c, num_args, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_not( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_mk_not(c, a); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_ite( + value _v_c, + value _v_t1, + value _v_t2, + value _v_t3) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast t3; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t3, &t3, _ctx); + _res = Z3_mk_ite(c, t1, t2, t3); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_iff( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_iff(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_implies( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_implies(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_xor( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_xor(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_and( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_and(c, num_args, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_or( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_or(c, num_args, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_add( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_add(c, num_args, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_mul( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_mul(c, num_args, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_sub( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_sub(c, num_args, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_unary_minus( + value _v_c, + value _v_arg) +{ + Z3_context c; /*in*/ + Z3_ast arg; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg, &arg, _ctx); + _res = Z3_mk_unary_minus(c, arg); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_div( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_div(c, arg1, arg2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_mod( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_mod(c, arg1, arg2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_rem( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_rem(c, arg1, arg2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_power( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_power(c, arg1, arg2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_lt( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_lt(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_le( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_le(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_gt( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_gt(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_ge( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_ge(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_int2real( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_int2real(c, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_real2int( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_real2int(c, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_is_int( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_is_int(c, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvnot( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_bvnot(c, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvredand( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_bvredand(c, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvredor( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_bvredor(c, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvand( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvand(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvor( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvor(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvxor( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvxor(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvnand( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvnand(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvnor( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvnor(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvxnor( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvxnor(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvneg( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_bvneg(c, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvadd( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvadd(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvsub( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsub(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvmul( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvmul(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvudiv( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvudiv(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvsdiv( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsdiv(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvurem( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvurem(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvsrem( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsrem(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvsmod( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsmod(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvult( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvult(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvslt( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvslt(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvule( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvule(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvsle( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsle(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvuge( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvuge(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvsge( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsge(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvugt( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvugt(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvsgt( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsgt(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_concat( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_concat(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_extract( + value _v_c, + value _v_high, + value _v_low, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int high; /*in*/ + unsigned int low; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + high = Int_val(_v_high); + low = Int_val(_v_low); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_extract(c, high, low, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_sign_ext( + value _v_c, + value _v_i, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_sign_ext(c, i, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_zero_ext( + value _v_c, + value _v_i, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_zero_ext(c, i, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_repeat( + value _v_c, + value _v_i, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_repeat(c, i, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvshl( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvshl(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvlshr( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvlshr(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvashr( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvashr(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_rotate_left( + value _v_c, + value _v_i, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_rotate_left(c, i, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_rotate_right( + value _v_c, + value _v_i, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_rotate_right(c, i, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_ext_rotate_left( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_ext_rotate_left(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_ext_rotate_right( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_ext_rotate_right(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_int2bv( + value _v_c, + value _v_n, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int n; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + n = Int_val(_v_n); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_int2bv(c, n, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bv2int( + value _v_c, + value _v_t1, + value _v_is_signed) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + int is_signed; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + is_signed = Int_val(_v_is_signed); + _res = Z3_mk_bv2int(c, t1, is_signed); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvadd_no_overflow( + value _v_c, + value _v_t1, + value _v_t2, + value _v_is_signed) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + int is_signed; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + is_signed = Int_val(_v_is_signed); + _res = Z3_mk_bvadd_no_overflow(c, t1, t2, is_signed); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvadd_no_underflow( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvadd_no_underflow(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvsub_no_overflow( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsub_no_overflow(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvsub_no_underflow( + value _v_c, + value _v_t1, + value _v_t2, + value _v_is_signed) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + int is_signed; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + is_signed = Int_val(_v_is_signed); + _res = Z3_mk_bvsub_no_underflow(c, t1, t2, is_signed); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvsdiv_no_overflow( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsdiv_no_overflow(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvneg_no_overflow( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_bvneg_no_overflow(c, t1); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvmul_no_overflow( + value _v_c, + value _v_t1, + value _v_t2, + value _v_is_signed) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + int is_signed; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + is_signed = Int_val(_v_is_signed); + _res = Z3_mk_bvmul_no_overflow(c, t1, t2, is_signed); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bvmul_no_underflow( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvmul_no_underflow(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_select( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_i, &i, _ctx); + _res = Z3_mk_select(c, a, i); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_store( + value _v_c, + value _v_a, + value _v_i, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast i; /*in*/ + Z3_ast v; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_i, &i, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_v, &v, _ctx); + _res = Z3_mk_store(c, a, i, v); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_const_array( + value _v_c, + value _v_domain, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_sort domain; /*in*/ + Z3_ast v; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_domain, &domain, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_v, &v, _ctx); + _res = Z3_mk_const_array(c, domain, v); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_map( + value _v_c, + value _v_f, + value _v_n, + value _v_args) +{ + Z3_context c; /*in*/ + Z3_func_decl f; /*in*/ + unsigned int n; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + Z3_ast _c1; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_f, &f, _ctx); + n = Int_val(_v_n); + args = &_c1; + camlidl_ml2c_z3_Z3_ast(_v_args, &_c1, _ctx); + _res = Z3_mk_map(c, f, n, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_array_default( + value _v_c, + value _v_array) +{ + Z3_context c; /*in*/ + Z3_ast array; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_array, &array, _ctx); + _res = Z3_mk_array_default(c, array); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_set_sort( + value _v_c, + value _v_ty) +{ + Z3_context c; /*in*/ + Z3_sort ty; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_set_sort(c, ty); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_empty_set( + value _v_c, + value _v_domain) +{ + Z3_context c; /*in*/ + Z3_sort domain; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_domain, &domain, _ctx); + _res = Z3_mk_empty_set(c, domain); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_full_set( + value _v_c, + value _v_domain) +{ + Z3_context c; /*in*/ + Z3_sort domain; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_domain, &domain, _ctx); + _res = Z3_mk_full_set(c, domain); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_set_add( + value _v_c, + value _v_set, + value _v_elem) +{ + Z3_context c; /*in*/ + Z3_ast set; /*in*/ + Z3_ast elem; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_set, &set, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_elem, &elem, _ctx); + _res = Z3_mk_set_add(c, set, elem); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_set_del( + value _v_c, + value _v_set, + value _v_elem) +{ + Z3_context c; /*in*/ + Z3_ast set; /*in*/ + Z3_ast elem; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_set, &set, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_elem, &elem, _ctx); + _res = Z3_mk_set_del(c, set, elem); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_set_union( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_set_union(c, num_args, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_set_intersect( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_set_intersect(c, num_args, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_set_difference( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_set_difference(c, arg1, arg2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_set_complement( + value _v_c, + value _v_arg) +{ + Z3_context c; /*in*/ + Z3_ast arg; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg, &arg, _ctx); + _res = Z3_mk_set_complement(c, arg); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_set_member( + value _v_c, + value _v_elem, + value _v_set) +{ + Z3_context c; /*in*/ + Z3_ast elem; /*in*/ + Z3_ast set; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_elem, &elem, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_set, &set, _ctx); + _res = Z3_mk_set_member(c, elem, set); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_set_subset( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_set_subset(c, arg1, arg2); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_numeral( + value _v_c, + value _v_numeral, + value _v_ty) +{ + Z3_context c; /*in*/ + Z3_string numeral; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_numeral, &numeral, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_numeral(c, numeral, ty); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_real( + value _v_c, + value _v_num, + value _v_den) +{ + Z3_context c; /*in*/ + int num; /*in*/ + int den; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + num = Int_val(_v_num); + den = Int_val(_v_den); + _res = Z3_mk_real(c, num, den); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_int( + value _v_c, + value _v_v, + value _v_ty) +{ + Z3_context c; /*in*/ + int v; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + v = Int_val(_v_v); + camlidl_ml2c_z3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_int(c, v, ty); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_int64( + value _v_c, + value _v_v, + value _v_ty) +{ + Z3_context c; /*in*/ + __int64 v; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + v = Int64_val(_v_v); + camlidl_ml2c_z3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_int64(c, v, ty); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_pattern( + value _v_c, + value _v_terms) +{ + Z3_context c; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_ast const *terms; /*in*/ + Z3_pattern _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_terms); + terms = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_terms, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &terms[_c2], _ctx); + } + num_patterns = _c1; + _res = Z3_mk_pattern(c, num_patterns, terms); + _vres = camlidl_c2ml_z3_Z3_pattern(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_bound( + value _v_c, + value _v_index, + value _v_ty) +{ + Z3_context c; /*in*/ + unsigned int index; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + index = Int_val(_v_index); + camlidl_ml2c_z3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_bound(c, index, ty); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_forall( + value _v_c, + value _v_weight, + value _v_patterns, + value _v_sorts, + value _v_decl_names, + value _v_body) +{ + Z3_context c; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + unsigned int num_decls; /*in*/ + Z3_sort const *sorts; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c1 * sizeof(Z3_pattern const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_patterns, _c2); + camlidl_ml2c_z3_Z3_pattern(_v3, &patterns[_c2], _ctx); + } + num_patterns = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_decls = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + camlidl_ml2c_z3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_forall(c, weight, num_patterns, patterns, num_decls, sorts, decl_names, body); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_forall_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_mk_forall(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3_Z3_mk_exists( + value _v_c, + value _v_weight, + value _v_patterns, + value _v_sorts, + value _v_decl_names, + value _v_body) +{ + Z3_context c; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + unsigned int num_decls; /*in*/ + Z3_sort const *sorts; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c1 * sizeof(Z3_pattern const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_patterns, _c2); + camlidl_ml2c_z3_Z3_pattern(_v3, &patterns[_c2], _ctx); + } + num_patterns = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_decls = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + camlidl_ml2c_z3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_exists(c, weight, num_patterns, patterns, num_decls, sorts, decl_names, body); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_exists_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_mk_exists(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3_Z3_mk_quantifier( + value _v_c, + value _v_is_forall, + value _v_weight, + value _v_patterns, + value _v_sorts, + value _v_decl_names, + value _v_body) +{ + Z3_context c; /*in*/ + int is_forall; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + unsigned int num_decls; /*in*/ + Z3_sort const *sorts; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + is_forall = Int_val(_v_is_forall); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c1 * sizeof(Z3_pattern const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_patterns, _c2); + camlidl_ml2c_z3_Z3_pattern(_v3, &patterns[_c2], _ctx); + } + num_patterns = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_decls = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + camlidl_ml2c_z3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_quantifier(c, is_forall, weight, num_patterns, patterns, num_decls, sorts, decl_names, body); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_quantifier_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_mk_quantifier(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]); +} + +value camlidl_z3_Z3_mk_quantifier_ex( + value _v_c, + value _v_is_forall, + value _v_weight, + value _v_quantifier_id, + value _v_skolem_id, + value _v_patterns, + value _v_no_patterns, + value _v_sorts, + value _v_decl_names, + value _v_body) +{ + Z3_context c; /*in*/ + int is_forall; /*in*/ + unsigned int weight; /*in*/ + Z3_symbol quantifier_id; /*in*/ + Z3_symbol skolem_id; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + unsigned int num_no_patterns; /*in*/ + Z3_ast const *no_patterns; /*in*/ + unsigned int num_decls; /*in*/ + Z3_sort const *sorts; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + mlsize_t _c11; + value _v12; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + is_forall = Int_val(_v_is_forall); + weight = Int_val(_v_weight); + camlidl_ml2c_z3_Z3_symbol(_v_quantifier_id, &quantifier_id, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_skolem_id, &skolem_id, _ctx); + _c1 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c1 * sizeof(Z3_pattern const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_patterns, _c2); + camlidl_ml2c_z3_Z3_pattern(_v3, &patterns[_c2], _ctx); + } + num_patterns = _c1; + _c4 = Wosize_val(_v_no_patterns); + no_patterns = camlidl_malloc(_c4 * sizeof(Z3_ast const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_no_patterns, _c5); + camlidl_ml2c_z3_Z3_ast(_v6, &no_patterns[_c5], _ctx); + } + num_no_patterns = _c4; + _c7 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c7 * sizeof(Z3_sort const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_sorts, _c8); + camlidl_ml2c_z3_Z3_sort(_v9, &sorts[_c8], _ctx); + } + num_decls = _c7; + _c10 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c10 * sizeof(Z3_symbol const ), _ctx); + for (_c11 = 0; _c11 < _c10; _c11++) { + _v12 = Field(_v_decl_names, _c11); + camlidl_ml2c_z3_Z3_symbol(_v12, &decl_names[_c11], _ctx); + } + num_decls = _c10; + camlidl_ml2c_z3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_quantifier_ex(c, is_forall, weight, quantifier_id, skolem_id, num_patterns, patterns, num_no_patterns, no_patterns, num_decls, sorts, decl_names, body); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_quantifier_ex_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_mk_quantifier_ex(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]); +} + +value camlidl_z3_Z3_mk_forall_const( + value _v_c, + value _v_weight, + value _v_bound, + value _v_patterns, + value _v_body) +{ + Z3_context c; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_bound; /*in*/ + Z3_app const *bound; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_bound); + bound = camlidl_malloc(_c1 * sizeof(Z3_app const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_bound, _c2); + camlidl_ml2c_z3_Z3_app(_v3, &bound[_c2], _ctx); + } + num_bound = _c1; + _c4 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c4 * sizeof(Z3_pattern const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_patterns, _c5); + camlidl_ml2c_z3_Z3_pattern(_v6, &patterns[_c5], _ctx); + } + num_patterns = _c4; + camlidl_ml2c_z3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_forall_const(c, weight, num_bound, bound, num_patterns, patterns, body); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_exists_const( + value _v_c, + value _v_weight, + value _v_bound, + value _v_patterns, + value _v_body) +{ + Z3_context c; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_bound; /*in*/ + Z3_app const *bound; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_bound); + bound = camlidl_malloc(_c1 * sizeof(Z3_app const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_bound, _c2); + camlidl_ml2c_z3_Z3_app(_v3, &bound[_c2], _ctx); + } + num_bound = _c1; + _c4 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c4 * sizeof(Z3_pattern const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_patterns, _c5); + camlidl_ml2c_z3_Z3_pattern(_v6, &patterns[_c5], _ctx); + } + num_patterns = _c4; + camlidl_ml2c_z3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_exists_const(c, weight, num_bound, bound, num_patterns, patterns, body); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_quantifier_const( + value _v_c, + value _v_is_forall, + value _v_weight, + value _v_bound, + value _v_patterns, + value _v_body) +{ + Z3_context c; /*in*/ + int is_forall; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_bound; /*in*/ + Z3_app const *bound; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + is_forall = Int_val(_v_is_forall); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_bound); + bound = camlidl_malloc(_c1 * sizeof(Z3_app const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_bound, _c2); + camlidl_ml2c_z3_Z3_app(_v3, &bound[_c2], _ctx); + } + num_bound = _c1; + _c4 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c4 * sizeof(Z3_pattern const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_patterns, _c5); + camlidl_ml2c_z3_Z3_pattern(_v6, &patterns[_c5], _ctx); + } + num_patterns = _c4; + camlidl_ml2c_z3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_quantifier_const(c, is_forall, weight, num_bound, bound, num_patterns, patterns, body); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_quantifier_const_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_mk_quantifier_const(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3_Z3_mk_quantifier_const_ex( + value _v_c, + value _v_is_forall, + value _v_weight, + value _v_quantifier_id, + value _v_skolem_id, + value _v_bound, + value _v_patterns, + value _v_no_patterns, + value _v_body) +{ + Z3_context c; /*in*/ + int is_forall; /*in*/ + unsigned int weight; /*in*/ + Z3_symbol quantifier_id; /*in*/ + Z3_symbol skolem_id; /*in*/ + unsigned int num_bound; /*in*/ + Z3_app const *bound; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + unsigned int num_no_patterns; /*in*/ + Z3_ast const *no_patterns; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + is_forall = Int_val(_v_is_forall); + weight = Int_val(_v_weight); + camlidl_ml2c_z3_Z3_symbol(_v_quantifier_id, &quantifier_id, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_skolem_id, &skolem_id, _ctx); + _c1 = Wosize_val(_v_bound); + bound = camlidl_malloc(_c1 * sizeof(Z3_app const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_bound, _c2); + camlidl_ml2c_z3_Z3_app(_v3, &bound[_c2], _ctx); + } + num_bound = _c1; + _c4 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c4 * sizeof(Z3_pattern const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_patterns, _c5); + camlidl_ml2c_z3_Z3_pattern(_v6, &patterns[_c5], _ctx); + } + num_patterns = _c4; + _c7 = Wosize_val(_v_no_patterns); + no_patterns = camlidl_malloc(_c7 * sizeof(Z3_ast const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_no_patterns, _c8); + camlidl_ml2c_z3_Z3_ast(_v9, &no_patterns[_c8], _ctx); + } + num_no_patterns = _c7; + camlidl_ml2c_z3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_quantifier_const_ex(c, is_forall, weight, quantifier_id, skolem_id, num_bound, bound, num_patterns, patterns, num_no_patterns, no_patterns, body); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_quantifier_const_ex_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_mk_quantifier_const_ex(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]); +} + +value camlidl_z3_Z3_get_symbol_kind( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + Z3_symbol_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_s, &s, _ctx); + _res = Z3_get_symbol_kind(c, s); + _vres = camlidl_c2ml_z3_Z3_symbol_kind(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_symbol_int( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_s, &s, _ctx); + _res = Z3_get_symbol_int(c, s); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_symbol_string( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_s, &s, _ctx); + _res = Z3_get_symbol_string(c, s); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_sort_name( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_sort d; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_d, &d, _ctx); + _res = Z3_get_sort_name(c, d); + _vres = camlidl_c2ml_z3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_sort_id( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_get_sort_id(c, s); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_sort_to_ast( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_sort_to_ast(c, s); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_is_eq_sort( + value _v_c, + value _v_s1, + value _v_s2) +{ + Z3_context c; /*in*/ + Z3_sort s1; /*in*/ + Z3_sort s2; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_s1, &s1, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_s2, &s2, _ctx); + _res = Z3_is_eq_sort(c, s1, s2); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_sort_kind( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + Z3_sort_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_sort_kind(c, t); + _vres = camlidl_c2ml_z3_Z3_sort_kind(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_bv_sort_size( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_bv_sort_size(c, t); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_finite_domain_sort_size( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + __int64 *r; /*out*/ + __int64 _c1; + value _v2; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_s, &s, _ctx); + r = &_c1; + Z3_get_finite_domain_sort_size(c, s, r); + if (r == NULL) { + _vres = Val_int(0); + } else { + _v2 = copy_int64(*r); + Begin_root(_v2) + _vres = camlidl_alloc_small(1, 0); + Field(_vres, 0) = _v2; + End_roots(); + } + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_array_sort_domain( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_array_sort_domain(c, t); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_array_sort_range( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_array_sort_range(c, t); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_tuple_sort_mk_decl( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_tuple_sort_mk_decl(c, t); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_tuple_sort_num_fields( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_tuple_sort_num_fields(c, t); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_tuple_sort_field_decl( + value _v_c, + value _v_t, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int i; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + i = Int_val(_v_i); + _res = Z3_get_tuple_sort_field_decl(c, t, i); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_datatype_sort_num_constructors( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_datatype_sort_num_constructors(c, t); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_datatype_sort_constructor( + value _v_c, + value _v_t, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int idx; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_datatype_sort_constructor(c, t, idx); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_datatype_sort_recognizer( + value _v_c, + value _v_t, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int idx; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_datatype_sort_recognizer(c, t, idx); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_datatype_sort_constructor_accessor( + value _v_c, + value _v_t, + value _v_idx_c, + value _v_idx_a) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int idx_c; /*in*/ + unsigned int idx_a; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_t, &t, _ctx); + idx_c = Int_val(_v_idx_c); + idx_a = Int_val(_v_idx_a); + _res = Z3_get_datatype_sort_constructor_accessor(c, t, idx_c, idx_a); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_relation_arity( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_get_relation_arity(c, s); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_relation_column( + value _v_c, + value _v_s, + value _v_col) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + unsigned int col; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_s, &s, _ctx); + col = Int_val(_v_col); + _res = Z3_get_relation_column(c, s, col); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_func_decl_to_ast( + value _v_c, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_func_decl f; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_f, &f, _ctx); + _res = Z3_func_decl_to_ast(c, f); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_is_eq_func_decl( + value _v_c, + value _v_f1, + value _v_f2) +{ + Z3_context c; /*in*/ + Z3_func_decl f1; /*in*/ + Z3_func_decl f2; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_f1, &f1, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_f2, &f2, _ctx); + _res = Z3_is_eq_func_decl(c, f1, f2); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_func_decl_id( + value _v_c, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_func_decl f; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_f, &f, _ctx); + _res = Z3_get_func_decl_id(c, f); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_name( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_decl_name(c, d); + _vres = camlidl_c2ml_z3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_kind( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + Z3_decl_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_decl_kind(c, d); + _vres = camlidl_c2ml_z3_Z3_decl_kind(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_domain_size( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_domain_size(c, d); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_arity( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_arity(c, d); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_domain( + value _v_c, + value _v_d, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int i; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + i = Int_val(_v_i); + _res = Z3_get_domain(c, d, i); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_range( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_range(c, d); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_num_parameters( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_decl_num_parameters(c, d); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_parameter_kind( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_parameter_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_parameter_kind(c, d, idx); + _vres = camlidl_c2ml_z3_Z3_parameter_kind(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_int_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_int_parameter(c, d, idx); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_double_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + double _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_double_parameter(c, d, idx); + _vres = copy_double(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_symbol_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_symbol_parameter(c, d, idx); + _vres = camlidl_c2ml_z3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_sort_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_sort_parameter(c, d, idx); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_ast_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_ast_parameter(c, d, idx); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_func_decl_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_func_decl_parameter(c, d, idx); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_decl_rational_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_rational_parameter(c, d, idx); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_app_to_ast( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_app a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_app(_v_a, &a, _ctx); + _res = Z3_app_to_ast(c, a); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_app_decl( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_app a; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_app(_v_a, &a, _ctx); + _res = Z3_get_app_decl(c, a); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_app_num_args( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_app a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_app(_v_a, &a, _ctx); + _res = Z3_get_app_num_args(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_app_arg( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_app a; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_app(_v_a, &a, _ctx); + i = Int_val(_v_i); + _res = Z3_get_app_arg(c, a, i); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_is_eq_ast( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_is_eq_ast(c, t1, t2); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_ast_id( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_ast t; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t, &t, _ctx); + _res = Z3_get_ast_id(c, t); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_ast_hash( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_ast_hash(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_sort( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_sort(c, a); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_is_well_sorted( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_ast t; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t, &t, _ctx); + _res = Z3_is_well_sorted(c, t); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_bool_value( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_lbool _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_bool_value(c, a); + _vres = camlidl_c2ml_z3_Z3_lbool(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_ast_kind( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_ast_kind(c, a); + _vres = camlidl_c2ml_z3_Z3_ast_kind(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_is_app( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_is_app(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_is_numeral_ast( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_is_numeral_ast(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_is_algebraic_number( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_is_algebraic_number(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_to_app( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_app _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_to_app(c, a); + _vres = camlidl_c2ml_z3_Z3_app(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_to_func_decl( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_to_func_decl(c, a); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_numeral_string( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_numeral_string(c, a); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_numeral_decimal_string( + value _v_c, + value _v_a, + value _v_precision) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int precision; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + precision = Int_val(_v_precision); + _res = Z3_get_numeral_decimal_string(c, a, precision); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_numerator( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_numerator(c, a); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_denominator( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_denominator(c, a); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_numeral_small( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + __int64 *num; /*out*/ + __int64 *den; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + __int64 _c1; + __int64 _c2; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + num = &_c1; + den = &_c2; + _res = Z3_get_numeral_small(c, a, num, den); + Begin_roots_block(_vres, 3) + _vres[0] = Val_int(_res); + _vres[1] = copy_int64(*num); + _vres[2] = copy_int64(*den); + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vresult; +} + +value camlidl_z3_Z3_get_numeral_int( + value _v_c, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast v; /*in*/ + int *i; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + int _c1; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_v, &v, _ctx); + i = &_c1; + _res = Z3_get_numeral_int(c, v, i); + Begin_roots_block(_vres, 2) + _vres[0] = Val_int(_res); + _vres[1] = Val_int(*i); + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vresult; +} + +value camlidl_z3_Z3_get_numeral_int64( + value _v_c, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast v; /*in*/ + __int64 *i; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + __int64 _c1; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_v, &v, _ctx); + i = &_c1; + _res = Z3_get_numeral_int64(c, v, i); + Begin_roots_block(_vres, 2) + _vres[0] = Val_int(_res); + _vres[1] = copy_int64(*i); + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vresult; +} + +value camlidl_z3_Z3_get_numeral_rational_int64( + value _v_c, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast v; /*in*/ + __int64 *num; /*out*/ + __int64 *den; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + __int64 _c1; + __int64 _c2; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_v, &v, _ctx); + num = &_c1; + den = &_c2; + _res = Z3_get_numeral_rational_int64(c, v, num, den); + Begin_roots_block(_vres, 3) + _vres[0] = Val_int(_res); + _vres[1] = copy_int64(*num); + _vres[2] = copy_int64(*den); + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vresult; +} + +value camlidl_z3_Z3_get_algebraic_number_lower( + value _v_c, + value _v_a, + value _v_precision) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int precision; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + precision = Int_val(_v_precision); + _res = Z3_get_algebraic_number_lower(c, a, precision); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_algebraic_number_upper( + value _v_c, + value _v_a, + value _v_precision) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int precision; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + precision = Int_val(_v_precision); + _res = Z3_get_algebraic_number_upper(c, a, precision); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_pattern_to_ast( + value _v_c, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_pattern p; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_pattern(_v_p, &p, _ctx); + _res = Z3_pattern_to_ast(c, p); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_pattern_num_terms( + value _v_c, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_pattern p; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_pattern(_v_p, &p, _ctx); + _res = Z3_get_pattern_num_terms(c, p); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_pattern( + value _v_c, + value _v_p, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_pattern p; /*in*/ + unsigned int idx; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_pattern(_v_p, &p, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_pattern(c, p, idx); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_index_value( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_index_value(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_is_quantifier_forall( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_is_quantifier_forall(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_quantifier_weight( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_quantifier_weight(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_quantifier_num_patterns( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_quantifier_num_patterns(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_quantifier_pattern_ast( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int i; /*in*/ + Z3_pattern _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + i = Int_val(_v_i); + _res = Z3_get_quantifier_pattern_ast(c, a, i); + _vres = camlidl_c2ml_z3_Z3_pattern(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_quantifier_num_no_patterns( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_quantifier_num_no_patterns(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_quantifier_no_pattern_ast( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + i = Int_val(_v_i); + _res = Z3_get_quantifier_no_pattern_ast(c, a, i); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_quantifier_bound_name( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int i; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + i = Int_val(_v_i); + _res = Z3_get_quantifier_bound_name(c, a, i); + _vres = camlidl_c2ml_z3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_quantifier_bound_sort( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int i; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + i = Int_val(_v_i); + _res = Z3_get_quantifier_bound_sort(c, a, i); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_quantifier_body( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_quantifier_body(c, a); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_quantifier_num_bound( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_quantifier_num_bound(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_simplify( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_simplify(c, a); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_simplify_ex( + value _v_c, + value _v_a, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_params p; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + _res = Z3_simplify_ex(c, a, p); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_simplify_get_help( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_simplify_get_help(c); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_simplify_get_param_descrs( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_param_descrs _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_simplify_get_param_descrs(c); + _vres = camlidl_c2ml_z3_Z3_param_descrs(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_update_term( + value _v_c, + value _v_a, + value _v_args) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_update_term(c, a, num_args, args); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_substitute( + value _v_c, + value _v_a, + value _v_from, + value _v_to) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int num_exprs; /*in*/ + Z3_ast const *from; /*in*/ + Z3_ast const *to; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _c1 = Wosize_val(_v_from); + from = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_from, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &from[_c2], _ctx); + } + num_exprs = _c1; + _c4 = Wosize_val(_v_to); + to = camlidl_malloc(_c4 * sizeof(Z3_ast const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_to, _c5); + camlidl_ml2c_z3_Z3_ast(_v6, &to[_c5], _ctx); + } + num_exprs = _c4; + _res = Z3_substitute(c, a, num_exprs, from, to); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_substitute_vars( + value _v_c, + value _v_a, + value _v_to) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int num_exprs; /*in*/ + Z3_ast const *to; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _c1 = Wosize_val(_v_to); + to = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_to, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &to[_c2], _ctx); + } + num_exprs = _c1; + _res = Z3_substitute_vars(c, a, num_exprs, to); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_translate( + value _v_source, + value _v_a, + value _v_target) +{ + Z3_context source; /*in*/ + Z3_ast a; /*in*/ + Z3_context target; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_source, &source, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + camlidl_ml2c_z3_Z3_context(_v_target, &target, _ctx); + _res = Z3_translate(source, a, target); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(source); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_eval( + value _v_c, + value _v_m, + value _v_t, + value _v_model_completion) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_ast t; /*in*/ + int model_completion; /*in*/ + Z3_ast *v; /*out*/ + Z3_ast _c1; + value _v2; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_t, &t, _ctx); + model_completion = Int_val(_v_model_completion); + v = &_c1; + Z3_model_eval(c, m, t, model_completion, v); + if (v == NULL) { + _vres = Val_int(0); + } else { + _v2 = camlidl_c2ml_z3_Z3_ast(&*v, _ctx); + Begin_root(_v2) + _vres = camlidl_alloc_small(1, 0); + Field(_vres, 0) = _v2; + End_roots(); + } + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_get_const_interp( + value _v_c, + value _v_m, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_func_decl a; /*in*/ + Z3_ast_opt _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_a, &a, _ctx); + _res = Z3_model_get_const_interp(c, m, a); + _vres = camlidl_c2ml_z3_Z3_ast_opt(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_get_func_interp( + value _v_c, + value _v_m, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_func_decl f; /*in*/ + Z3_func_interp_opt _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_f, &f, _ctx); + _res = Z3_model_get_func_interp(c, m, f); + _vres = camlidl_c2ml_z3_Z3_func_interp_opt(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_get_num_consts( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + _res = Z3_model_get_num_consts(c, m); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_get_const_decl( + value _v_c, + value _v_m, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int i; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + i = Int_val(_v_i); + _res = Z3_model_get_const_decl(c, m, i); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_get_num_funcs( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + _res = Z3_model_get_num_funcs(c, m); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_get_func_decl( + value _v_c, + value _v_m, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int i; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + i = Int_val(_v_i); + _res = Z3_model_get_func_decl(c, m, i); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_get_num_sorts( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + _res = Z3_model_get_num_sorts(c, m); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_get_sort( + value _v_c, + value _v_m, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int i; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + i = Int_val(_v_i); + _res = Z3_model_get_sort(c, m, i); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_get_sort_universe( + value _v_c, + value _v_m, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_sort s; /*in*/ + Z3_ast_vector _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_model_get_sort_universe(c, m, s); + _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_is_as_array( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_is_as_array(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_as_array_func_decl( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_as_array_func_decl(c, a); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_func_interp_get_num_entries( + value _v_c, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_func_interp f; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_interp(_v_f, &f, _ctx); + _res = Z3_func_interp_get_num_entries(c, f); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_func_interp_get_entry( + value _v_c, + value _v_f, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_func_interp f; /*in*/ + unsigned int i; /*in*/ + Z3_func_entry _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_interp(_v_f, &f, _ctx); + i = Int_val(_v_i); + _res = Z3_func_interp_get_entry(c, f, i); + _vres = camlidl_c2ml_z3_Z3_func_entry(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_func_interp_get_else( + value _v_c, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_func_interp f; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_interp(_v_f, &f, _ctx); + _res = Z3_func_interp_get_else(c, f); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_func_interp_get_arity( + value _v_c, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_func_interp f; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_interp(_v_f, &f, _ctx); + _res = Z3_func_interp_get_arity(c, f); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_func_entry_get_value( + value _v_c, + value _v_e) +{ + Z3_context c; /*in*/ + Z3_func_entry e; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_entry(_v_e, &e, _ctx); + _res = Z3_func_entry_get_value(c, e); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_func_entry_get_num_args( + value _v_c, + value _v_e) +{ + Z3_context c; /*in*/ + Z3_func_entry e; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_entry(_v_e, &e, _ctx); + _res = Z3_func_entry_get_num_args(c, e); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_func_entry_get_arg( + value _v_c, + value _v_e, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_func_entry e; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_entry(_v_e, &e, _ctx); + i = Int_val(_v_i); + _res = Z3_func_entry_get_arg(c, e, i); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_open_log( + value _v_filename) +{ + Z3_string filename; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_string(_v_filename, &filename, _ctx); + _res = Z3_open_log(filename); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3_Z3_append_log( + value _v_string) +{ + Z3_string string; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_string(_v_string, &string, _ctx); + Z3_append_log(string); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3_Z3_close_log(value _unit) +{ + Z3_close_log(); + return Val_unit; +} + +value camlidl_z3_Z3_toggle_warning_messages( + value _v_enabled) +{ + int enabled; /*in*/ + enabled = Int_val(_v_enabled); + Z3_toggle_warning_messages(enabled); + return Val_unit; +} + +value camlidl_z3_Z3_set_ast_print_mode( + value _v_c, + value _v_mode) +{ + Z3_context c; /*in*/ + Z3_ast_print_mode mode; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_print_mode(_v_mode, &mode, _ctx); + Z3_set_ast_print_mode(c, mode); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_ast_to_string( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_ast_to_string(c, a); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_pattern_to_string( + value _v_c, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_pattern p; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_pattern(_v_p, &p, _ctx); + _res = Z3_pattern_to_string(c, p); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_sort_to_string( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_sort_to_string(c, s); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_func_decl_to_string( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_func_decl_to_string(c, d); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_model_to_string( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + _res = Z3_model_to_string(c, m); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_benchmark_to_smtlib_string( + value _v_c, + value _v_name, + value _v_logic, + value _v_status, + value _v_attributes, + value _v_assumptions, + value _v_formula) +{ + Z3_context c; /*in*/ + Z3_string name; /*in*/ + Z3_string logic; /*in*/ + Z3_string status; /*in*/ + Z3_string attributes; /*in*/ + unsigned int num_assumptions; /*in*/ + Z3_ast const *assumptions; /*in*/ + Z3_ast formula; /*in*/ + Z3_string _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_name, &name, _ctx); + camlidl_ml2c_z3_Z3_string(_v_logic, &logic, _ctx); + camlidl_ml2c_z3_Z3_string(_v_status, &status, _ctx); + camlidl_ml2c_z3_Z3_string(_v_attributes, &attributes, _ctx); + _c1 = Wosize_val(_v_assumptions); + assumptions = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_assumptions, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &assumptions[_c2], _ctx); + } + num_assumptions = _c1; + camlidl_ml2c_z3_Z3_ast(_v_formula, &formula, _ctx); + _res = Z3_benchmark_to_smtlib_string(c, name, logic, status, attributes, num_assumptions, assumptions, formula); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_benchmark_to_smtlib_string_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_benchmark_to_smtlib_string(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]); +} + +value camlidl_z3_Z3_parse_smtlib2_string( + value _v_c, + value _v_str, + value _v_sort_names, + value _v_sorts, + value _v_decl_names, + value _v_decls) +{ + Z3_context c; /*in*/ + Z3_string str; /*in*/ + unsigned int num_sorts; /*in*/ + Z3_symbol const *sort_names; /*in*/ + Z3_sort const *sorts; /*in*/ + unsigned int num_decls; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_func_decl const *decls; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + mlsize_t _c11; + value _v12; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_str, &str, _ctx); + _c1 = Wosize_val(_v_sort_names); + sort_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_sort_names, _c2); + camlidl_ml2c_z3_Z3_symbol(_v3, &sort_names[_c2], _ctx); + } + num_sorts = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_sorts = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + _c10 = Wosize_val(_v_decls); + decls = camlidl_malloc(_c10 * sizeof(Z3_func_decl const ), _ctx); + for (_c11 = 0; _c11 < _c10; _c11++) { + _v12 = Field(_v_decls, _c11); + camlidl_ml2c_z3_Z3_func_decl(_v12, &decls[_c11], _ctx); + } + num_decls = _c10; + _res = Z3_parse_smtlib2_string(c, str, num_sorts, sort_names, sorts, num_decls, decl_names, decls); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_parse_smtlib2_string_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_parse_smtlib2_string(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3_Z3_parse_smtlib2_file( + value _v_c, + value _v_file_name, + value _v_sort_names, + value _v_sorts, + value _v_decl_names, + value _v_decls) +{ + Z3_context c; /*in*/ + Z3_string file_name; /*in*/ + unsigned int num_sorts; /*in*/ + Z3_symbol const *sort_names; /*in*/ + Z3_sort const *sorts; /*in*/ + unsigned int num_decls; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_func_decl const *decls; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + mlsize_t _c11; + value _v12; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_file_name, &file_name, _ctx); + _c1 = Wosize_val(_v_sort_names); + sort_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_sort_names, _c2); + camlidl_ml2c_z3_Z3_symbol(_v3, &sort_names[_c2], _ctx); + } + num_sorts = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_sorts = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + _c10 = Wosize_val(_v_decls); + decls = camlidl_malloc(_c10 * sizeof(Z3_func_decl const ), _ctx); + for (_c11 = 0; _c11 < _c10; _c11++) { + _v12 = Field(_v_decls, _c11); + camlidl_ml2c_z3_Z3_func_decl(_v12, &decls[_c11], _ctx); + } + num_decls = _c10; + _res = Z3_parse_smtlib2_file(c, file_name, num_sorts, sort_names, sorts, num_decls, decl_names, decls); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_parse_smtlib2_file_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_parse_smtlib2_file(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3_Z3_parse_smtlib_string( + value _v_c, + value _v_str, + value _v_sort_names, + value _v_sorts, + value _v_decl_names, + value _v_decls) +{ + Z3_context c; /*in*/ + Z3_string str; /*in*/ + unsigned int num_sorts; /*in*/ + Z3_symbol const *sort_names; /*in*/ + Z3_sort const *sorts; /*in*/ + unsigned int num_decls; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_func_decl const *decls; /*in*/ + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + mlsize_t _c11; + value _v12; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_str, &str, _ctx); + _c1 = Wosize_val(_v_sort_names); + sort_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_sort_names, _c2); + camlidl_ml2c_z3_Z3_symbol(_v3, &sort_names[_c2], _ctx); + } + num_sorts = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_sorts = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + _c10 = Wosize_val(_v_decls); + decls = camlidl_malloc(_c10 * sizeof(Z3_func_decl const ), _ctx); + for (_c11 = 0; _c11 < _c10; _c11++) { + _v12 = Field(_v_decls, _c11); + camlidl_ml2c_z3_Z3_func_decl(_v12, &decls[_c11], _ctx); + } + num_decls = _c10; + Z3_parse_smtlib_string(c, str, num_sorts, sort_names, sorts, num_decls, decl_names, decls); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_parse_smtlib_string_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_parse_smtlib_string(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3_Z3_parse_smtlib_file( + value _v_c, + value _v_file_name, + value _v_sort_names, + value _v_sorts, + value _v_decl_names, + value _v_decls) +{ + Z3_context c; /*in*/ + Z3_string file_name; /*in*/ + unsigned int num_sorts; /*in*/ + Z3_symbol const *sort_names; /*in*/ + Z3_sort const *sorts; /*in*/ + unsigned int num_decls; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_func_decl const *decls; /*in*/ + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + mlsize_t _c11; + value _v12; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_file_name, &file_name, _ctx); + _c1 = Wosize_val(_v_sort_names); + sort_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_sort_names, _c2); + camlidl_ml2c_z3_Z3_symbol(_v3, &sort_names[_c2], _ctx); + } + num_sorts = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_sorts = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + _c10 = Wosize_val(_v_decls); + decls = camlidl_malloc(_c10 * sizeof(Z3_func_decl const ), _ctx); + for (_c11 = 0; _c11 < _c10; _c11++) { + _v12 = Field(_v_decls, _c11); + camlidl_ml2c_z3_Z3_func_decl(_v12, &decls[_c11], _ctx); + } + num_decls = _c10; + Z3_parse_smtlib_file(c, file_name, num_sorts, sort_names, sorts, num_decls, decl_names, decls); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_parse_smtlib_file_bytecode(value * argv, int argn) +{ + return camlidl_z3_Z3_parse_smtlib_file(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3_Z3_get_smtlib_num_formulas( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_smtlib_num_formulas(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_smtlib_formula( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_get_smtlib_formula(c, i); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_smtlib_num_assumptions( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_smtlib_num_assumptions(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_smtlib_assumption( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_get_smtlib_assumption(c, i); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_smtlib_num_decls( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_smtlib_num_decls(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_smtlib_decl( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_get_smtlib_decl(c, i); + _vres = camlidl_c2ml_z3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_smtlib_num_sorts( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_smtlib_num_sorts(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_smtlib_sort( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_get_smtlib_sort(c, i); + _vres = camlidl_c2ml_z3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_smtlib_error( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_smtlib_error(c); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_parse_z3_string( + value _v_c, + value _v_str) +{ + Z3_context c; /*in*/ + Z3_string str; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_str, &str, _ctx); + _res = Z3_parse_z3_string(c, str); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_parse_z3_file( + value _v_c, + value _v_file_name) +{ + Z3_context c; /*in*/ + Z3_string file_name; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_file_name, &file_name, _ctx); + _res = Z3_parse_z3_file(c, file_name); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_set_error( + value _v_c, + value _v_e) +{ + Z3_context c; /*in*/ + Z3_error_code e; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_error_code(_v_e, &e, _ctx); + Z3_set_error(c, e); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_get_error_msg_ex( + value _v_c, + value _v_err) +{ + Z3_context c; /*in*/ + Z3_error_code err; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_error_code(_v_err, &err, _ctx); + _res = Z3_get_error_msg_ex(c, err); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_version(value _unit) +{ + unsigned int *major; /*out*/ + unsigned int *minor; /*out*/ + unsigned int *build_number; /*out*/ + unsigned int *revision_number; /*out*/ + unsigned int _c1; + unsigned int _c2; + unsigned int _c3; + unsigned int _c4; + value _vresult; + value _vres[4] = { 0, 0, 0, 0, }; + + major = &_c1; + minor = &_c2; + build_number = &_c3; + revision_number = &_c4; + Z3_get_version(major, minor, build_number, revision_number); + Begin_roots_block(_vres, 4) + _vres[0] = Val_int(*major); + _vres[1] = Val_int(*minor); + _vres[2] = Val_int(*build_number); + _vres[3] = Val_int(*revision_number); + _vresult = camlidl_alloc_small(4, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + Field(_vresult, 3) = _vres[3]; + End_roots() + return _vresult; +} + +value camlidl_z3_Z3_mk_fixedpoint( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_fixedpoint _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_fixedpoint(c); + _vres = camlidl_c2ml_z3_Z3_fixedpoint(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_add_rule( + value _v_c, + value _v_d, + value _v_rule, + value _v_name) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_ast rule; /*in*/ + Z3_symbol name; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_rule, &rule, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_name, &name, _ctx); + Z3_fixedpoint_add_rule(c, d, rule, name); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_fixedpoint_add_fact( + value _v_c, + value _v_d, + value _v_r, + value _v_args) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_func_decl r; /*in*/ + unsigned int num_args; /*in*/ + unsigned int *args; /*in*/ + mlsize_t _c1; + mlsize_t _c2; + value _v3; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_r, &r, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(unsigned int ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + args[_c2] = Int_val(_v3); + } + num_args = _c1; + Z3_fixedpoint_add_fact(c, d, r, num_args, args); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_fixedpoint_assert( + value _v_c, + value _v_d, + value _v_axiom) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_ast axiom; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_axiom, &axiom, _ctx); + Z3_fixedpoint_assert(c, d, axiom); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_fixedpoint_query( + value _v_c, + value _v_d, + value _v_query) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_ast query; /*in*/ + Z3_lbool _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_query, &query, _ctx); + _res = Z3_fixedpoint_query(c, d, query); + _vres = camlidl_c2ml_z3_Z3_lbool(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_query_relations( + value _v_c, + value _v_d, + value _v_relations) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + unsigned int num_relations; /*in*/ + Z3_func_decl const *relations; /*in*/ + Z3_lbool _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + _c1 = Wosize_val(_v_relations); + relations = camlidl_malloc(_c1 * sizeof(Z3_func_decl const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_relations, _c2); + camlidl_ml2c_z3_Z3_func_decl(_v3, &relations[_c2], _ctx); + } + num_relations = _c1; + _res = Z3_fixedpoint_query_relations(c, d, num_relations, relations); + _vres = camlidl_c2ml_z3_Z3_lbool(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_get_answer( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + _res = Z3_fixedpoint_get_answer(c, d); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_get_reason_unknown( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + _res = Z3_fixedpoint_get_reason_unknown(c, d); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_update_rule( + value _v_c, + value _v_d, + value _v_a, + value _v_name) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_ast a; /*in*/ + Z3_symbol name; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_name, &name, _ctx); + Z3_fixedpoint_update_rule(c, d, a, name); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_fixedpoint_get_num_levels( + value _v_c, + value _v_d, + value _v_pred) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_func_decl pred; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_pred, &pred, _ctx); + _res = Z3_fixedpoint_get_num_levels(c, d, pred); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_get_cover_delta( + value _v_c, + value _v_d, + value _v_level, + value _v_pred) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + int level; /*in*/ + Z3_func_decl pred; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + level = Int_val(_v_level); + camlidl_ml2c_z3_Z3_func_decl(_v_pred, &pred, _ctx); + _res = Z3_fixedpoint_get_cover_delta(c, d, level, pred); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_add_cover( + value _v_c, + value _v_d, + value _v_level, + value _v_pred, + value _v_property) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + int level; /*in*/ + Z3_func_decl pred; /*in*/ + Z3_ast property; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + level = Int_val(_v_level); + camlidl_ml2c_z3_Z3_func_decl(_v_pred, &pred, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_property, &property, _ctx); + Z3_fixedpoint_add_cover(c, d, level, pred, property); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_fixedpoint_get_statistics( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_stats _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + _res = Z3_fixedpoint_get_statistics(c, d); + _vres = camlidl_c2ml_z3_Z3_stats(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_register_relation( + value _v_c, + value _v_d, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_func_decl f; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_f, &f, _ctx); + Z3_fixedpoint_register_relation(c, d, f); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_fixedpoint_set_predicate_representation( + value _v_c, + value _v_d, + value _v_f, + value _v_relation_kinds) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + Z3_func_decl f; /*in*/ + unsigned int num_relations; /*in*/ + Z3_symbol const *relation_kinds; /*in*/ + mlsize_t _c1; + mlsize_t _c2; + value _v3; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + camlidl_ml2c_z3_Z3_func_decl(_v_f, &f, _ctx); + _c1 = Wosize_val(_v_relation_kinds); + relation_kinds = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_relation_kinds, _c2); + camlidl_ml2c_z3_Z3_symbol(_v3, &relation_kinds[_c2], _ctx); + } + num_relations = _c1; + Z3_fixedpoint_set_predicate_representation(c, d, f, num_relations, relation_kinds); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_fixedpoint_simplify_rules( + value _v_c, + value _v_f, + value _v_rules, + value _v_outputs) +{ + Z3_context c; /*in*/ + Z3_fixedpoint f; /*in*/ + unsigned int num_rules; /*in*/ + Z3_ast *rules; /*in*/ + unsigned int num_outputs; /*in*/ + Z3_func_decl *outputs; /*in*/ + Z3_ast_vector _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_f, &f, _ctx); + _c1 = Wosize_val(_v_rules); + rules = camlidl_malloc(_c1 * sizeof(Z3_ast ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_rules, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &rules[_c2], _ctx); + } + num_rules = _c1; + _c4 = Wosize_val(_v_outputs); + outputs = camlidl_malloc(_c4 * sizeof(Z3_func_decl ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_outputs, _c5); + camlidl_ml2c_z3_Z3_func_decl(_v6, &outputs[_c5], _ctx); + } + num_outputs = _c4; + _res = Z3_fixedpoint_simplify_rules(c, f, num_rules, rules, num_outputs, outputs); + _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_set_params( + value _v_c, + value _v_f, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_fixedpoint f; /*in*/ + Z3_params p; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_f, &f, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + Z3_fixedpoint_set_params(c, f, p); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_fixedpoint_get_help( + value _v_c, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_fixedpoint f; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_f, &f, _ctx); + _res = Z3_fixedpoint_get_help(c, f); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_get_param_descrs( + value _v_c, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_fixedpoint f; /*in*/ + Z3_param_descrs _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_f, &f, _ctx); + _res = Z3_fixedpoint_get_param_descrs(c, f); + _vres = camlidl_c2ml_z3_Z3_param_descrs(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_to_string( + value _v_c, + value _v_f, + value _v_queries) +{ + Z3_context c; /*in*/ + Z3_fixedpoint f; /*in*/ + unsigned int num_queries; /*in*/ + Z3_ast *queries; /*in*/ + Z3_string _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_f, &f, _ctx); + _c1 = Wosize_val(_v_queries); + queries = camlidl_malloc(_c1 * sizeof(Z3_ast ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_queries, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &queries[_c2], _ctx); + } + num_queries = _c1; + _res = Z3_fixedpoint_to_string(c, f, num_queries, queries); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_push( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + Z3_fixedpoint_push(c, d); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_fixedpoint_pop( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_fixedpoint d; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_d, &d, _ctx); + Z3_fixedpoint_pop(c, d); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_mk_ast_vector( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_ast_vector _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_ast_vector(c); + _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_ast_vector_size( + value _v_c, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast_vector v; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_vector(_v_v, &v, _ctx); + _res = Z3_ast_vector_size(c, v); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_ast_vector_get( + value _v_c, + value _v_v, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast_vector v; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_vector(_v_v, &v, _ctx); + i = Int_val(_v_i); + _res = Z3_ast_vector_get(c, v, i); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_ast_vector_set( + value _v_c, + value _v_v, + value _v_i, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast_vector v; /*in*/ + unsigned int i; /*in*/ + Z3_ast a; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_vector(_v_v, &v, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + Z3_ast_vector_set(c, v, i, a); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_ast_vector_resize( + value _v_c, + value _v_v, + value _v_n) +{ + Z3_context c; /*in*/ + Z3_ast_vector v; /*in*/ + unsigned int n; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_vector(_v_v, &v, _ctx); + n = Int_val(_v_n); + Z3_ast_vector_resize(c, v, n); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_ast_vector_push( + value _v_c, + value _v_v, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast_vector v; /*in*/ + Z3_ast a; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_vector(_v_v, &v, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + Z3_ast_vector_push(c, v, a); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_ast_vector_translate( + value _v_s, + value _v_v, + value _v_t) +{ + Z3_context s; /*in*/ + Z3_ast_vector v; /*in*/ + Z3_context t; /*in*/ + Z3_ast_vector _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_s, &s, _ctx); + camlidl_ml2c_z3_Z3_ast_vector(_v_v, &v, _ctx); + camlidl_ml2c_z3_Z3_context(_v_t, &t, _ctx); + _res = Z3_ast_vector_translate(s, v, t); + _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(s); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_ast_vector_to_string( + value _v_c, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast_vector v; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_vector(_v_v, &v, _ctx); + _res = Z3_ast_vector_to_string(c, v); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_ast_map( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_ast_map _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_ast_map(c); + _vres = camlidl_c2ml_z3_Z3_ast_map(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_ast_map_contains( + value _v_c, + value _v_m, + value _v_k) +{ + Z3_context c; /*in*/ + Z3_ast_map m; /*in*/ + Z3_ast k; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_map(_v_m, &m, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_k, &k, _ctx); + _res = Z3_ast_map_contains(c, m, k); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_ast_map_find( + value _v_c, + value _v_m, + value _v_k) +{ + Z3_context c; /*in*/ + Z3_ast_map m; /*in*/ + Z3_ast k; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_map(_v_m, &m, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_k, &k, _ctx); + _res = Z3_ast_map_find(c, m, k); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_ast_map_insert( + value _v_c, + value _v_m, + value _v_k, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast_map m; /*in*/ + Z3_ast k; /*in*/ + Z3_ast v; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_map(_v_m, &m, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_k, &k, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_v, &v, _ctx); + Z3_ast_map_insert(c, m, k, v); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_ast_map_erase( + value _v_c, + value _v_m, + value _v_k) +{ + Z3_context c; /*in*/ + Z3_ast_map m; /*in*/ + Z3_ast k; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_map(_v_m, &m, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_k, &k, _ctx); + Z3_ast_map_erase(c, m, k); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_ast_map_reset( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_ast_map m; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_map(_v_m, &m, _ctx); + Z3_ast_map_reset(c, m); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_ast_map_size( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_ast_map m; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_map(_v_m, &m, _ctx); + _res = Z3_ast_map_size(c, m); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_ast_map_keys( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_ast_map m; /*in*/ + Z3_ast_vector _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_map(_v_m, &m, _ctx); + _res = Z3_ast_map_keys(c, m); + _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_ast_map_to_string( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_ast_map m; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_ast_map(_v_m, &m, _ctx); + _res = Z3_ast_map_to_string(c, m); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_goal( + value _v_c, + value _v_models, + value _v_unsat_cores, + value _v_proofs) +{ + Z3_context c; /*in*/ + int models; /*in*/ + int unsat_cores; /*in*/ + int proofs; /*in*/ + Z3_goal _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + models = Int_val(_v_models); + unsat_cores = Int_val(_v_unsat_cores); + proofs = Int_val(_v_proofs); + _res = Z3_mk_goal(c, models, unsat_cores, proofs); + _vres = camlidl_c2ml_z3_Z3_goal(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_goal_precision( + value _v_c, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + Z3_goal_prec _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + _res = Z3_goal_precision(c, g); + _vres = camlidl_c2ml_z3_Z3_goal_prec(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_goal_assert( + value _v_c, + value _v_g, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + Z3_ast a; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + Z3_goal_assert(c, g, a); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_goal_inconsistent( + value _v_c, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + _res = Z3_goal_inconsistent(c, g); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_goal_depth( + value _v_c, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + _res = Z3_goal_depth(c, g); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_goal_reset( + value _v_c, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + Z3_goal_reset(c, g); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_goal_size( + value _v_c, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + _res = Z3_goal_size(c, g); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_goal_formula( + value _v_c, + value _v_g, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + unsigned int idx; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + idx = Int_val(_v_idx); + _res = Z3_goal_formula(c, g, idx); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_goal_num_exprs( + value _v_c, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + _res = Z3_goal_num_exprs(c, g); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_goal_is_decided_sat( + value _v_c, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + _res = Z3_goal_is_decided_sat(c, g); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_goal_is_decided_unsat( + value _v_c, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + _res = Z3_goal_is_decided_unsat(c, g); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_goal_translate( + value _v_source, + value _v_g, + value _v_target) +{ + Z3_context source; /*in*/ + Z3_goal g; /*in*/ + Z3_context target; /*in*/ + Z3_goal _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_source, &source, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + camlidl_ml2c_z3_Z3_context(_v_target, &target, _ctx); + _res = Z3_goal_translate(source, g, target); + _vres = camlidl_c2ml_z3_Z3_goal(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(source); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_goal_to_string( + value _v_c, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_goal g; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + _res = Z3_goal_to_string(c, g); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_tactic( + value _v_c, + value _v_name) +{ + Z3_context c; /*in*/ + Z3_string name; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_name, &name, _ctx); + _res = Z3_mk_tactic(c, name); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_probe( + value _v_c, + value _v_name) +{ + Z3_context c; /*in*/ + Z3_string name; /*in*/ + Z3_probe _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_name, &name, _ctx); + _res = Z3_mk_probe(c, name); + _vres = camlidl_c2ml_z3_Z3_probe(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_and_then( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_tactic t1; /*in*/ + Z3_tactic t2; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t2, &t2, _ctx); + _res = Z3_tactic_and_then(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_or_else( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_tactic t1; /*in*/ + Z3_tactic t2; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t2, &t2, _ctx); + _res = Z3_tactic_or_else(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_par_or( + value _v_c, + value _v_ts) +{ + Z3_context c; /*in*/ + unsigned int num; /*in*/ + Z3_tactic const *ts; /*in*/ + Z3_tactic _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_ts); + ts = camlidl_malloc(_c1 * sizeof(Z3_tactic const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_ts, _c2); + camlidl_ml2c_z3_Z3_tactic(_v3, &ts[_c2], _ctx); + } + num = _c1; + _res = Z3_tactic_par_or(c, num, ts); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_par_and_then( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_tactic t1; /*in*/ + Z3_tactic t2; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t2, &t2, _ctx); + _res = Z3_tactic_par_and_then(c, t1, t2); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_try_for( + value _v_c, + value _v_t, + value _v_ms) +{ + Z3_context c; /*in*/ + Z3_tactic t; /*in*/ + unsigned int ms; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t, &t, _ctx); + ms = Int_val(_v_ms); + _res = Z3_tactic_try_for(c, t, ms); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_when( + value _v_c, + value _v_p, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_probe p; /*in*/ + Z3_tactic t; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p, &p, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t, &t, _ctx); + _res = Z3_tactic_when(c, p, t); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_cond( + value _v_c, + value _v_p, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_probe p; /*in*/ + Z3_tactic t1; /*in*/ + Z3_tactic t2; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p, &p, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t1, &t1, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t2, &t2, _ctx); + _res = Z3_tactic_cond(c, p, t1, t2); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_repeat( + value _v_c, + value _v_t, + value _v_max) +{ + Z3_context c; /*in*/ + Z3_tactic t; /*in*/ + unsigned int max; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t, &t, _ctx); + max = Int_val(_v_max); + _res = Z3_tactic_repeat(c, t, max); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_skip( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_tactic_skip(c); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_fail( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_tactic_fail(c); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_fail_if( + value _v_c, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_probe p; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p, &p, _ctx); + _res = Z3_tactic_fail_if(c, p); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_fail_if_not_decided( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_tactic_fail_if_not_decided(c); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_using_params( + value _v_c, + value _v_t, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_tactic t; /*in*/ + Z3_params p; /*in*/ + Z3_tactic _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t, &t, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + _res = Z3_tactic_using_params(c, t, p); + _vres = camlidl_c2ml_z3_Z3_tactic(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_const( + value _v_x, + value _v_val) +{ + Z3_context x; /*in*/ + double val; /*in*/ + Z3_probe _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_x, &x, _ctx); + val = Double_val(_v_val); + _res = Z3_probe_const(x, val); + _vres = camlidl_c2ml_z3_Z3_probe(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(x); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_lt( + value _v_x, + value _v_p1, + value _v_p2) +{ + Z3_context x; /*in*/ + Z3_probe p1; /*in*/ + Z3_probe p2; /*in*/ + Z3_probe _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_x, &x, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p1, &p1, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p2, &p2, _ctx); + _res = Z3_probe_lt(x, p1, p2); + _vres = camlidl_c2ml_z3_Z3_probe(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(x); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_gt( + value _v_x, + value _v_p1, + value _v_p2) +{ + Z3_context x; /*in*/ + Z3_probe p1; /*in*/ + Z3_probe p2; /*in*/ + Z3_probe _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_x, &x, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p1, &p1, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p2, &p2, _ctx); + _res = Z3_probe_gt(x, p1, p2); + _vres = camlidl_c2ml_z3_Z3_probe(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(x); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_le( + value _v_x, + value _v_p1, + value _v_p2) +{ + Z3_context x; /*in*/ + Z3_probe p1; /*in*/ + Z3_probe p2; /*in*/ + Z3_probe _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_x, &x, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p1, &p1, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p2, &p2, _ctx); + _res = Z3_probe_le(x, p1, p2); + _vres = camlidl_c2ml_z3_Z3_probe(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(x); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_ge( + value _v_x, + value _v_p1, + value _v_p2) +{ + Z3_context x; /*in*/ + Z3_probe p1; /*in*/ + Z3_probe p2; /*in*/ + Z3_probe _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_x, &x, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p1, &p1, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p2, &p2, _ctx); + _res = Z3_probe_ge(x, p1, p2); + _vres = camlidl_c2ml_z3_Z3_probe(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(x); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_eq( + value _v_x, + value _v_p1, + value _v_p2) +{ + Z3_context x; /*in*/ + Z3_probe p1; /*in*/ + Z3_probe p2; /*in*/ + Z3_probe _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_x, &x, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p1, &p1, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p2, &p2, _ctx); + _res = Z3_probe_eq(x, p1, p2); + _vres = camlidl_c2ml_z3_Z3_probe(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(x); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_and( + value _v_x, + value _v_p1, + value _v_p2) +{ + Z3_context x; /*in*/ + Z3_probe p1; /*in*/ + Z3_probe p2; /*in*/ + Z3_probe _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_x, &x, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p1, &p1, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p2, &p2, _ctx); + _res = Z3_probe_and(x, p1, p2); + _vres = camlidl_c2ml_z3_Z3_probe(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(x); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_or( + value _v_x, + value _v_p1, + value _v_p2) +{ + Z3_context x; /*in*/ + Z3_probe p1; /*in*/ + Z3_probe p2; /*in*/ + Z3_probe _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_x, &x, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p1, &p1, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p2, &p2, _ctx); + _res = Z3_probe_or(x, p1, p2); + _vres = camlidl_c2ml_z3_Z3_probe(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(x); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_not( + value _v_x, + value _v_p) +{ + Z3_context x; /*in*/ + Z3_probe p; /*in*/ + Z3_probe _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_x, &x, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p, &p, _ctx); + _res = Z3_probe_not(x, p); + _vres = camlidl_c2ml_z3_Z3_probe(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(x); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_num_tactics( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_num_tactics(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_tactic_name( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_get_tactic_name(c, i); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_num_probes( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_num_probes(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_get_probe_name( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_get_probe_name(c, i); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_get_help( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_tactic t; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t, &t, _ctx); + _res = Z3_tactic_get_help(c, t); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_get_param_descrs( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_tactic t; /*in*/ + Z3_param_descrs _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t, &t, _ctx); + _res = Z3_tactic_get_param_descrs(c, t); + _vres = camlidl_c2ml_z3_Z3_param_descrs(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_get_descr( + value _v_c, + value _v_name) +{ + Z3_context c; /*in*/ + Z3_string name; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_name, &name, _ctx); + _res = Z3_tactic_get_descr(c, name); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_get_descr( + value _v_c, + value _v_name) +{ + Z3_context c; /*in*/ + Z3_string name; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_string(_v_name, &name, _ctx); + _res = Z3_probe_get_descr(c, name); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_probe_apply( + value _v_c, + value _v_p, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_probe p; /*in*/ + Z3_goal g; /*in*/ + double _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_probe(_v_p, &p, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + _res = Z3_probe_apply(c, p, g); + _vres = copy_double(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_apply( + value _v_c, + value _v_t, + value _v_g) +{ + Z3_context c; /*in*/ + Z3_tactic t; /*in*/ + Z3_goal g; /*in*/ + Z3_apply_result _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t, &t, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + _res = Z3_tactic_apply(c, t, g); + _vres = camlidl_c2ml_z3_Z3_apply_result(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_tactic_apply_ex( + value _v_c, + value _v_t, + value _v_g, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_tactic t; /*in*/ + Z3_goal g; /*in*/ + Z3_params p; /*in*/ + Z3_apply_result _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t, &t, _ctx); + camlidl_ml2c_z3_Z3_goal(_v_g, &g, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + _res = Z3_tactic_apply_ex(c, t, g, p); + _vres = camlidl_c2ml_z3_Z3_apply_result(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_apply_result_to_string( + value _v_c, + value _v_r) +{ + Z3_context c; /*in*/ + Z3_apply_result r; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_apply_result(_v_r, &r, _ctx); + _res = Z3_apply_result_to_string(c, r); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_apply_result_get_num_subgoals( + value _v_c, + value _v_r) +{ + Z3_context c; /*in*/ + Z3_apply_result r; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_apply_result(_v_r, &r, _ctx); + _res = Z3_apply_result_get_num_subgoals(c, r); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_apply_result_get_subgoal( + value _v_c, + value _v_r, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_apply_result r; /*in*/ + unsigned int i; /*in*/ + Z3_goal _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_apply_result(_v_r, &r, _ctx); + i = Int_val(_v_i); + _res = Z3_apply_result_get_subgoal(c, r, i); + _vres = camlidl_c2ml_z3_Z3_goal(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_apply_result_convert_model( + value _v_c, + value _v_r, + value _v_i, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_apply_result r; /*in*/ + unsigned int i; /*in*/ + Z3_model m; /*in*/ + Z3_model _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_apply_result(_v_r, &r, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3_Z3_model(_v_m, &m, _ctx); + _res = Z3_apply_result_convert_model(c, r, i, m); + _vres = camlidl_c2ml_z3_Z3_model(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_solver( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_solver _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_solver(c); + _vres = camlidl_c2ml_z3_Z3_solver(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_simple_solver( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_solver _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_simple_solver(c); + _vres = camlidl_c2ml_z3_Z3_solver(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_solver_for_logic( + value _v_c, + value _v_logic) +{ + Z3_context c; /*in*/ + Z3_symbol logic; /*in*/ + Z3_solver _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_symbol(_v_logic, &logic, _ctx); + _res = Z3_mk_solver_for_logic(c, logic); + _vres = camlidl_c2ml_z3_Z3_solver(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_mk_solver_from_tactic( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_tactic t; /*in*/ + Z3_solver _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_tactic(_v_t, &t, _ctx); + _res = Z3_mk_solver_from_tactic(c, t); + _vres = camlidl_c2ml_z3_Z3_solver(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_get_help( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_get_help(c, s); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_get_param_descrs( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_param_descrs _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_get_param_descrs(c, s); + _vres = camlidl_c2ml_z3_Z3_param_descrs(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_set_params( + value _v_c, + value _v_s, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_params p; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + camlidl_ml2c_z3_Z3_params(_v_p, &p, _ctx); + Z3_solver_set_params(c, s, p); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_solver_push( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + Z3_solver_push(c, s); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_solver_pop( + value _v_c, + value _v_s, + value _v_n) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + unsigned int n; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + n = Int_val(_v_n); + Z3_solver_pop(c, s, n); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_solver_reset( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + Z3_solver_reset(c, s); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_solver_get_num_scopes( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_get_num_scopes(c, s); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_assert( + value _v_c, + value _v_s, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_ast a; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + Z3_solver_assert(c, s, a); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + +value camlidl_z3_Z3_solver_get_assertions( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_ast_vector _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_get_assertions(c, s); + _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_check( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_lbool _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_check(c, s); + _vres = camlidl_c2ml_z3_Z3_lbool(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_check_assumptions( + value _v_c, + value _v_s, + value _v_assumptions) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + unsigned int num_assumptions; /*in*/ + Z3_ast const *assumptions; /*in*/ + Z3_lbool _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _c1 = Wosize_val(_v_assumptions); + assumptions = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_assumptions, _c2); + camlidl_ml2c_z3_Z3_ast(_v3, &assumptions[_c2], _ctx); + } + num_assumptions = _c1; + _res = Z3_solver_check_assumptions(c, s, num_assumptions, assumptions); + _vres = camlidl_c2ml_z3_Z3_lbool(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_get_model( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_model _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_get_model(c, s); + _vres = camlidl_c2ml_z3_Z3_model(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_get_proof( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_get_proof(c, s); + _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_get_unsat_core( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_ast_vector _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_get_unsat_core(c, s); + _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_get_reason_unknown( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_get_reason_unknown(c, s); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_get_statistics( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_stats _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_get_statistics(c, s); + _vres = camlidl_c2ml_z3_Z3_stats(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_solver_to_string( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + _res = Z3_solver_to_string(c, s); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_stats_to_string( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_stats s; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_stats(_v_s, &s, _ctx); + _res = Z3_stats_to_string(c, s); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_stats_size( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_stats s; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_stats(_v_s, &s, _ctx); + _res = Z3_stats_size(c, s); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_stats_get_key( + value _v_c, + value _v_s, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_stats s; /*in*/ + unsigned int idx; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_stats(_v_s, &s, _ctx); + idx = Int_val(_v_idx); + _res = Z3_stats_get_key(c, s, idx); + _vres = camlidl_c2ml_z3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_stats_is_uint( + value _v_c, + value _v_s, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_stats s; /*in*/ + unsigned int idx; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_stats(_v_s, &s, _ctx); + idx = Int_val(_v_idx); + _res = Z3_stats_is_uint(c, s, idx); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_stats_is_double( + value _v_c, + value _v_s, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_stats s; /*in*/ + unsigned int idx; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_stats(_v_s, &s, _ctx); + idx = Int_val(_v_idx); + _res = Z3_stats_is_double(c, s, idx); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_stats_get_uint_value( + value _v_c, + value _v_s, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_stats s; /*in*/ + unsigned int idx; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_stats(_v_s, &s, _ctx); + idx = Int_val(_v_idx); + _res = Z3_stats_get_uint_value(c, s, idx); + _vres = Val_int(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_stats_get_double_value( + value _v_c, + value _v_s, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_stats s; /*in*/ + unsigned int idx; /*in*/ + double _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_stats(_v_s, &s, _ctx); + idx = Int_val(_v_idx); + _res = Z3_stats_get_double_value(c, s, idx); + _vres = copy_double(_res); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +void caml_z3_error_handler(Z3_context c, Z3_error_code e) { static char buffer[128]; char * msg = Z3_get_error_msg_ex(c, e); if (strlen(msg) > 100) { failwith("Z3: error message is too big to fit in buffer"); } else { sprintf(buffer, "Z3: %s", msg); failwith(buffer); } } +void camlidl_ml2c_z3V3_Z3_symbol(value _v1, Z3_symbol * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_symbol *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_symbol(Z3_symbol * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_symbol) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_symbol *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_literals(value _v1, Z3_literals * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_literals *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_literals(Z3_literals * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_literals) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_literals *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_theory(value _v1, Z3_theory * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_theory *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_theory(Z3_theory * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_theory) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_theory *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_config(value _v1, Z3_config * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_config *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_config(Z3_config * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_config) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_config *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_context(value _v1, Z3_context * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_context *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_context(Z3_context * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_context) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_context *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_sort(value _v1, Z3_sort * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_sort *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_sort(Z3_sort * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_sort) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_sort *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_func_decl(value _v1, Z3_func_decl * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_func_decl *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_func_decl(Z3_func_decl * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_func_decl) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_func_decl *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_ast(value _v1, Z3_ast * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_ast *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_ast(Z3_ast * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_ast) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_ast *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_app(value _v1, Z3_app * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_app *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_app(Z3_app * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_app) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_app *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_pattern(value _v1, Z3_pattern * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_pattern *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_pattern(Z3_pattern * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_pattern) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_pattern *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_model(value _v1, Z3_model * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_model *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_model(Z3_model * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_model) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_model *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_constructor(value _v1, Z3_constructor * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_constructor *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_constructor(Z3_constructor * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_constructor) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_constructor *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_constructor_list(value _v1, Z3_constructor_list * _c2, camlidl_ctx _ctx) +{ + *_c2 = *((Z3_constructor_list *) Bp_val(_v1)); +} + +value camlidl_c2ml_z3V3_Z3_constructor_list(Z3_constructor_list * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_alloc((sizeof(Z3_constructor_list) + sizeof(value) - 1) / sizeof(value), Abstract_tag); + *((Z3_constructor_list *) Bp_val(_v1)) = *_c2; + return _v1; +} + +void camlidl_ml2c_z3V3_Z3_string(value _v1, Z3_string * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_malloc_string(_v1, _ctx); +} + +value camlidl_c2ml_z3V3_Z3_string(Z3_string * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = copy_string((*_c2)); + return _v1; +} + +int camlidl_transl_table_z3V3_enum_1[3] = { + Z3_L_FALSE, + Z3_L_UNDEF, + Z3_L_TRUE, +}; + +void camlidl_ml2c_z3V3_Z3_lbool(value _v1, Z3_lbool * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3V3_enum_1[Int_val(_v1)]; +} + +value camlidl_c2ml_z3V3_Z3_lbool(Z3_lbool * _c2, camlidl_ctx _ctx) +{ +value _v1; + switch((*_c2)) { + case Z3_L_FALSE: _v1 = Val_int(0); break; + case Z3_L_UNDEF: _v1 = Val_int(1); break; + case Z3_L_TRUE: _v1 = Val_int(2); break; + default: invalid_argument("typedef Z3_lbool: bad enum value"); + } + return _v1; +} + +int camlidl_transl_table_z3V3_enum_2[2] = { + Z3_INT_SYMBOL, + Z3_STRING_SYMBOL, +}; + +void camlidl_ml2c_z3V3_Z3_symbol_kind(value _v1, Z3_symbol_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3V3_enum_2[Int_val(_v1)]; +} + +value camlidl_c2ml_z3V3_Z3_symbol_kind(Z3_symbol_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + switch((*_c2)) { + case Z3_INT_SYMBOL: _v1 = Val_int(0); break; + case Z3_STRING_SYMBOL: _v1 = Val_int(1); break; + default: invalid_argument("typedef Z3_symbol_kind: bad enum value"); + } + return _v1; +} + +int camlidl_transl_table_z3V3_enum_3[7] = { + Z3_PARAMETER_INT, + Z3_PARAMETER_DOUBLE, + Z3_PARAMETER_RATIONAL, + Z3_PARAMETER_SYMBOL, + Z3_PARAMETER_SORT, + Z3_PARAMETER_AST, + Z3_PARAMETER_FUNC_DECL, +}; + +void camlidl_ml2c_z3V3_Z3_parameter_kind(value _v1, Z3_parameter_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3V3_enum_3[Int_val(_v1)]; +} + +value camlidl_c2ml_z3V3_Z3_parameter_kind(Z3_parameter_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3V3_enum_3, 7, "typedef Z3_parameter_kind: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3V3_enum_4[10] = { + Z3_UNINTERPRETED_SORT, + Z3_BOOL_SORT, + Z3_INT_SORT, + Z3_REAL_SORT, + Z3_BV_SORT, + Z3_ARRAY_SORT, + Z3_DATATYPE_SORT, + Z3_RELATION_SORT, + Z3_FINITE_DOMAIN_SORT, + Z3_UNKNOWN_SORT, +}; + +void camlidl_ml2c_z3V3_Z3_sort_kind(value _v1, Z3_sort_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3V3_enum_4[Int_val(_v1)]; +} + +value camlidl_c2ml_z3V3_Z3_sort_kind(Z3_sort_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3V3_enum_4, 10, "typedef Z3_sort_kind: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3V3_enum_5[7] = { + Z3_NUMERAL_AST, + Z3_APP_AST, + Z3_VAR_AST, + Z3_QUANTIFIER_AST, + Z3_SORT_AST, + Z3_FUNC_DECL_AST, + Z3_UNKNOWN_AST, +}; + +void camlidl_ml2c_z3V3_Z3_ast_kind(value _v1, Z3_ast_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3V3_enum_5[Int_val(_v1)]; +} + +value camlidl_c2ml_z3V3_Z3_ast_kind(Z3_ast_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3V3_enum_5, 7, "typedef Z3_ast_kind: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3V3_enum_6[151] = { + Z3_OP_TRUE, + Z3_OP_FALSE, + Z3_OP_EQ, + Z3_OP_DISTINCT, + Z3_OP_ITE, + Z3_OP_AND, + Z3_OP_OR, + Z3_OP_IFF, + Z3_OP_XOR, + Z3_OP_NOT, + Z3_OP_IMPLIES, + Z3_OP_OEQ, + Z3_OP_ANUM, + Z3_OP_AGNUM, + Z3_OP_LE, + Z3_OP_GE, + Z3_OP_LT, + Z3_OP_GT, + Z3_OP_ADD, + Z3_OP_SUB, + Z3_OP_UMINUS, + Z3_OP_MUL, + Z3_OP_DIV, + Z3_OP_IDIV, + Z3_OP_REM, + Z3_OP_MOD, + Z3_OP_TO_REAL, + Z3_OP_TO_INT, + Z3_OP_IS_INT, + Z3_OP_POWER, + Z3_OP_STORE, + Z3_OP_SELECT, + Z3_OP_CONST_ARRAY, + Z3_OP_ARRAY_MAP, + Z3_OP_ARRAY_DEFAULT, + Z3_OP_SET_UNION, + Z3_OP_SET_INTERSECT, + Z3_OP_SET_DIFFERENCE, + Z3_OP_SET_COMPLEMENT, + Z3_OP_SET_SUBSET, + Z3_OP_AS_ARRAY, + Z3_OP_BNUM, + Z3_OP_BIT1, + Z3_OP_BIT0, + Z3_OP_BNEG, + Z3_OP_BADD, + Z3_OP_BSUB, + Z3_OP_BMUL, + Z3_OP_BSDIV, + Z3_OP_BUDIV, + Z3_OP_BSREM, + Z3_OP_BUREM, + Z3_OP_BSMOD, + Z3_OP_BSDIV0, + Z3_OP_BUDIV0, + Z3_OP_BSREM0, + Z3_OP_BUREM0, + Z3_OP_BSMOD0, + Z3_OP_ULEQ, + Z3_OP_SLEQ, + Z3_OP_UGEQ, + Z3_OP_SGEQ, + Z3_OP_ULT, + Z3_OP_SLT, + Z3_OP_UGT, + Z3_OP_SGT, + Z3_OP_BAND, + Z3_OP_BOR, + Z3_OP_BNOT, + Z3_OP_BXOR, + Z3_OP_BNAND, + Z3_OP_BNOR, + Z3_OP_BXNOR, + Z3_OP_CONCAT, + Z3_OP_SIGN_EXT, + Z3_OP_ZERO_EXT, + Z3_OP_EXTRACT, + Z3_OP_REPEAT, + Z3_OP_BREDOR, + Z3_OP_BREDAND, + Z3_OP_BCOMP, + Z3_OP_BSHL, + Z3_OP_BLSHR, + Z3_OP_BASHR, + Z3_OP_ROTATE_LEFT, + Z3_OP_ROTATE_RIGHT, + Z3_OP_EXT_ROTATE_LEFT, + Z3_OP_EXT_ROTATE_RIGHT, + Z3_OP_INT2BV, + Z3_OP_BV2INT, + Z3_OP_CARRY, + Z3_OP_XOR3, + Z3_OP_PR_UNDEF, + Z3_OP_PR_TRUE, + Z3_OP_PR_ASSERTED, + Z3_OP_PR_GOAL, + Z3_OP_PR_MODUS_PONENS, + Z3_OP_PR_REFLEXIVITY, + Z3_OP_PR_SYMMETRY, + Z3_OP_PR_TRANSITIVITY, + Z3_OP_PR_TRANSITIVITY_STAR, + Z3_OP_PR_MONOTONICITY, + Z3_OP_PR_QUANT_INTRO, + Z3_OP_PR_DISTRIBUTIVITY, + Z3_OP_PR_AND_ELIM, + Z3_OP_PR_NOT_OR_ELIM, + Z3_OP_PR_REWRITE, + Z3_OP_PR_REWRITE_STAR, + Z3_OP_PR_PULL_QUANT, + Z3_OP_PR_PULL_QUANT_STAR, + Z3_OP_PR_PUSH_QUANT, + Z3_OP_PR_ELIM_UNUSED_VARS, + Z3_OP_PR_DER, + Z3_OP_PR_QUANT_INST, + Z3_OP_PR_HYPOTHESIS, + Z3_OP_PR_LEMMA, + Z3_OP_PR_UNIT_RESOLUTION, + Z3_OP_PR_IFF_TRUE, + Z3_OP_PR_IFF_FALSE, + Z3_OP_PR_COMMUTATIVITY, + Z3_OP_PR_DEF_AXIOM, + Z3_OP_PR_DEF_INTRO, + Z3_OP_PR_APPLY_DEF, + Z3_OP_PR_IFF_OEQ, + Z3_OP_PR_NNF_POS, + Z3_OP_PR_NNF_NEG, + Z3_OP_PR_NNF_STAR, + Z3_OP_PR_CNF_STAR, + Z3_OP_PR_SKOLEMIZE, + Z3_OP_PR_MODUS_PONENS_OEQ, + Z3_OP_PR_TH_LEMMA, + Z3_OP_RA_STORE, + Z3_OP_RA_EMPTY, + Z3_OP_RA_IS_EMPTY, + Z3_OP_RA_JOIN, + Z3_OP_RA_UNION, + Z3_OP_RA_WIDEN, + Z3_OP_RA_PROJECT, + Z3_OP_RA_FILTER, + Z3_OP_RA_NEGATION_FILTER, + Z3_OP_RA_RENAME, + Z3_OP_RA_COMPLEMENT, + Z3_OP_RA_SELECT, + Z3_OP_RA_CLONE, + Z3_OP_FD_LT, + Z3_OP_LABEL, + Z3_OP_LABEL_LIT, + Z3_OP_DT_CONSTRUCTOR, + Z3_OP_DT_RECOGNISER, + Z3_OP_DT_ACCESSOR, + Z3_OP_UNINTERPRETED, +}; + +void camlidl_ml2c_z3V3_Z3_decl_kind(value _v1, Z3_decl_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3V3_enum_6[Int_val(_v1)]; +} + +value camlidl_c2ml_z3V3_Z3_decl_kind(Z3_decl_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3V3_enum_6, 151, "typedef Z3_decl_kind: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3V3_enum_7[7] = { + Z3_PK_UINT, + Z3_PK_BOOL, + Z3_PK_DOUBLE, + Z3_PK_SYMBOL, + Z3_PK_STRING, + Z3_PK_OTHER, + Z3_PK_INVALID, +}; + +void camlidl_ml2c_z3V3_Z3_param_kind(value _v1, Z3_param_kind * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3V3_enum_7[Int_val(_v1)]; +} + +value camlidl_c2ml_z3V3_Z3_param_kind(Z3_param_kind * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3V3_enum_7, 7, "typedef Z3_param_kind: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3V3_enum_8[8] = { + Z3_NO_FAILURE, + Z3_UNKNOWN, + Z3_TIMEOUT, + Z3_MEMOUT_WATERMARK, + Z3_CANCELED, + Z3_NUM_CONFLICTS, + Z3_THEORY, + Z3_QUANTIFIERS, +}; + +void camlidl_ml2c_z3V3_Z3_search_failure(value _v1, Z3_search_failure * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3V3_enum_8[Int_val(_v1)]; +} + +value camlidl_c2ml_z3V3_Z3_search_failure(Z3_search_failure * _c2, camlidl_ctx _ctx) +{ +value _v1; + _v1 = camlidl_find_enum((*_c2), camlidl_transl_table_z3V3_enum_8, 8, "typedef Z3_search_failure: bad enum value"); + return _v1; +} + +int camlidl_transl_table_z3V3_enum_9[4] = { + Z3_PRINT_SMTLIB_FULL, + Z3_PRINT_LOW_LEVEL, + Z3_PRINT_SMTLIB_COMPLIANT, + Z3_PRINT_SMTLIB2_COMPLIANT, +}; + +void camlidl_ml2c_z3V3_Z3_ast_print_mode(value _v1, Z3_ast_print_mode * _c2, camlidl_ctx _ctx) +{ + (*_c2) = camlidl_transl_table_z3V3_enum_9[Int_val(_v1)]; +} + +value camlidl_c2ml_z3V3_Z3_ast_print_mode(Z3_ast_print_mode * _c2, camlidl_ctx _ctx) +{ +value _v1; + switch((*_c2)) { + case Z3_PRINT_SMTLIB_FULL: _v1 = Val_int(0); break; + case Z3_PRINT_LOW_LEVEL: _v1 = Val_int(1); break; + case Z3_PRINT_SMTLIB_COMPLIANT: _v1 = Val_int(2); break; + case Z3_PRINT_SMTLIB2_COMPLIANT: _v1 = Val_int(3); break; + default: invalid_argument("typedef Z3_ast_print_mode: bad enum value"); + } + return _v1; +} + +value camlidl_z3V3_Z3_mk_config(value _unit) +{ + Z3_config _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + _res = Z3_mk_config(); + _vres = camlidl_c2ml_z3V3_Z3_config(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_del_config( + value _v_c) +{ + Z3_config c; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_config(_v_c, &c, _ctx); + Z3_del_config(c); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_set_param_value( + value _v_c, + value _v_param_id, + value _v_param_value) +{ + Z3_config c; /*in*/ + Z3_string param_id; /*in*/ + Z3_string param_value; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_config(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_param_id, ¶m_id, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_param_value, ¶m_value, _ctx); + Z3_set_param_value(c, param_id, param_value); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_mk_context( + value _v_c) +{ + Z3_config c; /*in*/ + Z3_context _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_config(_v_c, &c, _ctx); + _res = Z3_mk_context(c); + _vres = camlidl_c2ml_z3V3_Z3_context(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +Z3_set_error_handler(_res, caml_z3_error_handler); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3V3_Z3_del_context( + value _v_c) +{ + Z3_context c; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + Z3_del_context(c); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_update_param_value( + value _v_c, + value _v_param_id, + value _v_param_value) +{ + Z3_context c; /*in*/ + Z3_string param_id; /*in*/ + Z3_string param_value; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_param_id, ¶m_id, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_param_value, ¶m_value, _ctx); + Z3_update_param_value(c, param_id, param_value); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_get_param_value( + value _v_c, + value _v_param_id) +{ + Z3_context c; /*in*/ + Z3_string param_id; /*in*/ + Z3_string *param_value; /*out*/ + Z3_string _c1; + value _v2; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_param_id, ¶m_id, _ctx); + param_value = &_c1; + Z3_get_param_value(c, param_id, param_value); + if (param_value == NULL) { + _vres = Val_int(0); + } else { + _v2 = camlidl_c2ml_z3V3_Z3_string(&*param_value, _ctx); + Begin_root(_v2) + _vres = camlidl_alloc_small(1, 0); + Field(_vres, 0) = _v2; + End_roots(); + } + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_int_symbol( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + int i; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_mk_int_symbol(c, i); + _vres = camlidl_c2ml_z3V3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_string_symbol( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_string s; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_s, &s, _ctx); + _res = Z3_mk_string_symbol(c, s); + _vres = camlidl_c2ml_z3V3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_uninterpreted_sort( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_s, &s, _ctx); + _res = Z3_mk_uninterpreted_sort(c, s); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bool_sort( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_bool_sort(c); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_int_sort( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_int_sort(c); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_real_sort( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_real_sort(c); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bv_sort( + value _v_c, + value _v_sz) +{ + Z3_context c; /*in*/ + unsigned int sz; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + sz = Int_val(_v_sz); + _res = Z3_mk_bv_sort(c, sz); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_finite_domain_sort( + value _v_c, + value _v_name, + value _v_size) +{ + Z3_context c; /*in*/ + Z3_symbol name; /*in*/ + __int64 size; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_name, &name, _ctx); + size = Int64_val(_v_size); + _res = Z3_mk_finite_domain_sort(c, name, size); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_array_sort( + value _v_c, + value _v_domain, + value _v_range) +{ + Z3_context c; /*in*/ + Z3_sort domain; /*in*/ + Z3_sort range; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_domain, &domain, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_range, &range, _ctx); + _res = Z3_mk_array_sort(c, domain, range); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_tuple_sort( + value _v_c, + value _v_mk_tuple_name, + value _v_field_names, + value _v_field_sorts) +{ + Z3_context c; /*in*/ + Z3_symbol mk_tuple_name; /*in*/ + unsigned int num_fields; /*in*/ + Z3_symbol const *field_names; /*in*/ + Z3_sort const *field_sorts; /*in*/ + Z3_func_decl *mk_tuple_decl; /*out*/ + Z3_func_decl *proj_decl; /*out*/ + Z3_sort _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + Z3_func_decl _c7; + mlsize_t _c8; + value _v9; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_mk_tuple_name, &mk_tuple_name, _ctx); + _c1 = Wosize_val(_v_field_names); + field_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_field_names, _c2); + camlidl_ml2c_z3V3_Z3_symbol(_v3, &field_names[_c2], _ctx); + } + num_fields = _c1; + _c4 = Wosize_val(_v_field_sorts); + field_sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_field_sorts, _c5); + camlidl_ml2c_z3V3_Z3_sort(_v6, &field_sorts[_c5], _ctx); + } + num_fields = _c4; + mk_tuple_decl = &_c7; + proj_decl = camlidl_malloc(num_fields * sizeof(Z3_func_decl ), _ctx); + _res = Z3_mk_tuple_sort(c, mk_tuple_name, num_fields, field_names, field_sorts, mk_tuple_decl, proj_decl); + Begin_roots_block(_vres, 3) + _vres[0] = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + _vres[1] = camlidl_c2ml_z3V3_Z3_func_decl(&*mk_tuple_decl, _ctx); + _vres[2] = camlidl_alloc(num_fields, 0); + Begin_root(_vres[2]) + for (_c8 = 0; _c8 < num_fields; _c8++) { + _v9 = camlidl_c2ml_z3V3_Z3_func_decl(&proj_decl[_c8], _ctx); + modify(&Field(_vres[2], _c8), _v9); + } + End_roots() + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_mk_enumeration_sort( + value _v_c, + value _v_name, + value _v_enum_names) +{ + Z3_context c; /*in*/ + Z3_symbol name; /*in*/ + unsigned int n; /*in*/ + Z3_symbol const *enum_names; /*in*/ + Z3_func_decl *enum_consts; /*out*/ + Z3_func_decl *enum_testers; /*out*/ + Z3_sort _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + value _v5; + mlsize_t _c6; + value _v7; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_name, &name, _ctx); + _c1 = Wosize_val(_v_enum_names); + enum_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_enum_names, _c2); + camlidl_ml2c_z3V3_Z3_symbol(_v3, &enum_names[_c2], _ctx); + } + n = _c1; + enum_consts = camlidl_malloc(n * sizeof(Z3_func_decl ), _ctx); + enum_testers = camlidl_malloc(n * sizeof(Z3_func_decl ), _ctx); + _res = Z3_mk_enumeration_sort(c, name, n, enum_names, enum_consts, enum_testers); + Begin_roots_block(_vres, 3) + _vres[0] = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + _vres[1] = camlidl_alloc(n, 0); + Begin_root(_vres[1]) + for (_c4 = 0; _c4 < n; _c4++) { + _v5 = camlidl_c2ml_z3V3_Z3_func_decl(&enum_consts[_c4], _ctx); + modify(&Field(_vres[1], _c4), _v5); + } + End_roots() + _vres[2] = camlidl_alloc(n, 0); + Begin_root(_vres[2]) + for (_c6 = 0; _c6 < n; _c6++) { + _v7 = camlidl_c2ml_z3V3_Z3_func_decl(&enum_testers[_c6], _ctx); + modify(&Field(_vres[2], _c6), _v7); + } + End_roots() + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_mk_list_sort( + value _v_c, + value _v_name, + value _v_elem_sort) +{ + Z3_context c; /*in*/ + Z3_symbol name; /*in*/ + Z3_sort elem_sort; /*in*/ + Z3_func_decl *nil_decl; /*out*/ + Z3_func_decl *is_nil_decl; /*out*/ + Z3_func_decl *cons_decl; /*out*/ + Z3_func_decl *is_cons_decl; /*out*/ + Z3_func_decl *head_decl; /*out*/ + Z3_func_decl *tail_decl; /*out*/ + Z3_sort _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + Z3_func_decl _c1; + Z3_func_decl _c2; + Z3_func_decl _c3; + Z3_func_decl _c4; + Z3_func_decl _c5; + Z3_func_decl _c6; + value _vresult; + value _vres[7] = { 0, 0, 0, 0, 0, 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_name, &name, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_elem_sort, &elem_sort, _ctx); + nil_decl = &_c1; + is_nil_decl = &_c2; + cons_decl = &_c3; + is_cons_decl = &_c4; + head_decl = &_c5; + tail_decl = &_c6; + _res = Z3_mk_list_sort(c, name, elem_sort, nil_decl, is_nil_decl, cons_decl, is_cons_decl, head_decl, tail_decl); + Begin_roots_block(_vres, 7) + _vres[0] = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + _vres[1] = camlidl_c2ml_z3V3_Z3_func_decl(&*nil_decl, _ctx); + _vres[2] = camlidl_c2ml_z3V3_Z3_func_decl(&*is_nil_decl, _ctx); + _vres[3] = camlidl_c2ml_z3V3_Z3_func_decl(&*cons_decl, _ctx); + _vres[4] = camlidl_c2ml_z3V3_Z3_func_decl(&*is_cons_decl, _ctx); + _vres[5] = camlidl_c2ml_z3V3_Z3_func_decl(&*head_decl, _ctx); + _vres[6] = camlidl_c2ml_z3V3_Z3_func_decl(&*tail_decl, _ctx); + _vresult = camlidl_alloc_small(7, 0); + { mlsize_t _c7; + for (_c7 = 0; _c7 < 7; _c7++) Field(_vresult, _c7) = _vres[_c7]; + } + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_mk_constructor( + value _v_c, + value _v_name, + value _v_recognizer, + value _v_field_names, + value _v_sorts, + value _v_sort_refs) +{ + Z3_context c; /*in*/ + Z3_symbol name; /*in*/ + Z3_symbol recognizer; /*in*/ + unsigned int num_fields; /*in*/ + Z3_symbol const *field_names; /*in*/ + Z3_sort const *sorts; /*in*/ + unsigned int *sort_refs; /*in*/ + Z3_constructor _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_name, &name, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_recognizer, &recognizer, _ctx); + _c1 = Wosize_val(_v_field_names); + field_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_field_names, _c2); + camlidl_ml2c_z3V3_Z3_symbol(_v3, &field_names[_c2], _ctx); + } + num_fields = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3V3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_fields = _c4; + _c7 = Wosize_val(_v_sort_refs); + sort_refs = camlidl_malloc(_c7 * sizeof(unsigned int ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_sort_refs, _c8); + sort_refs[_c8] = Int_val(_v9); + } + num_fields = _c7; + _res = Z3_mk_constructor(c, name, recognizer, num_fields, field_names, sorts, sort_refs); + _vres = camlidl_c2ml_z3V3_Z3_constructor(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_constructor_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_mk_constructor(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3V3_Z3_del_constructor( + value _v_c, + value _v_constr) +{ + Z3_context c; /*in*/ + Z3_constructor constr; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_constructor(_v_constr, &constr, _ctx); + Z3_del_constructor(c, constr); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_mk_datatype( + value _v_c, + value _v_name, + value _v_constructors) +{ + Z3_context c; /*in*/ + Z3_symbol name; /*in*/ + unsigned int num_constructors; /*in*/ + Z3_constructor *constructors; /*in,out*/ + Z3_sort _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + value _v5; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_name, &name, _ctx); + _c1 = Wosize_val(_v_constructors); + constructors = camlidl_malloc(_c1 * sizeof(Z3_constructor ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_constructors, _c2); + camlidl_ml2c_z3V3_Z3_constructor(_v3, &constructors[_c2], _ctx); + } + num_constructors = _c1; + _res = Z3_mk_datatype(c, name, num_constructors, constructors); + Begin_roots_block(_vres, 2) + _vres[0] = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + _vres[1] = camlidl_alloc(num_constructors, 0); + Begin_root(_vres[1]) + for (_c4 = 0; _c4 < num_constructors; _c4++) { + _v5 = camlidl_c2ml_z3V3_Z3_constructor(&constructors[_c4], _ctx); + modify(&Field(_vres[1], _c4), _v5); + } + End_roots() + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_mk_constructor_list( + value _v_c, + value _v_constructors) +{ + Z3_context c; /*in*/ + unsigned int num_constructors; /*in*/ + Z3_constructor const *constructors; /*in*/ + Z3_constructor_list _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_constructors); + constructors = camlidl_malloc(_c1 * sizeof(Z3_constructor const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_constructors, _c2); + camlidl_ml2c_z3V3_Z3_constructor(_v3, &constructors[_c2], _ctx); + } + num_constructors = _c1; + _res = Z3_mk_constructor_list(c, num_constructors, constructors); + _vres = camlidl_c2ml_z3V3_Z3_constructor_list(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_del_constructor_list( + value _v_c, + value _v_clist) +{ + Z3_context c; /*in*/ + Z3_constructor_list clist; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_constructor_list(_v_clist, &clist, _ctx); + Z3_del_constructor_list(c, clist); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_mk_datatypes( + value _v_c, + value _v_sort_names, + value _v_constructor_lists) +{ + Z3_context c; /*in*/ + unsigned int num_sorts; /*in*/ + Z3_symbol const *sort_names; /*in*/ + Z3_sort *sorts; /*out*/ + Z3_constructor_list *constructor_lists; /*in,out*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + value _v8; + mlsize_t _c9; + value _v10; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_sort_names); + sort_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_sort_names, _c2); + camlidl_ml2c_z3V3_Z3_symbol(_v3, &sort_names[_c2], _ctx); + } + num_sorts = _c1; + _c4 = Wosize_val(_v_constructor_lists); + constructor_lists = camlidl_malloc(_c4 * sizeof(Z3_constructor_list ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_constructor_lists, _c5); + camlidl_ml2c_z3V3_Z3_constructor_list(_v6, &constructor_lists[_c5], _ctx); + } + num_sorts = _c4; + sorts = camlidl_malloc(num_sorts * sizeof(Z3_sort ), _ctx); + Z3_mk_datatypes(c, num_sorts, sort_names, sorts, constructor_lists); + Begin_roots_block(_vres, 2) + _vres[0] = camlidl_alloc(num_sorts, 0); + Begin_root(_vres[0]) + for (_c7 = 0; _c7 < num_sorts; _c7++) { + _v8 = camlidl_c2ml_z3V3_Z3_sort(&sorts[_c7], _ctx); + modify(&Field(_vres[0], _c7), _v8); + } + End_roots() + _vres[1] = camlidl_alloc(num_sorts, 0); + Begin_root(_vres[1]) + for (_c9 = 0; _c9 < num_sorts; _c9++) { + _v10 = camlidl_c2ml_z3V3_Z3_constructor_list(&constructor_lists[_c9], _ctx); + modify(&Field(_vres[1], _c9), _v10); + } + End_roots() + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_query_constructor( + value _v_c, + value _v_constr, + value _v_num_fields) +{ + Z3_context c; /*in*/ + Z3_constructor constr; /*in*/ + unsigned int num_fields; /*in*/ + Z3_func_decl *constructor; /*out*/ + Z3_func_decl *tester; /*out*/ + Z3_func_decl *accessors; /*out*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + Z3_func_decl _c1; + Z3_func_decl _c2; + mlsize_t _c3; + value _v4; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_constructor(_v_constr, &constr, _ctx); + num_fields = Int_val(_v_num_fields); + constructor = &_c1; + tester = &_c2; + accessors = camlidl_malloc(num_fields * sizeof(Z3_func_decl ), _ctx); + Z3_query_constructor(c, constr, num_fields, constructor, tester, accessors); + Begin_roots_block(_vres, 3) + _vres[0] = camlidl_c2ml_z3V3_Z3_func_decl(&*constructor, _ctx); + _vres[1] = camlidl_c2ml_z3V3_Z3_func_decl(&*tester, _ctx); + _vres[2] = camlidl_alloc(num_fields, 0); + Begin_root(_vres[2]) + for (_c3 = 0; _c3 < num_fields; _c3++) { + _v4 = camlidl_c2ml_z3V3_Z3_func_decl(&accessors[_c3], _ctx); + modify(&Field(_vres[2], _c3), _v4); + } + End_roots() + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_mk_func_decl( + value _v_c, + value _v_s, + value _v_domain, + value _v_range) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + unsigned int domain_size; /*in*/ + Z3_sort const *domain; /*in*/ + Z3_sort range; /*in*/ + Z3_func_decl _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_s, &s, _ctx); + _c1 = Wosize_val(_v_domain); + domain = camlidl_malloc(_c1 * sizeof(Z3_sort const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_domain, _c2); + camlidl_ml2c_z3V3_Z3_sort(_v3, &domain[_c2], _ctx); + } + domain_size = _c1; + camlidl_ml2c_z3V3_Z3_sort(_v_range, &range, _ctx); + _res = Z3_mk_func_decl(c, s, domain_size, domain, range); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_app( + value _v_c, + value _v_d, + value _v_args) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_app(c, d, num_args, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_const( + value _v_c, + value _v_s, + value _v_ty) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_s, &s, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_const(c, s, ty); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_fresh_func_decl( + value _v_c, + value _v_prefix, + value _v_domain, + value _v_range) +{ + Z3_context c; /*in*/ + Z3_string prefix; /*in*/ + unsigned int domain_size; /*in*/ + Z3_sort const *domain; /*in*/ + Z3_sort range; /*in*/ + Z3_func_decl _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_prefix, &prefix, _ctx); + _c1 = Wosize_val(_v_domain); + domain = camlidl_malloc(_c1 * sizeof(Z3_sort const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_domain, _c2); + camlidl_ml2c_z3V3_Z3_sort(_v3, &domain[_c2], _ctx); + } + domain_size = _c1; + camlidl_ml2c_z3V3_Z3_sort(_v_range, &range, _ctx); + _res = Z3_mk_fresh_func_decl(c, prefix, domain_size, domain, range); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_fresh_const( + value _v_c, + value _v_prefix, + value _v_ty) +{ + Z3_context c; /*in*/ + Z3_string prefix; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_prefix, &prefix, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_fresh_const(c, prefix, ty); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_true( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_true(c); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_false( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_mk_false(c); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_eq( + value _v_c, + value _v_l, + value _v_r) +{ + Z3_context c; /*in*/ + Z3_ast l; /*in*/ + Z3_ast r; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_l, &l, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_r, &r, _ctx); + _res = Z3_mk_eq(c, l, r); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_distinct( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_distinct(c, num_args, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_not( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_mk_not(c, a); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_ite( + value _v_c, + value _v_t1, + value _v_t2, + value _v_t3) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast t3; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t3, &t3, _ctx); + _res = Z3_mk_ite(c, t1, t2, t3); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_iff( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_iff(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_implies( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_implies(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_xor( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_xor(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_and( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_and(c, num_args, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_or( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_or(c, num_args, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_add( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_add(c, num_args, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_mul( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_mul(c, num_args, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_sub( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_sub(c, num_args, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_unary_minus( + value _v_c, + value _v_arg) +{ + Z3_context c; /*in*/ + Z3_ast arg; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg, &arg, _ctx); + _res = Z3_mk_unary_minus(c, arg); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_div( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_div(c, arg1, arg2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_mod( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_mod(c, arg1, arg2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_rem( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_rem(c, arg1, arg2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_power( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_power(c, arg1, arg2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_lt( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_lt(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_le( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_le(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_gt( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_gt(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_ge( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_ge(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_int2real( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_int2real(c, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_real2int( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_real2int(c, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_is_int( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_is_int(c, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvnot( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_bvnot(c, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvredand( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_bvredand(c, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvredor( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_bvredor(c, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvand( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvand(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvor( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvor(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvxor( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvxor(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvnand( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvnand(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvnor( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvnor(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvxnor( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvxnor(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvneg( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_bvneg(c, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvadd( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvadd(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvsub( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsub(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvmul( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvmul(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvudiv( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvudiv(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvsdiv( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsdiv(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvurem( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvurem(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvsrem( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsrem(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvsmod( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsmod(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvult( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvult(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvslt( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvslt(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvule( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvule(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvsle( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsle(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvuge( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvuge(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvsge( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsge(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvugt( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvugt(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvsgt( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsgt(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_concat( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_concat(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_extract( + value _v_c, + value _v_high, + value _v_low, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int high; /*in*/ + unsigned int low; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + high = Int_val(_v_high); + low = Int_val(_v_low); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_extract(c, high, low, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_sign_ext( + value _v_c, + value _v_i, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_sign_ext(c, i, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_zero_ext( + value _v_c, + value _v_i, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_zero_ext(c, i, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_repeat( + value _v_c, + value _v_i, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_repeat(c, i, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvshl( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvshl(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvlshr( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvlshr(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvashr( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvashr(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_rotate_left( + value _v_c, + value _v_i, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_rotate_left(c, i, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_rotate_right( + value _v_c, + value _v_i, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_rotate_right(c, i, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_ext_rotate_left( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_ext_rotate_left(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_ext_rotate_right( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_ext_rotate_right(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_int2bv( + value _v_c, + value _v_n, + value _v_t1) +{ + Z3_context c; /*in*/ + unsigned int n; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + n = Int_val(_v_n); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_int2bv(c, n, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bv2int( + value _v_c, + value _v_t1, + value _v_is_signed) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + int is_signed; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + is_signed = Int_val(_v_is_signed); + _res = Z3_mk_bv2int(c, t1, is_signed); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvadd_no_overflow( + value _v_c, + value _v_t1, + value _v_t2, + value _v_is_signed) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + int is_signed; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + is_signed = Int_val(_v_is_signed); + _res = Z3_mk_bvadd_no_overflow(c, t1, t2, is_signed); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvadd_no_underflow( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvadd_no_underflow(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvsub_no_overflow( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsub_no_overflow(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvsub_no_underflow( + value _v_c, + value _v_t1, + value _v_t2, + value _v_is_signed) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + int is_signed; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + is_signed = Int_val(_v_is_signed); + _res = Z3_mk_bvsub_no_underflow(c, t1, t2, is_signed); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvsdiv_no_overflow( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvsdiv_no_overflow(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvneg_no_overflow( + value _v_c, + value _v_t1) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + _res = Z3_mk_bvneg_no_overflow(c, t1); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvmul_no_overflow( + value _v_c, + value _v_t1, + value _v_t2, + value _v_is_signed) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + int is_signed; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + is_signed = Int_val(_v_is_signed); + _res = Z3_mk_bvmul_no_overflow(c, t1, t2, is_signed); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bvmul_no_underflow( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_mk_bvmul_no_underflow(c, t1, t2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_select( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_i, &i, _ctx); + _res = Z3_mk_select(c, a, i); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_store( + value _v_c, + value _v_a, + value _v_i, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast i; /*in*/ + Z3_ast v; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_i, &i, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_v, &v, _ctx); + _res = Z3_mk_store(c, a, i, v); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_const_array( + value _v_c, + value _v_domain, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_sort domain; /*in*/ + Z3_ast v; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_domain, &domain, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_v, &v, _ctx); + _res = Z3_mk_const_array(c, domain, v); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_map( + value _v_c, + value _v_f, + value _v_n, + value _v_args) +{ + Z3_context c; /*in*/ + Z3_func_decl f; /*in*/ + unsigned int n; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + Z3_ast _c1; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_f, &f, _ctx); + n = Int_val(_v_n); + args = &_c1; + camlidl_ml2c_z3V3_Z3_ast(_v_args, &_c1, _ctx); + _res = Z3_mk_map(c, f, n, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_array_default( + value _v_c, + value _v_array) +{ + Z3_context c; /*in*/ + Z3_ast array; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_array, &array, _ctx); + _res = Z3_mk_array_default(c, array); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_set_sort( + value _v_c, + value _v_ty) +{ + Z3_context c; /*in*/ + Z3_sort ty; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_set_sort(c, ty); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_empty_set( + value _v_c, + value _v_domain) +{ + Z3_context c; /*in*/ + Z3_sort domain; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_domain, &domain, _ctx); + _res = Z3_mk_empty_set(c, domain); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_full_set( + value _v_c, + value _v_domain) +{ + Z3_context c; /*in*/ + Z3_sort domain; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_domain, &domain, _ctx); + _res = Z3_mk_full_set(c, domain); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_set_add( + value _v_c, + value _v_set, + value _v_elem) +{ + Z3_context c; /*in*/ + Z3_ast set; /*in*/ + Z3_ast elem; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_set, &set, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_elem, &elem, _ctx); + _res = Z3_mk_set_add(c, set, elem); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_set_del( + value _v_c, + value _v_set, + value _v_elem) +{ + Z3_context c; /*in*/ + Z3_ast set; /*in*/ + Z3_ast elem; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_set, &set, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_elem, &elem, _ctx); + _res = Z3_mk_set_del(c, set, elem); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_set_union( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_set_union(c, num_args, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_set_intersect( + value _v_c, + value _v_args) +{ + Z3_context c; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_mk_set_intersect(c, num_args, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_set_difference( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_set_difference(c, arg1, arg2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_set_complement( + value _v_c, + value _v_arg) +{ + Z3_context c; /*in*/ + Z3_ast arg; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg, &arg, _ctx); + _res = Z3_mk_set_complement(c, arg); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_set_member( + value _v_c, + value _v_elem, + value _v_set) +{ + Z3_context c; /*in*/ + Z3_ast elem; /*in*/ + Z3_ast set; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_elem, &elem, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_set, &set, _ctx); + _res = Z3_mk_set_member(c, elem, set); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_set_subset( + value _v_c, + value _v_arg1, + value _v_arg2) +{ + Z3_context c; /*in*/ + Z3_ast arg1; /*in*/ + Z3_ast arg2; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg1, &arg1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_arg2, &arg2, _ctx); + _res = Z3_mk_set_subset(c, arg1, arg2); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_numeral( + value _v_c, + value _v_numeral, + value _v_ty) +{ + Z3_context c; /*in*/ + Z3_string numeral; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_numeral, &numeral, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_numeral(c, numeral, ty); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_real( + value _v_c, + value _v_num, + value _v_den) +{ + Z3_context c; /*in*/ + int num; /*in*/ + int den; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + num = Int_val(_v_num); + den = Int_val(_v_den); + _res = Z3_mk_real(c, num, den); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_int( + value _v_c, + value _v_v, + value _v_ty) +{ + Z3_context c; /*in*/ + int v; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + v = Int_val(_v_v); + camlidl_ml2c_z3V3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_int(c, v, ty); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_int64( + value _v_c, + value _v_v, + value _v_ty) +{ + Z3_context c; /*in*/ + __int64 v; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + v = Int64_val(_v_v); + camlidl_ml2c_z3V3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_int64(c, v, ty); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_pattern( + value _v_c, + value _v_terms) +{ + Z3_context c; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_ast const *terms; /*in*/ + Z3_pattern _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_terms); + terms = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_terms, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &terms[_c2], _ctx); + } + num_patterns = _c1; + _res = Z3_mk_pattern(c, num_patterns, terms); + _vres = camlidl_c2ml_z3V3_Z3_pattern(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_bound( + value _v_c, + value _v_index, + value _v_ty) +{ + Z3_context c; /*in*/ + unsigned int index; /*in*/ + Z3_sort ty; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + index = Int_val(_v_index); + camlidl_ml2c_z3V3_Z3_sort(_v_ty, &ty, _ctx); + _res = Z3_mk_bound(c, index, ty); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_forall( + value _v_c, + value _v_weight, + value _v_patterns, + value _v_sorts, + value _v_decl_names, + value _v_body) +{ + Z3_context c; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + unsigned int num_decls; /*in*/ + Z3_sort const *sorts; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c1 * sizeof(Z3_pattern const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_patterns, _c2); + camlidl_ml2c_z3V3_Z3_pattern(_v3, &patterns[_c2], _ctx); + } + num_patterns = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3V3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_decls = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3V3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + camlidl_ml2c_z3V3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_forall(c, weight, num_patterns, patterns, num_decls, sorts, decl_names, body); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_forall_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_mk_forall(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3V3_Z3_mk_exists( + value _v_c, + value _v_weight, + value _v_patterns, + value _v_sorts, + value _v_decl_names, + value _v_body) +{ + Z3_context c; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + unsigned int num_decls; /*in*/ + Z3_sort const *sorts; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c1 * sizeof(Z3_pattern const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_patterns, _c2); + camlidl_ml2c_z3V3_Z3_pattern(_v3, &patterns[_c2], _ctx); + } + num_patterns = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3V3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_decls = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3V3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + camlidl_ml2c_z3V3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_exists(c, weight, num_patterns, patterns, num_decls, sorts, decl_names, body); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_exists_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_mk_exists(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3V3_Z3_mk_quantifier( + value _v_c, + value _v_is_forall, + value _v_weight, + value _v_patterns, + value _v_sorts, + value _v_decl_names, + value _v_body) +{ + Z3_context c; /*in*/ + int is_forall; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + unsigned int num_decls; /*in*/ + Z3_sort const *sorts; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + is_forall = Int_val(_v_is_forall); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c1 * sizeof(Z3_pattern const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_patterns, _c2); + camlidl_ml2c_z3V3_Z3_pattern(_v3, &patterns[_c2], _ctx); + } + num_patterns = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3V3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_decls = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3V3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + camlidl_ml2c_z3V3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_quantifier(c, is_forall, weight, num_patterns, patterns, num_decls, sorts, decl_names, body); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_quantifier_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_mk_quantifier(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]); +} + +value camlidl_z3V3_Z3_mk_quantifier_ex( + value _v_c, + value _v_is_forall, + value _v_weight, + value _v_quantifier_id, + value _v_skolem_id, + value _v_patterns, + value _v_no_patterns, + value _v_sorts, + value _v_decl_names, + value _v_body) +{ + Z3_context c; /*in*/ + int is_forall; /*in*/ + unsigned int weight; /*in*/ + Z3_symbol quantifier_id; /*in*/ + Z3_symbol skolem_id; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + unsigned int num_no_patterns; /*in*/ + Z3_ast const *no_patterns; /*in*/ + unsigned int num_decls; /*in*/ + Z3_sort const *sorts; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + mlsize_t _c11; + value _v12; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + is_forall = Int_val(_v_is_forall); + weight = Int_val(_v_weight); + camlidl_ml2c_z3V3_Z3_symbol(_v_quantifier_id, &quantifier_id, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_skolem_id, &skolem_id, _ctx); + _c1 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c1 * sizeof(Z3_pattern const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_patterns, _c2); + camlidl_ml2c_z3V3_Z3_pattern(_v3, &patterns[_c2], _ctx); + } + num_patterns = _c1; + _c4 = Wosize_val(_v_no_patterns); + no_patterns = camlidl_malloc(_c4 * sizeof(Z3_ast const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_no_patterns, _c5); + camlidl_ml2c_z3V3_Z3_ast(_v6, &no_patterns[_c5], _ctx); + } + num_no_patterns = _c4; + _c7 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c7 * sizeof(Z3_sort const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_sorts, _c8); + camlidl_ml2c_z3V3_Z3_sort(_v9, &sorts[_c8], _ctx); + } + num_decls = _c7; + _c10 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c10 * sizeof(Z3_symbol const ), _ctx); + for (_c11 = 0; _c11 < _c10; _c11++) { + _v12 = Field(_v_decl_names, _c11); + camlidl_ml2c_z3V3_Z3_symbol(_v12, &decl_names[_c11], _ctx); + } + num_decls = _c10; + camlidl_ml2c_z3V3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_quantifier_ex(c, is_forall, weight, quantifier_id, skolem_id, num_patterns, patterns, num_no_patterns, no_patterns, num_decls, sorts, decl_names, body); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_quantifier_ex_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_mk_quantifier_ex(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]); +} + +value camlidl_z3V3_Z3_mk_forall_const( + value _v_c, + value _v_weight, + value _v_bound, + value _v_patterns, + value _v_body) +{ + Z3_context c; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_bound; /*in*/ + Z3_app const *bound; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_bound); + bound = camlidl_malloc(_c1 * sizeof(Z3_app const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_bound, _c2); + camlidl_ml2c_z3V3_Z3_app(_v3, &bound[_c2], _ctx); + } + num_bound = _c1; + _c4 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c4 * sizeof(Z3_pattern const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_patterns, _c5); + camlidl_ml2c_z3V3_Z3_pattern(_v6, &patterns[_c5], _ctx); + } + num_patterns = _c4; + camlidl_ml2c_z3V3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_forall_const(c, weight, num_bound, bound, num_patterns, patterns, body); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_exists_const( + value _v_c, + value _v_weight, + value _v_bound, + value _v_patterns, + value _v_body) +{ + Z3_context c; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_bound; /*in*/ + Z3_app const *bound; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_bound); + bound = camlidl_malloc(_c1 * sizeof(Z3_app const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_bound, _c2); + camlidl_ml2c_z3V3_Z3_app(_v3, &bound[_c2], _ctx); + } + num_bound = _c1; + _c4 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c4 * sizeof(Z3_pattern const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_patterns, _c5); + camlidl_ml2c_z3V3_Z3_pattern(_v6, &patterns[_c5], _ctx); + } + num_patterns = _c4; + camlidl_ml2c_z3V3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_exists_const(c, weight, num_bound, bound, num_patterns, patterns, body); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_quantifier_const( + value _v_c, + value _v_is_forall, + value _v_weight, + value _v_bound, + value _v_patterns, + value _v_body) +{ + Z3_context c; /*in*/ + int is_forall; /*in*/ + unsigned int weight; /*in*/ + unsigned int num_bound; /*in*/ + Z3_app const *bound; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + is_forall = Int_val(_v_is_forall); + weight = Int_val(_v_weight); + _c1 = Wosize_val(_v_bound); + bound = camlidl_malloc(_c1 * sizeof(Z3_app const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_bound, _c2); + camlidl_ml2c_z3V3_Z3_app(_v3, &bound[_c2], _ctx); + } + num_bound = _c1; + _c4 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c4 * sizeof(Z3_pattern const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_patterns, _c5); + camlidl_ml2c_z3V3_Z3_pattern(_v6, &patterns[_c5], _ctx); + } + num_patterns = _c4; + camlidl_ml2c_z3V3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_quantifier_const(c, is_forall, weight, num_bound, bound, num_patterns, patterns, body); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_quantifier_const_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_mk_quantifier_const(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3V3_Z3_mk_quantifier_const_ex( + value _v_c, + value _v_is_forall, + value _v_weight, + value _v_quantifier_id, + value _v_skolem_id, + value _v_bound, + value _v_patterns, + value _v_no_patterns, + value _v_body) +{ + Z3_context c; /*in*/ + int is_forall; /*in*/ + unsigned int weight; /*in*/ + Z3_symbol quantifier_id; /*in*/ + Z3_symbol skolem_id; /*in*/ + unsigned int num_bound; /*in*/ + Z3_app const *bound; /*in*/ + unsigned int num_patterns; /*in*/ + Z3_pattern const *patterns; /*in*/ + unsigned int num_no_patterns; /*in*/ + Z3_ast const *no_patterns; /*in*/ + Z3_ast body; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + is_forall = Int_val(_v_is_forall); + weight = Int_val(_v_weight); + camlidl_ml2c_z3V3_Z3_symbol(_v_quantifier_id, &quantifier_id, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_skolem_id, &skolem_id, _ctx); + _c1 = Wosize_val(_v_bound); + bound = camlidl_malloc(_c1 * sizeof(Z3_app const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_bound, _c2); + camlidl_ml2c_z3V3_Z3_app(_v3, &bound[_c2], _ctx); + } + num_bound = _c1; + _c4 = Wosize_val(_v_patterns); + patterns = camlidl_malloc(_c4 * sizeof(Z3_pattern const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_patterns, _c5); + camlidl_ml2c_z3V3_Z3_pattern(_v6, &patterns[_c5], _ctx); + } + num_patterns = _c4; + _c7 = Wosize_val(_v_no_patterns); + no_patterns = camlidl_malloc(_c7 * sizeof(Z3_ast const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_no_patterns, _c8); + camlidl_ml2c_z3V3_Z3_ast(_v9, &no_patterns[_c8], _ctx); + } + num_no_patterns = _c7; + camlidl_ml2c_z3V3_Z3_ast(_v_body, &body, _ctx); + _res = Z3_mk_quantifier_const_ex(c, is_forall, weight, quantifier_id, skolem_id, num_bound, bound, num_patterns, patterns, num_no_patterns, no_patterns, body); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_quantifier_const_ex_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_mk_quantifier_const_ex(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]); +} + +value camlidl_z3V3_Z3_get_symbol_kind( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + Z3_symbol_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_s, &s, _ctx); + _res = Z3_get_symbol_kind(c, s); + _vres = camlidl_c2ml_z3V3_Z3_symbol_kind(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_symbol_int( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_s, &s, _ctx); + _res = Z3_get_symbol_int(c, s); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_symbol_string( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_s, &s, _ctx); + _res = Z3_get_symbol_string(c, s); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_sort_name( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_sort d; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_d, &d, _ctx); + _res = Z3_get_sort_name(c, d); + _vres = camlidl_c2ml_z3V3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_sort_id( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_get_sort_id(c, s); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_sort_to_ast( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_sort_to_ast(c, s); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_is_eq_sort( + value _v_c, + value _v_s1, + value _v_s2) +{ + Z3_context c; /*in*/ + Z3_sort s1; /*in*/ + Z3_sort s2; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_s1, &s1, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_s2, &s2, _ctx); + _res = Z3_is_eq_sort(c, s1, s2); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_sort_kind( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + Z3_sort_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_sort_kind(c, t); + _vres = camlidl_c2ml_z3V3_Z3_sort_kind(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_bv_sort_size( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_bv_sort_size(c, t); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_finite_domain_sort_size( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + __int64 *r; /*out*/ + __int64 _c1; + value _v2; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_s, &s, _ctx); + r = &_c1; + Z3_get_finite_domain_sort_size(c, s, r); + if (r == NULL) { + _vres = Val_int(0); + } else { + _v2 = copy_int64(*r); + Begin_root(_v2) + _vres = camlidl_alloc_small(1, 0); + Field(_vres, 0) = _v2; + End_roots(); + } + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_array_sort_domain( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_array_sort_domain(c, t); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_array_sort_range( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_array_sort_range(c, t); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_tuple_sort_mk_decl( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_tuple_sort_mk_decl(c, t); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_tuple_sort_num_fields( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_tuple_sort_num_fields(c, t); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_tuple_sort_field_decl( + value _v_c, + value _v_t, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int i; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + i = Int_val(_v_i); + _res = Z3_get_tuple_sort_field_decl(c, t, i); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_datatype_sort_num_constructors( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + _res = Z3_get_datatype_sort_num_constructors(c, t); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_datatype_sort_constructor( + value _v_c, + value _v_t, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int idx; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_datatype_sort_constructor(c, t, idx); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_datatype_sort_recognizer( + value _v_c, + value _v_t, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int idx; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_datatype_sort_recognizer(c, t, idx); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_datatype_sort_constructor_accessor( + value _v_c, + value _v_t, + value _v_idx_c, + value _v_idx_a) +{ + Z3_context c; /*in*/ + Z3_sort t; /*in*/ + unsigned int idx_c; /*in*/ + unsigned int idx_a; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_t, &t, _ctx); + idx_c = Int_val(_v_idx_c); + idx_a = Int_val(_v_idx_a); + _res = Z3_get_datatype_sort_constructor_accessor(c, t, idx_c, idx_a); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_relation_arity( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_get_relation_arity(c, s); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_relation_column( + value _v_c, + value _v_s, + value _v_col) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + unsigned int col; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_s, &s, _ctx); + col = Int_val(_v_col); + _res = Z3_get_relation_column(c, s, col); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_func_decl_to_ast( + value _v_c, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_func_decl f; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_f, &f, _ctx); + _res = Z3_func_decl_to_ast(c, f); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_is_eq_func_decl( + value _v_c, + value _v_f1, + value _v_f2) +{ + Z3_context c; /*in*/ + Z3_func_decl f1; /*in*/ + Z3_func_decl f2; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_f1, &f1, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_f2, &f2, _ctx); + _res = Z3_is_eq_func_decl(c, f1, f2); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_func_decl_id( + value _v_c, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_func_decl f; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_f, &f, _ctx); + _res = Z3_get_func_decl_id(c, f); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_name( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_decl_name(c, d); + _vres = camlidl_c2ml_z3V3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_kind( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + Z3_decl_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_decl_kind(c, d); + _vres = camlidl_c2ml_z3V3_Z3_decl_kind(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_domain_size( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_domain_size(c, d); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_arity( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_arity(c, d); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_domain( + value _v_c, + value _v_d, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int i; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + i = Int_val(_v_i); + _res = Z3_get_domain(c, d, i); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_range( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_range(c, d); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_num_parameters( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_get_decl_num_parameters(c, d); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_parameter_kind( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_parameter_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_parameter_kind(c, d, idx); + _vres = camlidl_c2ml_z3V3_Z3_parameter_kind(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_int_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_int_parameter(c, d, idx); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_double_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + double _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_double_parameter(c, d, idx); + _vres = copy_double(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_symbol_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_symbol_parameter(c, d, idx); + _vres = camlidl_c2ml_z3V3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_sort_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_sort_parameter(c, d, idx); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_ast_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_ast_parameter(c, d, idx); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_func_decl_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_func_decl_parameter(c, d, idx); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_decl_rational_parameter( + value _v_c, + value _v_d, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int idx; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_decl_rational_parameter(c, d, idx); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_app_to_ast( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_app a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_app(_v_a, &a, _ctx); + _res = Z3_app_to_ast(c, a); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_app_decl( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_app a; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_app(_v_a, &a, _ctx); + _res = Z3_get_app_decl(c, a); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_app_num_args( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_app a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_app(_v_a, &a, _ctx); + _res = Z3_get_app_num_args(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_app_arg( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_app a; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_app(_v_a, &a, _ctx); + i = Int_val(_v_i); + _res = Z3_get_app_arg(c, a, i); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_is_eq_ast( + value _v_c, + value _v_t1, + value _v_t2) +{ + Z3_context c; /*in*/ + Z3_ast t1; /*in*/ + Z3_ast t2; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t1, &t1, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t2, &t2, _ctx); + _res = Z3_is_eq_ast(c, t1, t2); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_ast_id( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_ast t; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t, &t, _ctx); + _res = Z3_get_ast_id(c, t); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_ast_hash( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_ast_hash(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_sort( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_sort(c, a); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_is_well_sorted( + value _v_c, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_ast t; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t, &t, _ctx); + _res = Z3_is_well_sorted(c, t); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_bool_value( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_lbool _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_bool_value(c, a); + _vres = camlidl_c2ml_z3V3_Z3_lbool(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_ast_kind( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast_kind _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_ast_kind(c, a); + _vres = camlidl_c2ml_z3V3_Z3_ast_kind(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_is_app( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_is_app(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_is_numeral_ast( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_is_numeral_ast(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_is_algebraic_number( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_is_algebraic_number(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_to_app( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_app _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_to_app(c, a); + _vres = camlidl_c2ml_z3V3_Z3_app(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_to_func_decl( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_to_func_decl(c, a); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_numeral_string( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_numeral_string(c, a); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_numeral_decimal_string( + value _v_c, + value _v_a, + value _v_precision) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int precision; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + precision = Int_val(_v_precision); + _res = Z3_get_numeral_decimal_string(c, a, precision); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_numerator( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_numerator(c, a); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_denominator( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_denominator(c, a); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_numeral_small( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + __int64 *num; /*out*/ + __int64 *den; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + __int64 _c1; + __int64 _c2; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + num = &_c1; + den = &_c2; + _res = Z3_get_numeral_small(c, a, num, den); + Begin_roots_block(_vres, 3) + _vres[0] = Val_int(_res); + _vres[1] = copy_int64(*num); + _vres[2] = copy_int64(*den); + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_get_numeral_int( + value _v_c, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast v; /*in*/ + int *i; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + int _c1; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_v, &v, _ctx); + i = &_c1; + _res = Z3_get_numeral_int(c, v, i); + Begin_roots_block(_vres, 2) + _vres[0] = Val_int(_res); + _vres[1] = Val_int(*i); + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_get_numeral_int64( + value _v_c, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast v; /*in*/ + __int64 *i; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + __int64 _c1; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_v, &v, _ctx); + i = &_c1; + _res = Z3_get_numeral_int64(c, v, i); + Begin_roots_block(_vres, 2) + _vres[0] = Val_int(_res); + _vres[1] = copy_int64(*i); + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_get_numeral_rational_int64( + value _v_c, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_ast v; /*in*/ + __int64 *num; /*out*/ + __int64 *den; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + __int64 _c1; + __int64 _c2; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_v, &v, _ctx); + num = &_c1; + den = &_c2; + _res = Z3_get_numeral_rational_int64(c, v, num, den); + Begin_roots_block(_vres, 3) + _vres[0] = Val_int(_res); + _vres[1] = copy_int64(*num); + _vres[2] = copy_int64(*den); + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_get_algebraic_number_lower( + value _v_c, + value _v_a, + value _v_precision) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int precision; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + precision = Int_val(_v_precision); + _res = Z3_get_algebraic_number_lower(c, a, precision); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_algebraic_number_upper( + value _v_c, + value _v_a, + value _v_precision) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int precision; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + precision = Int_val(_v_precision); + _res = Z3_get_algebraic_number_upper(c, a, precision); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_pattern_to_ast( + value _v_c, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_pattern p; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_pattern(_v_p, &p, _ctx); + _res = Z3_pattern_to_ast(c, p); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_pattern_num_terms( + value _v_c, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_pattern p; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_pattern(_v_p, &p, _ctx); + _res = Z3_get_pattern_num_terms(c, p); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_pattern( + value _v_c, + value _v_p, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_pattern p; /*in*/ + unsigned int idx; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_pattern(_v_p, &p, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_pattern(c, p, idx); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_index_value( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_index_value(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_is_quantifier_forall( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_is_quantifier_forall(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_quantifier_weight( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_quantifier_weight(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_quantifier_num_patterns( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_quantifier_num_patterns(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_quantifier_pattern_ast( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int i; /*in*/ + Z3_pattern _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + i = Int_val(_v_i); + _res = Z3_get_quantifier_pattern_ast(c, a, i); + _vres = camlidl_c2ml_z3V3_Z3_pattern(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_quantifier_num_no_patterns( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_quantifier_num_no_patterns(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_quantifier_no_pattern_ast( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + i = Int_val(_v_i); + _res = Z3_get_quantifier_no_pattern_ast(c, a, i); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_quantifier_bound_name( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int i; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + i = Int_val(_v_i); + _res = Z3_get_quantifier_bound_name(c, a, i); + _vres = camlidl_c2ml_z3V3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_quantifier_bound_sort( + value _v_c, + value _v_a, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int i; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + i = Int_val(_v_i); + _res = Z3_get_quantifier_bound_sort(c, a, i); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_quantifier_body( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_quantifier_body(c, a); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_quantifier_num_bound( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_get_quantifier_num_bound(c, a); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_simplify( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_simplify(c, a); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_update_term( + value _v_c, + value _v_a, + value _v_args) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + _res = Z3_update_term(c, a, num_args, args); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_substitute( + value _v_c, + value _v_a, + value _v_from, + value _v_to) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int num_exprs; /*in*/ + Z3_ast const *from; /*in*/ + Z3_ast const *to; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _c1 = Wosize_val(_v_from); + from = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_from, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &from[_c2], _ctx); + } + num_exprs = _c1; + _c4 = Wosize_val(_v_to); + to = camlidl_malloc(_c4 * sizeof(Z3_ast const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_to, _c5); + camlidl_ml2c_z3V3_Z3_ast(_v6, &to[_c5], _ctx); + } + num_exprs = _c4; + _res = Z3_substitute(c, a, num_exprs, from, to); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_substitute_vars( + value _v_c, + value _v_a, + value _v_to) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int num_exprs; /*in*/ + Z3_ast const *to; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _c1 = Wosize_val(_v_to); + to = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_to, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &to[_c2], _ctx); + } + num_exprs = _c1; + _res = Z3_substitute_vars(c, a, num_exprs, to); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_open_log( + value _v_filename) +{ + Z3_string filename; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_string(_v_filename, &filename, _ctx); + _res = Z3_open_log(filename); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_append_log( + value _v_string) +{ + Z3_string string; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_string(_v_string, &string, _ctx); + Z3_append_log(string); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_close_log(value _unit) +{ + Z3_close_log(); + return Val_unit; +} + +value camlidl_z3V3_Z3_toggle_warning_messages( + value _v_enabled) +{ + int enabled; /*in*/ + enabled = Int_val(_v_enabled); + Z3_toggle_warning_messages(enabled); + return Val_unit; +} + +value camlidl_z3V3_Z3_set_ast_print_mode( + value _v_c, + value _v_mode) +{ + Z3_context c; /*in*/ + Z3_ast_print_mode mode; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast_print_mode(_v_mode, &mode, _ctx); + Z3_set_ast_print_mode(c, mode); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_ast_to_string( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + _res = Z3_ast_to_string(c, a); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_pattern_to_string( + value _v_c, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_pattern p; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_pattern(_v_p, &p, _ctx); + _res = Z3_pattern_to_string(c, p); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_sort_to_string( + value _v_c, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_sort s; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_sort_to_string(c, s); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_func_decl_to_string( + value _v_c, + value _v_d) +{ + Z3_context c; /*in*/ + Z3_func_decl d; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_func_decl_to_string(c, d); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_model_to_string( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + _res = Z3_model_to_string(c, m); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_benchmark_to_smtlib_string( + value _v_c, + value _v_name, + value _v_logic, + value _v_status, + value _v_attributes, + value _v_assumptions, + value _v_formula) +{ + Z3_context c; /*in*/ + Z3_string name; /*in*/ + Z3_string logic; /*in*/ + Z3_string status; /*in*/ + Z3_string attributes; /*in*/ + unsigned int num_assumptions; /*in*/ + Z3_ast const *assumptions; /*in*/ + Z3_ast formula; /*in*/ + Z3_string _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_name, &name, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_logic, &logic, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_status, &status, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_attributes, &attributes, _ctx); + _c1 = Wosize_val(_v_assumptions); + assumptions = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_assumptions, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &assumptions[_c2], _ctx); + } + num_assumptions = _c1; + camlidl_ml2c_z3V3_Z3_ast(_v_formula, &formula, _ctx); + _res = Z3_benchmark_to_smtlib_string(c, name, logic, status, attributes, num_assumptions, assumptions, formula); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_benchmark_to_smtlib_string_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_benchmark_to_smtlib_string(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]); +} + +value camlidl_z3V3_Z3_parse_smtlib2_string( + value _v_c, + value _v_str, + value _v_sort_names, + value _v_sorts, + value _v_decl_names, + value _v_decls) +{ + Z3_context c; /*in*/ + Z3_string str; /*in*/ + unsigned int num_sorts; /*in*/ + Z3_symbol const *sort_names; /*in*/ + Z3_sort const *sorts; /*in*/ + unsigned int num_decls; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_func_decl const *decls; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + mlsize_t _c11; + value _v12; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_str, &str, _ctx); + _c1 = Wosize_val(_v_sort_names); + sort_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_sort_names, _c2); + camlidl_ml2c_z3V3_Z3_symbol(_v3, &sort_names[_c2], _ctx); + } + num_sorts = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3V3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_sorts = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3V3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + _c10 = Wosize_val(_v_decls); + decls = camlidl_malloc(_c10 * sizeof(Z3_func_decl const ), _ctx); + for (_c11 = 0; _c11 < _c10; _c11++) { + _v12 = Field(_v_decls, _c11); + camlidl_ml2c_z3V3_Z3_func_decl(_v12, &decls[_c11], _ctx); + } + num_decls = _c10; + _res = Z3_parse_smtlib2_string(c, str, num_sorts, sort_names, sorts, num_decls, decl_names, decls); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_parse_smtlib2_string_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_parse_smtlib2_string(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3V3_Z3_parse_smtlib2_file( + value _v_c, + value _v_file_name, + value _v_sort_names, + value _v_sorts, + value _v_decl_names, + value _v_decls) +{ + Z3_context c; /*in*/ + Z3_string file_name; /*in*/ + unsigned int num_sorts; /*in*/ + Z3_symbol const *sort_names; /*in*/ + Z3_sort const *sorts; /*in*/ + unsigned int num_decls; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_func_decl const *decls; /*in*/ + Z3_ast _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + mlsize_t _c11; + value _v12; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_file_name, &file_name, _ctx); + _c1 = Wosize_val(_v_sort_names); + sort_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_sort_names, _c2); + camlidl_ml2c_z3V3_Z3_symbol(_v3, &sort_names[_c2], _ctx); + } + num_sorts = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3V3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_sorts = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3V3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + _c10 = Wosize_val(_v_decls); + decls = camlidl_malloc(_c10 * sizeof(Z3_func_decl const ), _ctx); + for (_c11 = 0; _c11 < _c10; _c11++) { + _v12 = Field(_v_decls, _c11); + camlidl_ml2c_z3V3_Z3_func_decl(_v12, &decls[_c11], _ctx); + } + num_decls = _c10; + _res = Z3_parse_smtlib2_file(c, file_name, num_sorts, sort_names, sorts, num_decls, decl_names, decls); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_parse_smtlib2_file_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_parse_smtlib2_file(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3V3_Z3_parse_smtlib_string( + value _v_c, + value _v_str, + value _v_sort_names, + value _v_sorts, + value _v_decl_names, + value _v_decls) +{ + Z3_context c; /*in*/ + Z3_string str; /*in*/ + unsigned int num_sorts; /*in*/ + Z3_symbol const *sort_names; /*in*/ + Z3_sort const *sorts; /*in*/ + unsigned int num_decls; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_func_decl const *decls; /*in*/ + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + mlsize_t _c11; + value _v12; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_str, &str, _ctx); + _c1 = Wosize_val(_v_sort_names); + sort_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_sort_names, _c2); + camlidl_ml2c_z3V3_Z3_symbol(_v3, &sort_names[_c2], _ctx); + } + num_sorts = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3V3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_sorts = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3V3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + _c10 = Wosize_val(_v_decls); + decls = camlidl_malloc(_c10 * sizeof(Z3_func_decl const ), _ctx); + for (_c11 = 0; _c11 < _c10; _c11++) { + _v12 = Field(_v_decls, _c11); + camlidl_ml2c_z3V3_Z3_func_decl(_v12, &decls[_c11], _ctx); + } + num_decls = _c10; + Z3_parse_smtlib_string(c, str, num_sorts, sort_names, sorts, num_decls, decl_names, decls); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_parse_smtlib_string_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_parse_smtlib_string(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3V3_Z3_parse_smtlib_file( + value _v_c, + value _v_file_name, + value _v_sort_names, + value _v_sorts, + value _v_decl_names, + value _v_decls) +{ + Z3_context c; /*in*/ + Z3_string file_name; /*in*/ + unsigned int num_sorts; /*in*/ + Z3_symbol const *sort_names; /*in*/ + Z3_sort const *sorts; /*in*/ + unsigned int num_decls; /*in*/ + Z3_symbol const *decl_names; /*in*/ + Z3_func_decl const *decls; /*in*/ + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + mlsize_t _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + mlsize_t _c11; + value _v12; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_file_name, &file_name, _ctx); + _c1 = Wosize_val(_v_sort_names); + sort_names = camlidl_malloc(_c1 * sizeof(Z3_symbol const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_sort_names, _c2); + camlidl_ml2c_z3V3_Z3_symbol(_v3, &sort_names[_c2], _ctx); + } + num_sorts = _c1; + _c4 = Wosize_val(_v_sorts); + sorts = camlidl_malloc(_c4 * sizeof(Z3_sort const ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_sorts, _c5); + camlidl_ml2c_z3V3_Z3_sort(_v6, &sorts[_c5], _ctx); + } + num_sorts = _c4; + _c7 = Wosize_val(_v_decl_names); + decl_names = camlidl_malloc(_c7 * sizeof(Z3_symbol const ), _ctx); + for (_c8 = 0; _c8 < _c7; _c8++) { + _v9 = Field(_v_decl_names, _c8); + camlidl_ml2c_z3V3_Z3_symbol(_v9, &decl_names[_c8], _ctx); + } + num_decls = _c7; + _c10 = Wosize_val(_v_decls); + decls = camlidl_malloc(_c10 * sizeof(Z3_func_decl const ), _ctx); + for (_c11 = 0; _c11 < _c10; _c11++) { + _v12 = Field(_v_decls, _c11); + camlidl_ml2c_z3V3_Z3_func_decl(_v12, &decls[_c11], _ctx); + } + num_decls = _c10; + Z3_parse_smtlib_file(c, file_name, num_sorts, sort_names, sorts, num_decls, decl_names, decls); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_parse_smtlib_file_bytecode(value * argv, int argn) +{ + return camlidl_z3V3_Z3_parse_smtlib_file(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]); +} + +value camlidl_z3V3_Z3_get_smtlib_num_formulas( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_smtlib_num_formulas(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_smtlib_formula( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_get_smtlib_formula(c, i); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_smtlib_num_assumptions( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_smtlib_num_assumptions(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_smtlib_assumption( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_get_smtlib_assumption(c, i); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_smtlib_num_decls( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_smtlib_num_decls(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_smtlib_decl( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_get_smtlib_decl(c, i); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_smtlib_num_sorts( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_smtlib_num_sorts(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_smtlib_sort( + value _v_c, + value _v_i) +{ + Z3_context c; /*in*/ + unsigned int i; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + i = Int_val(_v_i); + _res = Z3_get_smtlib_sort(c, i); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_smtlib_error( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_smtlib_error(c); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3_Z3_parse_z3V3_string( + value _v_c, + value _v_str) +{ + Z3_context c; /*in*/ + Z3_string str; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_str, &str, _ctx); + _res = Z3_parse_z3_string(c, str); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3_Z3_parse_z3V3_file( + value _v_c, + value _v_file_name) +{ + Z3_context c; /*in*/ + Z3_string file_name; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_file_name, &file_name, _ctx); + _res = Z3_parse_z3_file(c, file_name); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_version(value _unit) +{ + unsigned int *major; /*out*/ + unsigned int *minor; /*out*/ + unsigned int *build_number; /*out*/ + unsigned int *revision_number; /*out*/ + unsigned int _c1; + unsigned int _c2; + unsigned int _c3; + unsigned int _c4; + value _vresult; + value _vres[4] = { 0, 0, 0, 0, }; + + major = &_c1; + minor = &_c2; + build_number = &_c3; + revision_number = &_c4; + Z3_get_version(major, minor, build_number, revision_number); + Begin_roots_block(_vres, 4) + _vres[0] = Val_int(*major); + _vres[1] = Val_int(*minor); + _vres[2] = Val_int(*build_number); + _vres[3] = Val_int(*revision_number); + _vresult = camlidl_alloc_small(4, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + Field(_vresult, 3) = _vres[3]; + End_roots() + return _vresult; +} + +value camlidl_z3V3_Z3_reset_memory(value _unit) +{ + Z3_reset_memory(); + return Val_unit; +} + +value camlidl_z3V3_Z3_theory_mk_sort( + value _v_c, + value _v_t, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_theory t; /*in*/ + Z3_symbol s; /*in*/ + Z3_sort _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_s, &s, _ctx); + _res = Z3_theory_mk_sort(c, t, s); + _vres = camlidl_c2ml_z3V3_Z3_sort(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_mk_value( + value _v_c, + value _v_t, + value _v_n, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_theory t; /*in*/ + Z3_symbol n; /*in*/ + Z3_sort s; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_n, &n, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_theory_mk_value(c, t, n, s); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_mk_constant( + value _v_c, + value _v_t, + value _v_n, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_theory t; /*in*/ + Z3_symbol n; /*in*/ + Z3_sort s; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_n, &n, _ctx); + camlidl_ml2c_z3V3_Z3_sort(_v_s, &s, _ctx); + _res = Z3_theory_mk_constant(c, t, n, s); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_mk_func_decl( + value _v_c, + value _v_t, + value _v_n, + value _v_domain, + value _v_range) +{ + Z3_context c; /*in*/ + Z3_theory t; /*in*/ + Z3_symbol n; /*in*/ + unsigned int domain_size; /*in*/ + Z3_sort const *domain; /*in*/ + Z3_sort range; /*in*/ + Z3_func_decl _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_n, &n, _ctx); + _c1 = Wosize_val(_v_domain); + domain = camlidl_malloc(_c1 * sizeof(Z3_sort const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_domain, _c2); + camlidl_ml2c_z3V3_Z3_sort(_v3, &domain[_c2], _ctx); + } + domain_size = _c1; + camlidl_ml2c_z3V3_Z3_sort(_v_range, &range, _ctx); + _res = Z3_theory_mk_func_decl(c, t, n, domain_size, domain, range); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_get_context( + value _v_t) +{ + Z3_theory t; /*in*/ + Z3_context _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + _res = Z3_theory_get_context(t); + _vres = camlidl_c2ml_z3V3_Z3_context(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_assert_axiom( + value _v_t, + value _v_ax) +{ + Z3_theory t; /*in*/ + Z3_ast ax; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_ax, &ax, _ctx); + Z3_theory_assert_axiom(t, ax); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_theory_assume_eq( + value _v_t, + value _v_lhs, + value _v_rhs) +{ + Z3_theory t; /*in*/ + Z3_ast lhs; /*in*/ + Z3_ast rhs; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_lhs, &lhs, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_rhs, &rhs, _ctx); + Z3_theory_assume_eq(t, lhs, rhs); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_theory_enable_axiom_simplification( + value _v_t, + value _v_flag) +{ + Z3_theory t; /*in*/ + int flag; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + flag = Int_val(_v_flag); + Z3_theory_enable_axiom_simplification(t, flag); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_theory_get_eqc_root( + value _v_t, + value _v_n) +{ + Z3_theory t; /*in*/ + Z3_ast n; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_n, &n, _ctx); + _res = Z3_theory_get_eqc_root(t, n); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_get_eqc_next( + value _v_t, + value _v_n) +{ + Z3_theory t; /*in*/ + Z3_ast n; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_n, &n, _ctx); + _res = Z3_theory_get_eqc_next(t, n); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_get_num_parents( + value _v_t, + value _v_n) +{ + Z3_theory t; /*in*/ + Z3_ast n; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_n, &n, _ctx); + _res = Z3_theory_get_num_parents(t, n); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_get_parent( + value _v_t, + value _v_n, + value _v_i) +{ + Z3_theory t; /*in*/ + Z3_ast n; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_n, &n, _ctx); + i = Int_val(_v_i); + _res = Z3_theory_get_parent(t, n, i); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_is_value( + value _v_t, + value _v_n) +{ + Z3_theory t; /*in*/ + Z3_ast n; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_n, &n, _ctx); + _res = Z3_theory_is_value(t, n); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_is_decl( + value _v_t, + value _v_d) +{ + Z3_theory t; /*in*/ + Z3_func_decl d; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + _res = Z3_theory_is_decl(t, d); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_get_num_elems( + value _v_t) +{ + Z3_theory t; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + _res = Z3_theory_get_num_elems(t); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_get_elem( + value _v_t, + value _v_i) +{ + Z3_theory t; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + i = Int_val(_v_i); + _res = Z3_theory_get_elem(t, i); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_get_num_apps( + value _v_t) +{ + Z3_theory t; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + _res = Z3_theory_get_num_apps(t); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_theory_get_app( + value _v_t, + value _v_i) +{ + Z3_theory t; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_theory(_v_t, &t, _ctx); + i = Int_val(_v_i); + _res = Z3_theory_get_app(t, i); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_injective_function( + value _v_c, + value _v_s, + value _v_domain, + value _v_range) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + unsigned int domain_size; /*in*/ + Z3_sort const *domain; /*in*/ + Z3_sort range; /*in*/ + Z3_func_decl _res; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_s, &s, _ctx); + _c1 = Wosize_val(_v_domain); + domain = camlidl_malloc(_c1 * sizeof(Z3_sort const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_domain, _c2); + camlidl_ml2c_z3V3_Z3_sort(_v3, &domain[_c2], _ctx); + } + domain_size = _c1; + camlidl_ml2c_z3V3_Z3_sort(_v_range, &range, _ctx); + _res = Z3_mk_injective_function(c, s, domain_size, domain, range); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_set_logic( + value _v_c, + value _v_logic) +{ + Z3_context c; /*in*/ + Z3_string logic; /*in*/ + int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_logic, &logic, _ctx); + _res = Z3_set_logic(c, logic); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_push( + value _v_c) +{ + Z3_context c; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + Z3_push(c); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_pop( + value _v_c, + value _v_num_scopes) +{ + Z3_context c; /*in*/ + unsigned int num_scopes; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + num_scopes = Int_val(_v_num_scopes); + Z3_pop(c, num_scopes); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_get_num_scopes( + value _v_c) +{ + Z3_context c; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_num_scopes(c); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_persist_ast( + value _v_c, + value _v_a, + value _v_num_scopes) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + unsigned int num_scopes; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + num_scopes = Int_val(_v_num_scopes); + Z3_persist_ast(c, a, num_scopes); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_assert_cnstr( + value _v_c, + value _v_a) +{ + Z3_context c; /*in*/ + Z3_ast a; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_a, &a, _ctx); + Z3_assert_cnstr(c, a); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_check_and_get_model( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_model *m; /*out*/ + Z3_lbool _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + Z3_model _c1; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + m = &_c1; + _res = Z3_check_and_get_model(c, m); + Begin_roots_block(_vres, 2) + _vres[0] = camlidl_c2ml_z3V3_Z3_lbool(&_res, _ctx); + _vres[1] = camlidl_c2ml_z3V3_Z3_model(&*m, _ctx); + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_check( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_lbool _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_check(c); + _vres = camlidl_c2ml_z3V3_Z3_lbool(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_check_assumptions( + value _v_c, + value _v_assumptions, + value _v_core_size, + value _v_core) +{ + Z3_context c; /*in*/ + unsigned int num_assumptions; /*in*/ + Z3_ast const *assumptions; /*in*/ + Z3_model *m; /*out*/ + Z3_ast *proof; /*out*/ + unsigned int *core_size; /*in,out*/ + Z3_ast *core; /*in,out*/ + Z3_lbool _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + unsigned int _c4; + mlsize_t _c5; + mlsize_t _c6; + value _v7; + Z3_model _c8; + Z3_ast _c9; + mlsize_t _c10; + value _v11; + value _vresult; + value _vres[5] = { 0, 0, 0, 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_assumptions); + assumptions = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_assumptions, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &assumptions[_c2], _ctx); + } + num_assumptions = _c1; + core_size = &_c4; + _c4 = Int_val(_v_core_size); + _c5 = Wosize_val(_v_core); + core = camlidl_malloc(_c5 * sizeof(Z3_ast ), _ctx); + for (_c6 = 0; _c6 < _c5; _c6++) { + _v7 = Field(_v_core, _c6); + camlidl_ml2c_z3V3_Z3_ast(_v7, &core[_c6], _ctx); + } + num_assumptions = _c5; + m = &_c8; + proof = &_c9; + _res = Z3_check_assumptions(c, num_assumptions, assumptions, m, proof, core_size, core); + Begin_roots_block(_vres, 5) + _vres[0] = camlidl_c2ml_z3V3_Z3_lbool(&_res, _ctx); + _vres[1] = camlidl_c2ml_z3V3_Z3_model(&*m, _ctx); + _vres[2] = camlidl_c2ml_z3V3_Z3_ast(&*proof, _ctx); + _vres[3] = Val_int(*core_size); + _vres[4] = camlidl_alloc(num_assumptions, 0); + Begin_root(_vres[4]) + for (_c10 = 0; _c10 < num_assumptions; _c10++) { + _v11 = camlidl_c2ml_z3V3_Z3_ast(&core[_c10], _ctx); + modify(&Field(_vres[4], _c10), _v11); + } + End_roots() + _vresult = camlidl_alloc_small(5, 0); + { mlsize_t _c12; + for (_c12 = 0; _c12 < 5; _c12++) Field(_vresult, _c12) = _vres[_c12]; + } + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_get_implied_equalities( + value _v_c, + value _v_terms) +{ + Z3_context c; /*in*/ + unsigned int num_terms; /*in*/ + Z3_ast const *terms; /*in*/ + unsigned int *class_ids; /*out*/ + Z3_lbool _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + value _v5; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _c1 = Wosize_val(_v_terms); + terms = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_terms, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &terms[_c2], _ctx); + } + num_terms = _c1; + class_ids = camlidl_malloc(num_terms * sizeof(unsigned int ), _ctx); + _res = Z3_get_implied_equalities(c, num_terms, terms, class_ids); + Begin_roots_block(_vres, 2) + _vres[0] = camlidl_c2ml_z3V3_Z3_lbool(&_res, _ctx); + _vres[1] = camlidl_alloc(num_terms, 0); + for (_c4 = 0; _c4 < num_terms; _c4++) { + _v5 = Val_int(class_ids[_c4]); + modify(&Field(_vres[1], _c4), _v5); + } + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_del_model( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + Z3_del_model(c, m); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_soft_check_cancel( + value _v_c) +{ + Z3_context c; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + Z3_soft_check_cancel(c); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_get_search_failure( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_search_failure _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_search_failure(c); + _vres = camlidl_c2ml_z3V3_Z3_search_failure(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_mk_label( + value _v_c, + value _v_s, + value _v_is_pos, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_symbol s; /*in*/ + int is_pos; /*in*/ + Z3_ast f; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_symbol(_v_s, &s, _ctx); + is_pos = Int_val(_v_is_pos); + camlidl_ml2c_z3V3_Z3_ast(_v_f, &f, _ctx); + _res = Z3_mk_label(c, s, is_pos, f); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_relevant_labels( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_literals _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_relevant_labels(c); + _vres = camlidl_c2ml_z3V3_Z3_literals(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_relevant_literals( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_literals _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_relevant_literals(c); + _vres = camlidl_c2ml_z3V3_Z3_literals(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_guessed_literals( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_literals _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_guessed_literals(c); + _vres = camlidl_c2ml_z3V3_Z3_literals(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_del_literals( + value _v_c, + value _v_lbls) +{ + Z3_context c; /*in*/ + Z3_literals lbls; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_literals(_v_lbls, &lbls, _ctx); + Z3_del_literals(c, lbls); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_get_num_literals( + value _v_c, + value _v_lbls) +{ + Z3_context c; /*in*/ + Z3_literals lbls; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_literals(_v_lbls, &lbls, _ctx); + _res = Z3_get_num_literals(c, lbls); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_label_symbol( + value _v_c, + value _v_lbls, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_literals lbls; /*in*/ + unsigned int idx; /*in*/ + Z3_symbol _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_literals(_v_lbls, &lbls, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_label_symbol(c, lbls, idx); + _vres = camlidl_c2ml_z3V3_Z3_symbol(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_literal( + value _v_c, + value _v_lbls, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_literals lbls; /*in*/ + unsigned int idx; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_literals(_v_lbls, &lbls, _ctx); + idx = Int_val(_v_idx); + _res = Z3_get_literal(c, lbls, idx); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_disable_literal( + value _v_c, + value _v_lbls, + value _v_idx) +{ + Z3_context c; /*in*/ + Z3_literals lbls; /*in*/ + unsigned int idx; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_literals(_v_lbls, &lbls, _ctx); + idx = Int_val(_v_idx); + Z3_disable_literal(c, lbls, idx); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_block_literals( + value _v_c, + value _v_lbls) +{ + Z3_context c; /*in*/ + Z3_literals lbls; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_literals(_v_lbls, &lbls, _ctx); + Z3_block_literals(c, lbls); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_get_model_num_constants( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + _res = Z3_get_model_num_constants(c, m); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_model_constant( + value _v_c, + value _v_m, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int i; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + i = Int_val(_v_i); + _res = Z3_get_model_constant(c, m, i); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_model_num_funcs( + value _v_c, + value _v_m) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + _res = Z3_get_model_num_funcs(c, m); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_model_func_decl( + value _v_c, + value _v_m, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int i; /*in*/ + Z3_func_decl _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + i = Int_val(_v_i); + _res = Z3_get_model_func_decl(c, m, i); + _vres = camlidl_c2ml_z3V3_Z3_func_decl(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_eval_func_decl( + value _v_c, + value _v_m, + value _v_decl) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_func_decl decl; /*in*/ + Z3_ast *v; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + Z3_ast _c1; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_decl, &decl, _ctx); + v = &_c1; + _res = Z3_eval_func_decl(c, m, decl, v); + Begin_roots_block(_vres, 2) + _vres[0] = Val_int(_res); + _vres[1] = camlidl_c2ml_z3V3_Z3_ast(&*v, _ctx); + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_is_array_value( + value _v_c, + value _v_m, + value _v_v) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_ast v; /*in*/ + unsigned int *num_entries; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + unsigned int _c1; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_v, &v, _ctx); + num_entries = &_c1; + _res = Z3_is_array_value(c, m, v, num_entries); + Begin_roots_block(_vres, 2) + _vres[0] = Val_int(_res); + _vres[1] = Val_int(*num_entries); + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_get_array_value( + value _v_c, + value _v_m, + value _v_v, + value _v_indices, + value _v_values) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_ast v; /*in*/ + unsigned int num_entries; /*in*/ + Z3_ast *indices; /*in,out*/ + Z3_ast *values; /*in,out*/ + Z3_ast *else_value; /*out*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + mlsize_t _c4; + mlsize_t _c5; + value _v6; + Z3_ast _c7; + mlsize_t _c8; + value _v9; + mlsize_t _c10; + value _v11; + value _vresult; + value _vres[3] = { 0, 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_v, &v, _ctx); + _c1 = Wosize_val(_v_indices); + indices = camlidl_malloc(_c1 * sizeof(Z3_ast ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_indices, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &indices[_c2], _ctx); + } + num_entries = _c1; + _c4 = Wosize_val(_v_values); + values = camlidl_malloc(_c4 * sizeof(Z3_ast ), _ctx); + for (_c5 = 0; _c5 < _c4; _c5++) { + _v6 = Field(_v_values, _c5); + camlidl_ml2c_z3V3_Z3_ast(_v6, &values[_c5], _ctx); + } + num_entries = _c4; + else_value = &_c7; + Z3_get_array_value(c, m, v, num_entries, indices, values, else_value); + Begin_roots_block(_vres, 3) + _vres[0] = camlidl_alloc(num_entries, 0); + Begin_root(_vres[0]) + for (_c8 = 0; _c8 < num_entries; _c8++) { + _v9 = camlidl_c2ml_z3V3_Z3_ast(&indices[_c8], _ctx); + modify(&Field(_vres[0], _c8), _v9); + } + End_roots() + _vres[1] = camlidl_alloc(num_entries, 0); + Begin_root(_vres[1]) + for (_c10 = 0; _c10 < num_entries; _c10++) { + _v11 = camlidl_c2ml_z3V3_Z3_ast(&values[_c10], _ctx); + modify(&Field(_vres[1], _c10), _v11); + } + End_roots() + _vres[2] = camlidl_c2ml_z3V3_Z3_ast(&*else_value, _ctx); + _vresult = camlidl_alloc_small(3, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + Field(_vresult, 2) = _vres[2]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_get_model_func_else( + value _v_c, + value _v_m, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int i; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + i = Int_val(_v_i); + _res = Z3_get_model_func_else(c, m, i); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_model_func_num_entries( + value _v_c, + value _v_m, + value _v_i) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int i; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + i = Int_val(_v_i); + _res = Z3_get_model_func_num_entries(c, m, i); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_model_func_entry_num_args( + value _v_c, + value _v_m, + value _v_i, + value _v_j) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int i; /*in*/ + unsigned int j; /*in*/ + unsigned int _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + i = Int_val(_v_i); + j = Int_val(_v_j); + _res = Z3_get_model_func_entry_num_args(c, m, i, j); + _vres = Val_int(_res); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_model_func_entry_arg( + value _v_c, + value _v_m, + value _v_i, + value _v_j, + value _v_k) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int i; /*in*/ + unsigned int j; /*in*/ + unsigned int k; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + i = Int_val(_v_i); + j = Int_val(_v_j); + k = Int_val(_v_k); + _res = Z3_get_model_func_entry_arg(c, m, i, j, k); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_model_func_entry_value( + value _v_c, + value _v_m, + value _v_i, + value _v_j) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + unsigned int i; /*in*/ + unsigned int j; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + i = Int_val(_v_i); + j = Int_val(_v_j); + _res = Z3_get_model_func_entry_value(c, m, i, j); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_eval( + value _v_c, + value _v_m, + value _v_t) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_ast t; /*in*/ + Z3_ast *v; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + Z3_ast _c1; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + camlidl_ml2c_z3V3_Z3_ast(_v_t, &t, _ctx); + v = &_c1; + _res = Z3_eval(c, m, t, v); + Begin_roots_block(_vres, 2) + _vres[0] = Val_int(_res); + _vres[1] = camlidl_c2ml_z3V3_Z3_ast(&*v, _ctx); + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_eval_decl( + value _v_c, + value _v_m, + value _v_d, + value _v_args) +{ + Z3_context c; /*in*/ + Z3_model m; /*in*/ + Z3_func_decl d; /*in*/ + unsigned int num_args; /*in*/ + Z3_ast const *args; /*in*/ + Z3_ast *v; /*out*/ + int _res; + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + mlsize_t _c1; + mlsize_t _c2; + value _v3; + Z3_ast _c4; + value _vresult; + value _vres[2] = { 0, 0, }; + + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3V3_Z3_model(_v_m, &m, _ctx); + camlidl_ml2c_z3V3_Z3_func_decl(_v_d, &d, _ctx); + _c1 = Wosize_val(_v_args); + args = camlidl_malloc(_c1 * sizeof(Z3_ast const ), _ctx); + for (_c2 = 0; _c2 < _c1; _c2++) { + _v3 = Field(_v_args, _c2); + camlidl_ml2c_z3V3_Z3_ast(_v3, &args[_c2], _ctx); + } + num_args = _c1; + v = &_c4; + _res = Z3_eval_decl(c, m, d, num_args, args, v); + Begin_roots_block(_vres, 2) + _vres[0] = Val_int(_res); + _vres[1] = camlidl_c2ml_z3V3_Z3_ast(&*v, _ctx); + _vresult = camlidl_alloc_small(2, 0); + Field(_vresult, 0) = _vres[0]; + Field(_vresult, 1) = _vres[1]; + End_roots() + camlidl_free(_ctx); + return _vresult; +} + +value camlidl_z3V3_Z3_context_to_string( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_context_to_string(c); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_statistics_to_string( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_string _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_statistics_to_string(c); + _vres = camlidl_c2ml_z3V3_Z3_string(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + +value camlidl_z3V3_Z3_get_context_assignment( + value _v_c) +{ + Z3_context c; /*in*/ + Z3_ast _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); + _res = Z3_get_context_assignment(c); + _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); + camlidl_free(_ctx); + return _vres; +} + diff --git a/ml/z3_theory_stubs.c b/ml/z3_theory_stubs.c new file mode 100644 index 000000000..d17a1790d --- /dev/null +++ b/ml/z3_theory_stubs.c @@ -0,0 +1,339 @@ +/*++ +Copyright (c) 2010 Microsoft Corporation + +Module Name: + + z3_theory_stubs.c + +Abstract: + + OCaml C bindings for callbacks between OCaml and C for + theory plugins. + The API for theory plugins require associating a set of + callbacks as C function pointers. + We use the following strategy: + + - store in the user_ext_data blob that theory constructors allow + a record of callback functions. + + - define catch-all static callback functions that access the + ML record with the callbacks. It then invokes these through user-registered + application functions that apply the callback stored in the record to the + actual parameters. + It is tempting to avoid this user-registered callback and directly access + the record of callback functions and apply the proper field. + However, the layout of records appears to be opaque, or at least we assume it is + so, from the C runtime. + +Author: + + +Revision History: +--*/ + +#include +#include +#include +#include +#include +#include +#include +#ifdef Custom_tag +#include +#include +#endif + +#include "z3.h" + +#define ML_SIZE(_ty) ((sizeof(_ty) + sizeof(value) - 1)/ sizeof(value)) + +static value mk_func_decl(Z3_func_decl f) { + value _f = alloc(ML_SIZE(Z3_func_decl), Abstract_tag); + *((Z3_func_decl*) Bp_val(_f)) = f; + return _f; +} + +static value Val_ast(Z3_ast a) { + value _a = alloc(ML_SIZE(Z3_ast), Abstract_tag); + *((Z3_ast*) Bp_val(_a)) = a; + return _a; +} + + +static value Val_ast_array(unsigned int sz, Z3_ast const args[]) { + value res; + Z3_ast* args1; + unsigned int i; + args1 = malloc((sz+1)*sizeof(Z3_ast)); + for (i = 0; i < sz; ++i) { + args1[i] = args[i]; + } + args1[sz] = 0; + res = alloc_array((value (*)(char const*))Val_ast, (const char**)args1); + free(args1); + return res; +} + +// ------------------ +// get_theory_callbacks +// + +value get_theory_callbacks(value th) +{ + Z3_theory _th = *((Z3_theory*) Bp_val(th)); + return (value) Z3_theory_get_ext_data(_th); +} + +// ------------------ +// delete_theory +// +static void delete_callback_static(Z3_theory th) +{ + CAMLparam0(); + CAMLlocal1(f); + value user_data = (value) Z3_theory_get_ext_data(th); + f = *(caml_named_value("apply_delete")) ; + callback(f, user_data); + remove_global_root(&user_data); + CAMLreturn0; +} + +#define SET_CALLBACK(_cb_name) \ + value set_ ## _cb_name ## _callback_register(value th) \ + { \ + CAMLparam1(th); \ + Z3_theory _th = *((Z3_theory*) Bp_val(th)); \ + Z3_set_ ## _cb_name ## _callback(_th, _cb_name ## _callback_static); \ + CAMLreturn(Val_unit); \ + } \ + +SET_CALLBACK(delete); + + +// ------------------ +// mk_theory +// + +value mk_theory_register(value context, value name, value user_data) +{ + CAMLparam3(context, name, user_data); + Z3_context _context = *((Z3_context *) Bp_val(context)); + value _th; + Z3_theory th; + register_global_root(&user_data); + th = Z3_mk_theory(_context, String_val(name), (void*)user_data); + // jjb: test th == NULL ? + Z3_set_delete_callback(th, delete_callback_static); + _th = alloc(ML_SIZE(Z3_context), Abstract_tag); + *((Z3_theory*) Bp_val(_th)) = th; + CAMLreturn(_th); +} + + +// ------------------- +// reduce_app_callback + +static Z3_bool reduce_app_callback_static(Z3_theory th, Z3_func_decl f, unsigned num_args, Z3_ast const args[], Z3_ast* r) { + CAMLparam0(); + CAMLlocal4(cb, _r, _v, _args); + value user_data; + Z3_bool result; + + _args = Val_ast_array(num_args, args); + + user_data = (value) Z3_theory_get_ext_data(th); + + cb = *(caml_named_value("apply_reduce_app")); + _r = callback3(cb, user_data, mk_func_decl(f), _args); + + cb = *(caml_named_value("is_some")); + _v = callback(cb, _r); + result = 0 != Bool_val(_v); + + if (result && r) { + cb = *(caml_named_value("get_some")); + _v = callback(cb, _r); + *r = *((Z3_ast*) Bp_val(_v)); + } + + CAMLreturn (result); +} + +SET_CALLBACK(reduce_app); + +// ------------------- +// reduce_eq_callback + +static Z3_bool reduce_eq_callback_static(Z3_theory th, Z3_ast a, Z3_ast b, Z3_ast * r) +{ + CAMLparam0(); + CAMLlocal5(cb, _r, _a, _b, _v); + value user_data; + Z3_bool result; + + _a = Val_ast(a); + _b = Val_ast(b); + + user_data = (value) Z3_theory_get_ext_data(th); + + cb = *(caml_named_value("apply_reduce_eq")); + _r = callback3(cb, user_data, _a, _b); + + cb = *(caml_named_value("is_some")); + _v = callback(cb, _r); + result = 0 != Bool_val(_v); + + if (result && r) { + cb = *(caml_named_value("get_some")); + _v = callback(cb, _r); + *r = *((Z3_ast*) Bp_val(_v)); + } + + CAMLreturn (result); +} + +SET_CALLBACK(reduce_eq); + + +// ------------------- +// reduce_distinct + +static Z3_bool reduce_distinct_callback_static(Z3_theory th, unsigned n, Z3_ast const args[], Z3_ast * r) +{ + CAMLparam0(); + CAMLlocal4(cb, _r, _args, _v); + value user_data; + Z3_bool result; + + _args = Val_ast_array(n, args); + + user_data = (value) Z3_theory_get_ext_data(th); + + cb = *(caml_named_value("apply_reduce_distinct")); + _r = callback2(cb, user_data, _args); + + cb = *(caml_named_value("is_some")); + _v = callback(cb, _r); + result = 0 != Bool_val(_v); + + if (result && r) { + cb = *(caml_named_value("get_some")); + _v = callback(cb, _r); + *r = *((Z3_ast*) Bp_val(_v)); + } + + CAMLreturn (result); +} + +SET_CALLBACK(reduce_distinct); + +// ------------------- +// new_app + +#define AST_CALLBACK(_cb_name) \ +static void _cb_name##_callback_static(Z3_theory th, Z3_ast a) \ +{ \ + CAMLparam0(); \ + CAMLlocal3(cb, _a, user_data); \ + _a = Val_ast(a); \ + user_data = (value) Z3_theory_get_ext_data(th); \ + cb = *(caml_named_value("apply_" #_cb_name)); \ + callback2(cb, user_data, _a); \ + CAMLreturn0; \ +} \ + +AST_CALLBACK(new_app); +SET_CALLBACK(new_app); + +// ------------------- +// new_elem + +AST_CALLBACK(new_elem); +SET_CALLBACK(new_elem); + +// ------------------- +// init_search + +#define TH_CALLBACK(_cb_name) \ +static void _cb_name##_callback_static(Z3_theory th) \ +{ \ + CAMLparam0(); \ + CAMLlocal2(cb, user_data); \ + user_data = (value) Z3_theory_get_ext_data(th); \ + cb = *(caml_named_value("apply_" #_cb_name)); \ + callback(cb, user_data); \ + CAMLreturn0; \ +} \ + +TH_CALLBACK(init_search); +SET_CALLBACK(init_search); + +// ------------------- +// push + +TH_CALLBACK(push); +SET_CALLBACK(push); + +TH_CALLBACK(pop); +SET_CALLBACK(pop); + +TH_CALLBACK(restart); +SET_CALLBACK(restart); + +TH_CALLBACK(reset); +SET_CALLBACK(reset); + + +#define FC_CALLBACK(_cb_name) \ + static Z3_bool _cb_name##_callback_static(Z3_theory th) \ + { \ + CAMLparam0(); \ + CAMLlocal3(cb, r, user_data); \ + user_data = (value) Z3_theory_get_ext_data(th); \ + cb = *(caml_named_value("apply_" #_cb_name)); \ + r = callback(cb, user_data); \ + CAMLreturn (Bool_val(r) != 0); \ + } \ + +FC_CALLBACK(final_check); +SET_CALLBACK(final_check); + +#define AST_AST_CALLBACK(_cb_name) \ + static void _cb_name##_callback_static(Z3_theory th, Z3_ast a, Z3_ast b) \ + { \ + CAMLparam0(); \ + CAMLlocal4(cb, _a, _b, user_data); \ + _a = Val_ast(a); \ + _b = Val_ast(b); \ + user_data = (value) Z3_theory_get_ext_data(th); \ + cb = *(caml_named_value("apply_" #_cb_name)); \ + callback3(cb, user_data, _a, _b); \ + CAMLreturn0; \ + } \ + +AST_AST_CALLBACK(new_eq); +SET_CALLBACK(new_eq); + +AST_AST_CALLBACK(new_diseq); +SET_CALLBACK(new_diseq); + +#define AST_BOOL_CALLBACK(_cb_name) \ + static void _cb_name##_callback_static(Z3_theory th, Z3_ast a, Z3_bool b) \ + { \ + CAMLparam0(); \ + CAMLlocal4(cb, _a, _b, user_data); \ + _a = Val_ast(a); \ + _b = Val_bool(b); \ + user_data = (value) Z3_theory_get_ext_data(th); \ + cb = *(caml_named_value("apply_" #_cb_name)); \ + callback3(cb, user_data, _a, _b); \ + CAMLreturn0; \ + } \ + + +AST_BOOL_CALLBACK(new_assignment); +SET_CALLBACK(new_assignment); + +AST_CALLBACK(new_relevant); +SET_CALLBACK(new_relevant); + diff --git a/python/mk_z3consts.py b/python/mk_z3consts.py new file mode 100644 index 000000000..8f26317a0 --- /dev/null +++ b/python/mk_z3consts.py @@ -0,0 +1,73 @@ +############################################ +# Copyright (c) 2012 Microsoft Corporation +# +# Extract enumeration types from z3_api.h +# +# Author: Leonardo de Moura (leonardo) +############################################ +import re + +blank_pat = re.compile("^ *$") +comment_pat = re.compile("^ *//.*$") +typedef_pat = re.compile("typedef enum *") +typedef2_pat = re.compile("typedef enum { *") +openbrace_pat = re.compile("{ *") +closebrace_pat = re.compile("}.*;") + +api = open('..\\lib\\z3_api.h', 'r') + +z3consts = open('z3consts.py', 'w') +z3consts.write('# Automatically generated file, generator: mk_z3consts.py\n\n') + +SEARCHING = 0 +FOUND_ENUM = 1 +IN_ENUM = 2 + +mode = SEARCHING +decls = {} +idx = 0 + +linenum = 1 +for line in api: + m1 = blank_pat.match(line) + m2 = comment_pat.match(line) + if m1 or m2: + # skip blank lines and comments + linenum = linenum + 1 + elif mode == SEARCHING: + m = typedef_pat.match(line) + if m: + mode = FOUND_ENUM + m = typedef2_pat.match(line) + if m: + mode = IN_ENUM + decls = {} + idx = 0 + elif mode == FOUND_ENUM: + m = openbrace_pat.match(line) + if m: + mode = IN_ENUM + decls = {} + idx = 0 + else: + assert False, "Invalid z3_api.h, line: %s" % linenum + else: + assert mode == IN_ENUM + words = re.split('[^\-a-zA-Z0-9_]+', line) + m = closebrace_pat.match(line) + if m: + name = words[1] + z3consts.write('# enum %s\n' % name) + for k, i in decls.iteritems(): + z3consts.write('%s = %s\n' % (k, i)) + z3consts.write('\n') + mode = SEARCHING + else: + if words[2] != '': + if len(words[2]) > 1 and words[2][1] == 'x': + idx = int(words[2], 16) + else: + idx = int(words[2]) + decls[words[1]] = idx + idx = idx + 1 + linenum = linenum + 1 diff --git a/python/mk_z3tactics.py b/python/mk_z3tactics.py new file mode 100644 index 000000000..c984c8a9f --- /dev/null +++ b/python/mk_z3tactics.py @@ -0,0 +1,38 @@ +############################################ +# Copyright (c) 2012 Microsoft Corporation +# +# Extract tactics and probes from install_tactics.cpp +# +# Author: Leonardo de Moura (leonardo) +############################################ +import re + +tactic_pat = re.compile("^[ \t]*ADD_TACTIC_CMD") +probe_pat = re.compile("^[ \t]*ADD_PROBE") + +cppfile = open('..\\lib\\install_tactics.cpp', 'r') + +z3tactics = open('z3tactics.py', 'w') +z3tactics.write('# Automatically generated file, generator: mk_z3tactics.py\n') +z3tactics.write('import z3core\n') +z3tactics.write('import z3\n\n') + + +for line in cppfile: + m1 = tactic_pat.match(line) + m2 = probe_pat.match(line) + if m1: + words = re.split('[^\-a-zA-Z0-9_]+', line) + tactic = words[2] + py_tactic = tactic.replace('-', '_') + z3tactics.write('def %s_tactic(ctx=None):\n' % py_tactic) + z3tactics.write(' ctx = z3._get_ctx(ctx)\n') + z3tactics.write(' return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), \'%s\'), ctx)\n\n' % tactic) + elif m2: + words = re.split('[^\-a-zA-Z0-9_]+', line) + probe = words[2] + py_probe = probe.replace('-', '_') + z3tactics.write('def %s_probe(ctx=None):\n' % py_probe) + z3tactics.write(' ctx = z3._get_ctx(ctx)\n') + z3tactics.write(' return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), \'%s\'), ctx)\n\n' % probe) + diff --git a/update_api.cmd b/update_api.cmd index d6d498d1b..1b2cc3151 100644 --- a/update_api.cmd +++ b/update_api.cmd @@ -1,17 +1,6 @@ -sd edit dll\z3.def -sd edit dll\z3_dbg.def -cd dll +pushd dll python mk_def.py -cd .. -sd edit Microsoft.Z3\native.cs -sd edit Microsoft.Z3\enumerations.cs -sd edit lib\api_log_macros.h -sd edit lib\api_log_macros.cpp -sd edit lib\api_commands.cpp -sd edit python\z3core.py -sd edit ml\z3.mli -sd edit ml\z3.ml -sd edit ml\z3_stubs.c +popd pushd lib python api.py popd @@ -19,12 +8,9 @@ pushd Microsoft.Z3 python mk_z3consts.py popd pushd python -sd edit z3consts.py python mk_z3consts.py -sd edit z3tactics.py python mk_z3tactics.py popd pushd ml call build.cmd 32 popd -sd revert -a ... \ No newline at end of file