From bcca613cb2b463d76b527cea734d364ac8b961c8 Mon Sep 17 00:00:00 2001 From: Leonardo de Moura Date: Tue, 2 Oct 2012 12:44:06 -0700 Subject: [PATCH] Added ml component Signed-off-by: Leonardo de Moura --- ml/add_error_checking.V3.sed | 2 + ml/add_error_checking.sed | 86 + ml/build.cmd | 55 + ml/build.sed | 82 + ml/clean.cmd | 13 + ml/cleantmp.cmd | 15 + ml/compile_mlapi.cmd | 95 + ml/diff.exe | Bin 0 -> 68096 bytes ml/error_handling.idl | 162 + ml/generate_mlapi.cmd | 69 + ml/import.cmd | 55 + ml/mlx_get_app_args.idl | 11 + ml/mlx_get_array_sort.idl | 11 + ml/mlx_get_datatype_sort.idl | 13 + ml/mlx_get_domains.idl | 11 + ml/mlx_get_error_msg.idl | 6 + ml/mlx_get_pattern_terms.idl | 11 + ml/mlx_get_tuple_sort.idl | 12 + ml/mlx_mk_context_x.idl | 36 + ml/mlx_mk_datatypes.idl | 28 + ml/mlx_mk_numeral.idl | 21 + ml/mlx_mk_sort.idl | 69 + ml/mlx_mk_symbol.idl | 22 + ml/mlx_model.idl | 19 + ml/mlx_numeral_refine.idl | 10 + ml/mlx_parse_smtlib.idl | 40 + ml/mlx_sort_refine.idl | 8 + ml/mlx_statistics.idl | 10 + ml/mlx_symbol_refine.idl | 8 + ml/mlx_term_refine.idl | 37 + ml/msbuild.proj | 72 + ml/queen.ml | 112 + ml/queen.regress.err | 0 ml/queen.regress.out | 1852 ++++ ml/readme.txt | 144 + ml/regress.cmd | 10 + ml/sed.exe | Bin 0 -> 82944 bytes ml/test_capi.regress.err | 5 + ml/test_capi.regress.out | 386 + ml/test_mlapi.cmd | 58 + ml/test_mlapi.ml | 209 + ml/test_mlapi.regress.err | 0 ml/test_mlapi.regress.out | 32 + ml/test_mlapiV3.ml | 1418 +++ ml/test_mlapiV3.regress.err | 5 + ml/test_mlapiV3.regress.out | 312 + ml/test_theory.ml | 42 + ml/update-ml-doc.cmd | 36 + ml/x3.ml | 366 + ml/x3V3.ml | 378 + ml/x3V3.mli | 361 + ml/z3.idl | 607 ++ ml/z3.ml | 3498 ++++++ ml/z3.mli | 9983 +++++++++++++++++ ml/z3.proj | 11 + ml/z3_stubs.c | 18966 +++++++++++++++++++++++++++++++++ ml/z3_theory_stubs.c | 339 + python/mk_z3consts.py | 73 + python/mk_z3tactics.py | 38 + update_api.cmd | 18 +- 60 files changed, 40332 insertions(+), 16 deletions(-) create mode 100644 ml/add_error_checking.V3.sed create mode 100644 ml/add_error_checking.sed create mode 100644 ml/build.cmd create mode 100644 ml/build.sed create mode 100644 ml/clean.cmd create mode 100644 ml/cleantmp.cmd create mode 100644 ml/compile_mlapi.cmd create mode 100644 ml/diff.exe create mode 100644 ml/error_handling.idl create mode 100644 ml/generate_mlapi.cmd create mode 100644 ml/import.cmd create mode 100644 ml/mlx_get_app_args.idl create mode 100644 ml/mlx_get_array_sort.idl create mode 100644 ml/mlx_get_datatype_sort.idl create mode 100644 ml/mlx_get_domains.idl create mode 100644 ml/mlx_get_error_msg.idl create mode 100644 ml/mlx_get_pattern_terms.idl create mode 100644 ml/mlx_get_tuple_sort.idl create mode 100644 ml/mlx_mk_context_x.idl create mode 100644 ml/mlx_mk_datatypes.idl create mode 100644 ml/mlx_mk_numeral.idl create mode 100644 ml/mlx_mk_sort.idl create mode 100644 ml/mlx_mk_symbol.idl create mode 100644 ml/mlx_model.idl create mode 100644 ml/mlx_numeral_refine.idl create mode 100644 ml/mlx_parse_smtlib.idl create mode 100644 ml/mlx_sort_refine.idl create mode 100644 ml/mlx_statistics.idl create mode 100644 ml/mlx_symbol_refine.idl create mode 100644 ml/mlx_term_refine.idl create mode 100644 ml/msbuild.proj create mode 100644 ml/queen.ml create mode 100644 ml/queen.regress.err create mode 100644 ml/queen.regress.out create mode 100644 ml/readme.txt create mode 100644 ml/regress.cmd create mode 100644 ml/sed.exe create mode 100644 ml/test_capi.regress.err create mode 100644 ml/test_capi.regress.out create mode 100644 ml/test_mlapi.cmd create mode 100644 ml/test_mlapi.ml create mode 100644 ml/test_mlapi.regress.err create mode 100644 ml/test_mlapi.regress.out create mode 100644 ml/test_mlapiV3.ml create mode 100644 ml/test_mlapiV3.regress.err create mode 100644 ml/test_mlapiV3.regress.out create mode 100644 ml/test_theory.ml create mode 100644 ml/update-ml-doc.cmd create mode 100644 ml/x3.ml create mode 100644 ml/x3V3.ml create mode 100644 ml/x3V3.mli create mode 100644 ml/z3.idl create mode 100644 ml/z3.ml create mode 100644 ml/z3.mli create mode 100644 ml/z3.proj create mode 100644 ml/z3_stubs.c create mode 100644 ml/z3_theory_stubs.c create mode 100644 python/mk_z3consts.py create mode 100644 python/mk_z3tactics.py 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 0000000000000000000000000000000000000000..2797ffd05d13c0cd59d28ab31b5d562f3e3c7987 GIT binary patch literal 68096 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 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 0000000000000000000000000000000000000000..75ffba78aeeecb41d86c6921ad5fe6d3c99fcf31 GIT binary patch literal 82944 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 literal 0 HcmV?d00001 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