mirror of
https://github.com/Z3Prover/z3
synced 2025-04-08 10:25:18 +00:00
Merge branch 'issue1379' of github.com:/mtrberzi/z3 into issue1379
This commit is contained in:
commit
fd6d9a9489
|
@ -33,7 +33,7 @@ endif()
|
|||
# Project version
|
||||
################################################################################
|
||||
set(Z3_VERSION_MAJOR 4)
|
||||
set(Z3_VERSION_MINOR 5)
|
||||
set(Z3_VERSION_MINOR 6)
|
||||
set(Z3_VERSION_PATCH 1)
|
||||
set(Z3_VERSION_TWEAK 0)
|
||||
set(Z3_VERSION "${Z3_VERSION_MAJOR}.${Z3_VERSION_MINOR}.${Z3_VERSION_PATCH}.${Z3_VERSION_TWEAK}")
|
||||
|
@ -257,6 +257,46 @@ list(APPEND Z3_COMPONENT_EXTRA_INCLUDE_DIRS
|
|||
"${CMAKE_BINARY_DIR}/src"
|
||||
"${CMAKE_SOURCE_DIR}/src"
|
||||
)
|
||||
|
||||
################################################################################
|
||||
# Linux specific configuration
|
||||
################################################################################
|
||||
if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
|
||||
# Try to detect if it is necessary to link against librt.
|
||||
# Note that glibc < 2.17 required librt to be linked to use clock_gettime()
|
||||
# and friends.
|
||||
set(CLOCK_GETTIME_REQUIRES_LIBRT_TEST_CODE
|
||||
"
|
||||
#include <time.h>
|
||||
int main() {
|
||||
timespec res;
|
||||
int result = clock_gettime(CLOCK_REALTIME, &res);
|
||||
return result == 0;
|
||||
}
|
||||
"
|
||||
)
|
||||
check_cxx_source_compiles(
|
||||
"${CLOCK_GETTIME_REQUIRES_LIBRT_TEST_CODE}"
|
||||
CLOCK_GETTIME_NO_REQUIRE_LIBRT
|
||||
)
|
||||
if (NOT CLOCK_GETTIME_NO_REQUIRE_LIBRT)
|
||||
# Try again with librt
|
||||
message(STATUS "Failed to link against clock_gettime(), trying with librt")
|
||||
set(CMAKE_REQUIRED_LIBRARIES_OLD "${CMAKE_REQUIRED_LIBRARIES}")
|
||||
set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES} rt")
|
||||
check_cxx_source_compiles(
|
||||
"${CLOCK_GETTIME_REQUIRES_LIBRT_TEST_CODE}"
|
||||
CLOCK_GETTIME_REQUIRES_LIBRT
|
||||
)
|
||||
set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES_OLD}")
|
||||
if (CLOCK_GETTIME_REQUIRES_LIBRT)
|
||||
list(APPEND Z3_DEPENDENT_LIBS "rt")
|
||||
else()
|
||||
message(FATAL_ERROR "Failed to link against clock_gettime()")
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
|
||||
################################################################################
|
||||
# GNU multiple precision library support
|
||||
################################################################################
|
||||
|
|
|
@ -5,7 +5,7 @@ of the project written in the ``CMakeLists.txt`` files and emits a build
|
|||
system for that project of your choice using one of CMake's "generators".
|
||||
This allows CMake to support many different platforms and build tools.
|
||||
You can run ``cmake --help`` to see the list of supported "generators"
|
||||
on your platform. Example generators include "UNIX Makfiles" and "Visual Studio
|
||||
on your platform. Example generators include "UNIX Makefiles" and "Visual Studio
|
||||
12 2013".
|
||||
|
||||
## Getting started
|
||||
|
@ -44,7 +44,7 @@ cmake -G "Unix Makefiles" ../
|
|||
make -j4 # Replace 4 with an appropriate number
|
||||
```
|
||||
|
||||
Note that on some platforms "Unix Makesfiles" is the default generator so on those
|
||||
Note that on some platforms "Unix Makefiles" is the default generator so on those
|
||||
platforms you don't need to pass ``-G "Unix Makefiles"`` command line option to
|
||||
``cmake``.
|
||||
|
||||
|
|
|
@ -1,7 +1,12 @@
|
|||
RELEASE NOTES
|
||||
|
||||
Version 4.5.x
|
||||
Version 4.6.0
|
||||
=============
|
||||
|
||||
- New requirements:
|
||||
- C++11 capable compiler to build Z3.
|
||||
- C++ API now requires C++11 or newer.
|
||||
|
||||
- New features (including):
|
||||
- A new string solver from University of Waterloo
|
||||
- A new linear real arithmetic solver
|
||||
|
@ -10,6 +15,10 @@ Version 4.5.x
|
|||
issuing the command (get-objectives). Pareto front objectives are accessed by
|
||||
issuing multiple (check-sat) calls until it returns unsat.
|
||||
|
||||
- Removed features:
|
||||
- Removed support for SMT-LIB 1.x
|
||||
|
||||
|
||||
Version 4.5.0
|
||||
=============
|
||||
|
||||
|
@ -45,10 +54,9 @@ Version 4.5.0
|
|||
over compound formulas, introduce a fresh predicate whose
|
||||
arguments are the relevant free variables in the formula and add a rule
|
||||
that uses the fresh predicate in the head and formula in the body.
|
||||
- minimization of unsat cores is avaialble as an option for the SAT and SMT cores.
|
||||
- Minimization of unsat cores is available as an option for the SAT and SMT cores.
|
||||
By setting smt.core.minimize=true resp. sat.core.minimize=true
|
||||
cores produced by these modules are minimized.
|
||||
|
||||
cores produced by these modules are minimized.
|
||||
|
||||
- A multitude of bugs has been fixed.
|
||||
|
||||
|
@ -419,11 +427,11 @@ Version 3.0
|
|||
|
||||
- New Bitvector (QF_BV) solver. The new solver is only available when using the new SMT2 front-end.
|
||||
|
||||
- Major performace improvements.
|
||||
- Major performance improvements.
|
||||
|
||||
- New preprocessing stack.
|
||||
|
||||
- Performance improvements for linear and nonlinear arithmetic. The improvements are only available when using the the SMT2 front-end.
|
||||
- Performance improvements for linear and nonlinear arithmetic. The improvements are only available when using the SMT2 front-end.
|
||||
|
||||
- Added API for parsing SMT2 files.
|
||||
|
||||
|
@ -704,7 +712,7 @@ The following bugs are fixed in this release:
|
|||
bvshl when using a shift amount that evaluates to the length
|
||||
of the bit-vector. Thanks to Trevor Hansen and Robert Brummayer.
|
||||
|
||||
- Incorrect NNF conversion in linear quantifier elimniation routines.
|
||||
- Incorrect NNF conversion in linear quantifier elimination routines.
|
||||
Thanks to Josh Berdine.
|
||||
|
||||
- Missing constant folding of extraction for large bit-vectors.
|
||||
|
@ -764,7 +772,7 @@ This release also introduces some new preprocessing features:
|
|||
|
||||
- More efficient destructive equality resolution DER=true.
|
||||
|
||||
- DISTRIBUTE_FORALL=true (distributes universal quatifiers over conjunctions, this transformation may affect pattern inference).
|
||||
- DISTRIBUTE_FORALL=true (distributes universal quantifiers over conjunctions, this transformation may affect pattern inference).
|
||||
|
||||
- Rewriter that uses universally quantified equations PRE_DEMODULATOR=true (yes, the option name is not good, we will change it in a future release).
|
||||
|
||||
|
@ -834,7 +842,7 @@ This release introduces the following features:
|
|||
|
||||
It fixes the following bugs:
|
||||
|
||||
- Incorrect simplification of map over store in the extendted array theory. Reported by Catalin Hritcu.
|
||||
- Incorrect simplification of map over store in the extended array theory. Reported by Catalin Hritcu.
|
||||
|
||||
- Incomplete handling of equality propagation with constant arrays. Reported by Catalin Hritcu.
|
||||
|
||||
|
@ -878,7 +886,7 @@ Version 2.0
|
|||
proof object.
|
||||
|
||||
- Proof Objects.
|
||||
The #Z3_check_assumptions retuns a proof object if
|
||||
The #Z3_check_assumptions returns a proof object if
|
||||
the configuration flag PROOF_MODE is set to 1 or 2.
|
||||
|
||||
- Partial support for non-linear arithmetic.
|
||||
|
@ -891,4 +899,4 @@ Version 2.0
|
|||
The theory of well-founded recursive data-types is supported
|
||||
over the binary APIs. It supports ground satisfiability checking
|
||||
for tuples, enumeration types (scalars),
|
||||
lists and mututally recursive data-types.
|
||||
lists and mutually recursive data-types.
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
# @AUTO_GEN_MSG@
|
||||
#
|
||||
# This file is intended to be consumed by clients who wish to use Z3 from CMake.
|
||||
# It can be use by doing `find_package(Z3 config)` from within a
|
||||
# It can be used by doing `find_package(Z3 config)` from within a
|
||||
# `CMakeLists.txt` file. If CMake doesn't find this package automatically you
|
||||
# can give it a hint by passing `-DZ3_DIR=<path>` to the CMake invocation where
|
||||
# `<path>` is the path to the directory containing this file.
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
# Sanitizer supression files
|
||||
# Sanitizer suppression files
|
||||
|
||||
This directory contains files used to suppress
|
||||
ASan/LSan/UBSan warnings/errors.
|
||||
|
|
|
@ -226,12 +226,14 @@ try:
|
|||
website_dox_substitutions = {}
|
||||
bullet_point_prefix='\n - '
|
||||
if Z3PY_ENABLED:
|
||||
print("Python documentation enabled")
|
||||
website_dox_substitutions['PYTHON_API'] = (
|
||||
'{prefix}<a class="el" href="namespacez3py.html">Python API</a> '
|
||||
'(also available in <a class="el" href="z3.html">pydoc format</a>)'
|
||||
).format(
|
||||
prefix=bullet_point_prefix)
|
||||
else:
|
||||
print("Python documentation disabled")
|
||||
website_dox_substitutions['PYTHON_API'] = ''
|
||||
if DOTNET_ENABLED:
|
||||
website_dox_substitutions['DOTNET_API'] = (
|
||||
|
@ -250,7 +252,7 @@ try:
|
|||
website_dox_substitutions['JAVA_API'] = ''
|
||||
if ML_ENABLED:
|
||||
website_dox_substitutions['OCAML_API'] = (
|
||||
'<a class="el" href="ml/index.html">ML/OCaml API</a>'
|
||||
'{prefix}<a class="el" href="ml/index.html">ML/OCaml API</a>'
|
||||
).format(
|
||||
prefix=bullet_point_prefix)
|
||||
else:
|
||||
|
@ -316,7 +318,7 @@ try:
|
|||
if ML_ENABLED:
|
||||
ml_output_dir = os.path.join(OUTPUT_DIRECTORY, 'html', 'ml')
|
||||
mk_dir(ml_output_dir)
|
||||
if subprocess.call(['ocamldoc', '-html', '-d', ml_output_dir, '-sort', '-hide', 'Z3', '-I', '%s/api/ml' % BUILD_DIR, doc_path('../src/api/ml/z3enums.mli'), doc_path('../src/api/ml/z3.mli')]) != 0:
|
||||
if subprocess.call(['ocamldoc', '-html', '-d', ml_output_dir, '-sort', '-hide', 'Z3', '-I', '%s/api/ml' % BUILD_DIR, '%s/api/ml/z3enums.mli' % BUILD_DIR, '%s/api/ml/z3.mli' % BUILD_DIR]) != 0:
|
||||
print("ERROR: ocamldoc failed.")
|
||||
exit(1)
|
||||
print("Generated ML/OCaml documentation.")
|
||||
|
@ -326,3 +328,4 @@ except Exception:
|
|||
exctype, value = sys.exc_info()[:2]
|
||||
print("ERROR: failed to generate documentation: %s" % value)
|
||||
exit(1)
|
||||
|
||||
|
|
|
@ -13,6 +13,22 @@ find_package(Z3
|
|||
# use this option.
|
||||
NO_DEFAULT_PATH
|
||||
)
|
||||
|
||||
################################################################################
|
||||
# Z3 C++ API bindings require C++11
|
||||
################################################################################
|
||||
if ("${CMAKE_VERSION}" VERSION_LESS "3.1")
|
||||
# Legacy CMake support
|
||||
if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
|
||||
else()
|
||||
message(FATAL_ERROR "Setting C++ version to C++11 not supported for \"${CMAKE_CXX_COMPILER_ID}\"")
|
||||
endif()
|
||||
else ()
|
||||
set(CMAKE_CXX_STANDARD 11)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
endif ()
|
||||
|
||||
message(STATUS "Z3_FOUND: ${Z3_FOUND}")
|
||||
message(STATUS "Found Z3 ${Z3_VERSION_STRING}")
|
||||
message(STATUS "Z3_DIR: ${Z3_DIR}")
|
||||
|
|
|
@ -1138,8 +1138,11 @@ static void parse_example() {
|
|||
decls.push_back(c.function("a", 0, 0, B));
|
||||
expr a = c.parse_string("(assert a)", sorts, decls);
|
||||
std::cout << a << "\n";
|
||||
|
||||
// expr b = c.parse_string("(benchmark tst :extrafuns ((x Int) (y Int)) :formula (> x y) :formula (> x 0))");
|
||||
}
|
||||
|
||||
|
||||
int main() {
|
||||
|
||||
try {
|
||||
|
|
|
@ -395,11 +395,10 @@ void assert_comm_axiom(Z3_context ctx, Z3_solver s, Z3_func_decl f)
|
|||
t_name = Z3_mk_string_symbol(ctx, "T");
|
||||
|
||||
|
||||
Z3_parse_smtlib_string(ctx,
|
||||
"(benchmark comm :formula (forall (x T) (y T) (= (f x y) (f y x))))",
|
||||
q = Z3_parse_smtlib2_string(ctx,
|
||||
"(assert (forall ((x T) (y T)) (= (f x y) (f y x))))",
|
||||
1, &t_name, &t,
|
||||
1, &f_name, &f);
|
||||
q = Z3_get_smtlib_formula(ctx, 0);
|
||||
printf("assert axiom:\n%s\n", Z3_ast_to_string(ctx, q));
|
||||
Z3_solver_assert(ctx, s, q);
|
||||
}
|
||||
|
@ -1547,7 +1546,7 @@ void two_contexts_example1()
|
|||
}
|
||||
|
||||
/**
|
||||
\brief Demonstrates how error codes can be read insted of registering an error handler.
|
||||
\brief Demonstrates how error codes can be read instead of registering an error handler.
|
||||
*/
|
||||
void error_code_example1()
|
||||
{
|
||||
|
@ -1632,35 +1631,6 @@ void error_code_example2() {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
\brief Demonstrates how to use the SMTLIB parser.
|
||||
*/
|
||||
void parser_example1()
|
||||
{
|
||||
Z3_context ctx = mk_context();
|
||||
Z3_solver s = mk_solver(ctx);
|
||||
unsigned i, num_formulas;
|
||||
|
||||
printf("\nparser_example1\n");
|
||||
LOG_MSG("parser_example1");
|
||||
|
||||
|
||||
Z3_parse_smtlib_string(ctx,
|
||||
"(benchmark tst :extrafuns ((x Int) (y Int)) :formula (> x y) :formula (> x 0))",
|
||||
0, 0, 0,
|
||||
0, 0, 0);
|
||||
num_formulas = Z3_get_smtlib_num_formulas(ctx);
|
||||
for (i = 0; i < num_formulas; i++) {
|
||||
Z3_ast f = Z3_get_smtlib_formula(ctx, i);
|
||||
printf("formula %d: %s\n", i, Z3_ast_to_string(ctx, f));
|
||||
Z3_solver_assert(ctx, s, f);
|
||||
}
|
||||
|
||||
check(ctx, s, Z3_L_TRUE);
|
||||
|
||||
del_solver(ctx, s);
|
||||
Z3_del_context(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
\brief Demonstrates how to initialize the parser symbol table.
|
||||
|
@ -1690,12 +1660,11 @@ void parser_example2()
|
|||
names[0] = Z3_mk_string_symbol(ctx, "a");
|
||||
names[1] = Z3_mk_string_symbol(ctx, "b");
|
||||
|
||||
Z3_parse_smtlib_string(ctx,
|
||||
"(benchmark tst :formula (> a b))",
|
||||
f = Z3_parse_smtlib2_string(ctx,
|
||||
"(assert (> a b))",
|
||||
0, 0, 0,
|
||||
/* 'x' and 'y' declarations are inserted as 'a' and 'b' into the parser symbol table. */
|
||||
2, names, decls);
|
||||
f = Z3_get_smtlib_formula(ctx, 0);
|
||||
printf("formula: %s\n", Z3_ast_to_string(ctx, f));
|
||||
Z3_solver_assert(ctx, s, f);
|
||||
check(ctx, s, Z3_L_TRUE);
|
||||
|
@ -1737,11 +1706,10 @@ void parser_example3()
|
|||
|
||||
assert_comm_axiom(ctx, s, g);
|
||||
|
||||
Z3_parse_smtlib_string(ctx,
|
||||
"(benchmark tst :formula (forall (x Int) (y Int) (implies (= x y) (= (g x 0) (g 0 y)))))",
|
||||
thm = Z3_parse_smtlib2_string(ctx,
|
||||
"(assert (forall ((x Int) (y Int)) (=> (= x y) (= (g x 0) (g 0 y)))))",
|
||||
0, 0, 0,
|
||||
1, &g_name, &g);
|
||||
thm = Z3_get_smtlib_formula(ctx, 0);
|
||||
printf("formula: %s\n", Z3_ast_to_string(ctx, thm));
|
||||
prove(ctx, s, thm, Z3_TRUE);
|
||||
|
||||
|
@ -1749,41 +1717,6 @@ void parser_example3()
|
|||
Z3_del_context(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
\brief Display the declarations, assumptions and formulas in a SMT-LIB string.
|
||||
*/
|
||||
void parser_example4()
|
||||
{
|
||||
Z3_context ctx;
|
||||
unsigned i, num_decls, num_assumptions, num_formulas;
|
||||
|
||||
printf("\nparser_example4\n");
|
||||
LOG_MSG("parser_example4");
|
||||
|
||||
ctx = mk_context();
|
||||
|
||||
Z3_parse_smtlib_string(ctx,
|
||||
"(benchmark tst :extrafuns ((x Int) (y Int)) :assumption (= x 20) :formula (> x y) :formula (> x 0))",
|
||||
0, 0, 0,
|
||||
0, 0, 0);
|
||||
num_decls = Z3_get_smtlib_num_decls(ctx);
|
||||
for (i = 0; i < num_decls; i++) {
|
||||
Z3_func_decl d = Z3_get_smtlib_decl(ctx, i);
|
||||
printf("declaration %d: %s\n", i, Z3_func_decl_to_string(ctx, d));
|
||||
}
|
||||
num_assumptions = Z3_get_smtlib_num_assumptions(ctx);
|
||||
for (i = 0; i < num_assumptions; i++) {
|
||||
Z3_ast a = Z3_get_smtlib_assumption(ctx, i);
|
||||
printf("assumption %d: %s\n", i, Z3_ast_to_string(ctx, a));
|
||||
}
|
||||
num_formulas = Z3_get_smtlib_num_formulas(ctx);
|
||||
for (i = 0; i < num_formulas; i++) {
|
||||
Z3_ast f = Z3_get_smtlib_formula(ctx, i);
|
||||
printf("formula %d: %s\n", i, Z3_ast_to_string(ctx, f));
|
||||
}
|
||||
Z3_del_context(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
\brief Demonstrates how to handle parser errors using Z3 error handling support.
|
||||
*/
|
||||
|
@ -1802,9 +1735,9 @@ void parser_example5() {
|
|||
s = mk_solver(ctx);
|
||||
Z3_del_config(cfg);
|
||||
|
||||
Z3_parse_smtlib_string(ctx,
|
||||
Z3_parse_smtlib2_string(ctx,
|
||||
/* the following string has a parsing error: missing parenthesis */
|
||||
"(benchmark tst :extrafuns ((x Int (y Int)) :formula (> x y) :formula (> x 0))",
|
||||
"(declare-const x Int) declare-const y Int) (assert (and (> x y) (> x 0)))",
|
||||
0, 0, 0,
|
||||
0, 0, 0);
|
||||
e = Z3_get_error_code(ctx);
|
||||
|
@ -1817,7 +1750,7 @@ void parser_example5() {
|
|||
err:
|
||||
printf("Z3 error: %s.\n", Z3_get_error_msg(ctx, e));
|
||||
if (ctx != NULL) {
|
||||
printf("Error message: '%s'.\n",Z3_get_smtlib_error(ctx));
|
||||
printf("Error message: '%s'.\n",Z3_get_parser_error(ctx));
|
||||
del_solver(ctx, s);
|
||||
Z3_del_context(ctx);
|
||||
}
|
||||
|
@ -2600,7 +2533,7 @@ void reference_counter_example() {
|
|||
|
||||
cfg = Z3_mk_config();
|
||||
Z3_set_param_value(cfg, "model", "true");
|
||||
// Create a Z3 context where the user is reponsible for managing
|
||||
// Create a Z3 context where the user is responsible for managing
|
||||
// Z3_ast reference counters.
|
||||
ctx = Z3_mk_context_rc(cfg);
|
||||
Z3_del_config(cfg);
|
||||
|
@ -3065,10 +2998,8 @@ int main() {
|
|||
two_contexts_example1();
|
||||
error_code_example1();
|
||||
error_code_example2();
|
||||
parser_example1();
|
||||
parser_example2();
|
||||
parser_example3();
|
||||
parser_example4();
|
||||
parser_example5();
|
||||
numeral_example();
|
||||
ite_example();
|
||||
|
|
|
@ -173,10 +173,9 @@ namespace test_mapi
|
|||
throw new Exception("function must be binary, and argument types must be equal to return type");
|
||||
}
|
||||
|
||||
string bench = string.Format("(benchmark comm :formula (forall (x {0}) (y {1}) (= ({2} x y) ({3} y x))))",
|
||||
string bench = string.Format("(assert (forall ((x {0}) (y {1})) (= ({2} x y) ({3} y x))))",
|
||||
t.Name, t.Name, f.Name, f.Name);
|
||||
ctx.ParseSMTLIBString(bench, new Symbol[] { t.Name }, new Sort[] { t }, new Symbol[] { f.Name }, new FuncDecl[] { f });
|
||||
return ctx.SMTLIBFormulas[0];
|
||||
return ctx.ParseSMTLIB2String(bench, new Symbol[] { t.Name }, new Sort[] { t }, new Symbol[] { f.Name }, new FuncDecl[] { f });
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
@ -623,7 +622,7 @@ namespace test_mapi
|
|||
Console.WriteLine("{0}", q1);
|
||||
}
|
||||
|
||||
// Quantifier with de-Brujin indices.
|
||||
// Quantifier with de-Bruijn indices.
|
||||
{
|
||||
Expr x = ctx.MkBound(1, ctx.IntSort);
|
||||
Expr y = ctx.MkBound(0, ctx.IntSort);
|
||||
|
@ -965,21 +964,6 @@ namespace test_mapi
|
|||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Shows how to read an SMT1 file.
|
||||
/// </summary>
|
||||
static void SMT1FileTest(string filename)
|
||||
{
|
||||
Console.Write("SMT File test ");
|
||||
|
||||
using (Context ctx = new Context(new Dictionary<string, string>() { { "MODEL", "true" } }))
|
||||
{
|
||||
ctx.ParseSMTLIBFile(filename);
|
||||
|
||||
BoolExpr a = ctx.MkAnd(ctx.SMTLIBFormulas);
|
||||
Console.WriteLine("read formula: " + a);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Shows how to read an SMT2 file.
|
||||
|
@ -1399,11 +1383,10 @@ namespace test_mapi
|
|||
{
|
||||
Console.WriteLine("ParserExample1");
|
||||
|
||||
ctx.ParseSMTLIBString("(benchmark tst :extrafuns ((x Int) (y Int)) :formula (> x y) :formula (> x 0))");
|
||||
foreach (BoolExpr f in ctx.SMTLIBFormulas)
|
||||
Console.WriteLine("formula {0}", f);
|
||||
var fml = ctx.ParseSMTLIB2String("(declare-const x Int) (declare-const y Int) (assert (> x y)) (assert (> x 0))");
|
||||
Console.WriteLine("formula {0}", fml);
|
||||
|
||||
Model m = Check(ctx, ctx.MkAnd(ctx.SMTLIBFormulas), Status.SATISFIABLE);
|
||||
Model m = Check(ctx, fml, Status.SATISFIABLE);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
@ -1412,15 +1395,11 @@ namespace test_mapi
|
|||
public static void ParserExample2(Context ctx)
|
||||
{
|
||||
Console.WriteLine("ParserExample2");
|
||||
|
||||
Symbol[] declNames = { ctx.MkSymbol("a"), ctx.MkSymbol("b") };
|
||||
FuncDecl a = ctx.MkConstDecl(declNames[0], ctx.MkIntSort());
|
||||
FuncDecl b = ctx.MkConstDecl(declNames[1], ctx.MkIntSort());
|
||||
FuncDecl[] decls = new FuncDecl[] { a, b };
|
||||
|
||||
ctx.ParseSMTLIBString("(benchmark tst :formula (> a b))",
|
||||
null, null, declNames, decls);
|
||||
BoolExpr f = ctx.SMTLIBFormulas[0];
|
||||
BoolExpr f = ctx.ParseSMTLIB2String("(assert (> a b))", null, null, declNames, decls);
|
||||
Console.WriteLine("formula: {0}", f);
|
||||
Check(ctx, f, Status.SATISFIABLE);
|
||||
}
|
||||
|
@ -1438,39 +1417,15 @@ namespace test_mapi
|
|||
|
||||
BoolExpr ca = CommAxiom(ctx, g);
|
||||
|
||||
ctx.ParseSMTLIBString("(benchmark tst :formula (forall (x Int) (y Int) (implies (= x y) (= (gg x 0) (gg 0 y)))))",
|
||||
BoolExpr thm = ctx.ParseSMTLIB2String("(assert (forall ((x Int) (y Int)) (=> (= x y) (= (gg x 0) (gg 0 y)))))",
|
||||
null, null,
|
||||
new Symbol[] { ctx.MkSymbol("gg") },
|
||||
new FuncDecl[] { g });
|
||||
|
||||
BoolExpr thm = ctx.SMTLIBFormulas[0];
|
||||
Console.WriteLine("formula: {0}", thm);
|
||||
Prove(ctx, thm, false, ca);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Display the declarations, assumptions and formulas in a SMT-LIB string.
|
||||
/// </summary>
|
||||
public static void ParserExample4(Context ctx)
|
||||
{
|
||||
Console.WriteLine("ParserExample4");
|
||||
|
||||
ctx.ParseSMTLIBString
|
||||
("(benchmark tst :extrafuns ((x Int) (y Int)) :assumption (= x 20) :formula (> x y) :formula (> x 0))");
|
||||
foreach (var decl in ctx.SMTLIBDecls)
|
||||
{
|
||||
Console.WriteLine("Declaration: {0}", decl);
|
||||
}
|
||||
foreach (var f in ctx.SMTLIBAssumptions)
|
||||
{
|
||||
Console.WriteLine("Assumption: {0}", f);
|
||||
}
|
||||
foreach (var f in ctx.SMTLIBFormulas)
|
||||
{
|
||||
Console.WriteLine("Formula: {0}", f);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Demonstrates how to handle parser errors using Z3 error handling support.
|
||||
/// </summary>
|
||||
|
@ -1481,9 +1436,9 @@ namespace test_mapi
|
|||
|
||||
try
|
||||
{
|
||||
ctx.ParseSMTLIBString(
|
||||
ctx.ParseSMTLIB2String(
|
||||
/* the following string has a parsing error: missing parenthesis */
|
||||
"(benchmark tst :extrafuns ((x Int (y Int)) :formula (> x y) :formula (> x 0))");
|
||||
"(declare-const x Int (declare-const y Int)) (assert (> x y))");
|
||||
}
|
||||
catch (Z3Exception e)
|
||||
{
|
||||
|
@ -1990,7 +1945,7 @@ namespace test_mapi
|
|||
BoolExpr p2 = ctx.MkBoolConst("P2");
|
||||
BoolExpr p3 = ctx.MkBoolConst("P3");
|
||||
BoolExpr p4 = ctx.MkBoolConst("P4");
|
||||
BoolExpr[] assumptions = new BoolExpr[] { ctx.MkNot(p1), ctx.MkNot(p2), ctx.MkNot(p3), ctx.MkNot(p4) };
|
||||
Expr[] assumptions = new Expr[] { ctx.MkNot(p1), ctx.MkNot(p2), ctx.MkNot(p3), ctx.MkNot(p4) };
|
||||
BoolExpr f1 = ctx.MkAnd(new BoolExpr[] { pa, pb, pc });
|
||||
BoolExpr f2 = ctx.MkAnd(new BoolExpr[] { pa, ctx.MkNot(pb), pc });
|
||||
BoolExpr f3 = ctx.MkOr(ctx.MkNot(pa), ctx.MkNot(pc));
|
||||
|
@ -2213,7 +2168,6 @@ namespace test_mapi
|
|||
BitvectorExample2(ctx);
|
||||
ParserExample1(ctx);
|
||||
ParserExample2(ctx);
|
||||
ParserExample4(ctx);
|
||||
ParserExample5(ctx);
|
||||
ITEExample(ctx);
|
||||
EvalExample1(ctx);
|
||||
|
|
|
@ -170,10 +170,9 @@ class JavaExample
|
|||
String bench = "(benchmark comm :formula (forall (x " + t.getName()
|
||||
+ ") (y " + t.getName() + ") (= (" + f.getName() + " x y) ("
|
||||
+ f.getName() + " y x))))";
|
||||
ctx.parseSMTLIBString(bench, new Symbol[] { t.getName() },
|
||||
return ctx.parseSMTLIB2String(bench, new Symbol[] { t.getName() },
|
||||
new Sort[] { t }, new Symbol[] { f.getName() },
|
||||
new FuncDecl[] { f });
|
||||
return ctx.getSMTLIBFormulas()[0];
|
||||
}
|
||||
|
||||
// / "Hello world" example: create a Z3 logical context, and delete it.
|
||||
|
@ -661,7 +660,7 @@ class JavaExample
|
|||
System.out.println(q1);
|
||||
}
|
||||
|
||||
// Quantifier with de-Brujin indices.
|
||||
// Quantifier with de-Bruijn indices.
|
||||
{
|
||||
Expr x = ctx.mkBound(1, ctx.getIntSort());
|
||||
Expr y = ctx.mkBound(0, ctx.getIntSort());
|
||||
|
@ -1028,21 +1027,6 @@ class JavaExample
|
|||
}
|
||||
}
|
||||
|
||||
// / Shows how to read an SMT1 file.
|
||||
|
||||
void smt1FileTest(String filename)
|
||||
{
|
||||
System.out.print("SMT File test ");
|
||||
|
||||
{
|
||||
HashMap<String, String> cfg = new HashMap<String, String>();
|
||||
Context ctx = new Context(cfg);
|
||||
ctx.parseSMTLIBFile(filename, null, null, null, null);
|
||||
|
||||
BoolExpr a = ctx.mkAnd(ctx.getSMTLIBFormulas());
|
||||
System.out.println("read formula: " + a);
|
||||
}
|
||||
}
|
||||
|
||||
// / Shows how to read an SMT2 file.
|
||||
|
||||
|
@ -1459,15 +1443,13 @@ class JavaExample
|
|||
System.out.println("ParserExample1");
|
||||
Log.append("ParserExample1");
|
||||
|
||||
ctx.parseSMTLIBString(
|
||||
"(benchmark tst :extrafuns ((x Int) (y Int)) :formula (> x y) :formula (> x 0))",
|
||||
BoolExpr f = ctx.parseSMTLIB2String(
|
||||
"(declare-const x Int) (declare-const y Int) (assert (and (> x y) (> x 0)))",
|
||||
null, null, null, null);
|
||||
for (BoolExpr f : ctx.getSMTLIBFormulas())
|
||||
System.out.println("formula " + f);
|
||||
System.out.println("formula " + f);
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
Model m = check(ctx, ctx.mkAnd(ctx.getSMTLIBFormulas()),
|
||||
Status.SATISFIABLE);
|
||||
Model m = check(ctx, f, Status.SATISFIABLE);
|
||||
}
|
||||
|
||||
// / Demonstrates how to initialize the parser symbol table.
|
||||
|
@ -1482,9 +1464,8 @@ class JavaExample
|
|||
FuncDecl b = ctx.mkConstDecl(declNames[1], ctx.mkIntSort());
|
||||
FuncDecl[] decls = new FuncDecl[] { a, b };
|
||||
|
||||
ctx.parseSMTLIBString("(benchmark tst :formula (> a b))", null, null,
|
||||
BoolExpr f = ctx.parseSMTLIB2String("(assert (> a b))", null, null,
|
||||
declNames, decls);
|
||||
BoolExpr f = ctx.getSMTLIBFormulas()[0];
|
||||
System.out.println("formula: " + f);
|
||||
check(ctx, f, Status.SATISFIABLE);
|
||||
}
|
||||
|
@ -1502,39 +1483,14 @@ class JavaExample
|
|||
|
||||
BoolExpr ca = commAxiom(ctx, g);
|
||||
|
||||
ctx.parseSMTLIBString(
|
||||
"(benchmark tst :formula (forall (x Int) (y Int) (implies (= x y) (= (gg x 0) (gg 0 y)))))",
|
||||
BoolExpr thm = ctx.parseSMTLIB2String(
|
||||
"(assert (forall ((x Int) (y Int)) (=> (= x y) (= (gg x 0) (gg 0 y)))))",
|
||||
null, null, new Symbol[] { ctx.mkSymbol("gg") },
|
||||
new FuncDecl[] { g });
|
||||
|
||||
BoolExpr thm = ctx.getSMTLIBFormulas()[0];
|
||||
System.out.println("formula: " + thm);
|
||||
prove(ctx, thm, false, ca);
|
||||
}
|
||||
|
||||
// / Display the declarations, assumptions and formulas in a SMT-LIB string.
|
||||
|
||||
public void parserExample4(Context ctx)
|
||||
{
|
||||
System.out.println("ParserExample4");
|
||||
Log.append("ParserExample4");
|
||||
|
||||
ctx.parseSMTLIBString(
|
||||
"(benchmark tst :extrafuns ((x Int) (y Int)) :assumption (= x 20) :formula (> x y) :formula (> x 0))",
|
||||
null, null, null, null);
|
||||
for (FuncDecl decl : ctx.getSMTLIBDecls())
|
||||
{
|
||||
System.out.println("Declaration: " + decl);
|
||||
}
|
||||
for (BoolExpr f : ctx.getSMTLIBAssumptions())
|
||||
{
|
||||
System.out.println("Assumption: " + f);
|
||||
}
|
||||
for (BoolExpr f : ctx.getSMTLIBFormulas())
|
||||
{
|
||||
System.out.println("Formula: " + f);
|
||||
}
|
||||
}
|
||||
|
||||
// / Demonstrates how to handle parser errors using Z3 error handling
|
||||
// support.
|
||||
|
@ -1546,12 +1502,12 @@ class JavaExample
|
|||
|
||||
try
|
||||
{
|
||||
ctx.parseSMTLIBString(
|
||||
ctx.parseSMTLIB2String(
|
||||
/*
|
||||
* the following string has a parsing error: missing
|
||||
* parenthesis
|
||||
*/
|
||||
"(benchmark tst :extrafuns ((x Int (y Int)) :formula (> x y) :formula (> x 0))",
|
||||
"(declare-const x Int (declare-const y Int)) (assert (> x y))",
|
||||
null, null, null, null);
|
||||
} catch (Z3Exception e)
|
||||
{
|
||||
|
@ -2341,7 +2297,6 @@ class JavaExample
|
|||
p.bitvectorExample2(ctx);
|
||||
p.parserExample1(ctx);
|
||||
p.parserExample2(ctx);
|
||||
p.parserExample4(ctx);
|
||||
p.parserExample5(ctx);
|
||||
p.iteExample(ctx);
|
||||
p.evalExample1(ctx);
|
||||
|
|
|
@ -9,4 +9,4 @@ On OSX and Linux, you must install z3 first using
|
|||
sudo make install
|
||||
OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (OSX) with the build directory. You need that to be able to find the Z3 shared library.
|
||||
|
||||
This directory contains a test file (ex.smt) that can be use as input for the maxsat test application.
|
||||
This directory contains a test file (ex.smt) that can be used as input for the maxsat test application.
|
||||
|
|
|
@ -1,11 +1,11 @@
|
|||
(benchmark ex
|
||||
:logic AUFLIA
|
||||
:extrafuns ((x Int) (y Int) (z Int))
|
||||
:assumption (> x 0)
|
||||
:assumption (<= x -1)
|
||||
:assumption (or (> x 0) (< y 1))
|
||||
:assumption (> y 2)
|
||||
:assumption (> y 3)
|
||||
:assumption (<= y -1)
|
||||
:formula (= z (+ x y)))
|
||||
(declare-const x Int)
|
||||
(declare-const y Int)
|
||||
(declare-const z Int)
|
||||
(assert-soft (> x 0))
|
||||
(assert-soft (<= x -1))
|
||||
(assert-soft (or (> x 0) (< y 1)))
|
||||
(assert-soft (> y 2))
|
||||
(assert-soft (> y 3))
|
||||
(assert-soft (<= y -1))
|
||||
(assert (= z (+ x y)))
|
||||
|
|
@ -116,41 +116,6 @@ Z3_ast mk_binary_and(Z3_context ctx, Z3_ast in_1, Z3_ast in_2)
|
|||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get hard constraints from a SMT-LIB file. We assume hard constraints
|
||||
are formulas preceeded with the keyword :formula.
|
||||
Return an array containing all formulas read by the last Z3_parse_smtlib_file invocation.
|
||||
It will store the number of formulas in num_cnstrs.
|
||||
*/
|
||||
Z3_ast * get_hard_constraints(Z3_context ctx, unsigned * num_cnstrs)
|
||||
{
|
||||
Z3_ast * result;
|
||||
unsigned i;
|
||||
*num_cnstrs = Z3_get_smtlib_num_formulas(ctx);
|
||||
result = (Z3_ast *) malloc(sizeof(Z3_ast) * (*num_cnstrs));
|
||||
for (i = 0; i < *num_cnstrs; i++) {
|
||||
result[i] = Z3_get_smtlib_formula(ctx, i);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
\brief Get soft constraints from a SMT-LIB file. We assume soft constraints
|
||||
are formulas preceeded with the keyword :assumption.
|
||||
Return an array containing all assumptions read by the last Z3_parse_smtlib_file invocation.
|
||||
It will store the number of formulas in num_cnstrs.
|
||||
*/
|
||||
Z3_ast * get_soft_constraints(Z3_context ctx, unsigned * num_cnstrs)
|
||||
{
|
||||
Z3_ast * result;
|
||||
unsigned i;
|
||||
*num_cnstrs = Z3_get_smtlib_num_assumptions(ctx);
|
||||
result = (Z3_ast *) malloc(sizeof(Z3_ast) * (*num_cnstrs));
|
||||
for (i = 0; i < *num_cnstrs; i++) {
|
||||
result[i] = Z3_get_smtlib_assumption(ctx, i);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
\brief Free the given array of cnstrs that was allocated using get_hard_constraints or get_soft_constraints.
|
||||
|
@ -610,14 +575,37 @@ int smtlib_maxsat(char * file_name, int approach)
|
|||
{
|
||||
Z3_context ctx;
|
||||
Z3_solver s;
|
||||
unsigned i;
|
||||
Z3_optimize opt;
|
||||
unsigned num_hard_cnstrs, num_soft_cnstrs;
|
||||
Z3_ast * hard_cnstrs, * soft_cnstrs;
|
||||
Z3_ast_vector hard, objs;
|
||||
Z3_app soft;
|
||||
unsigned result = 0;
|
||||
ctx = mk_context();
|
||||
s = mk_solver(ctx);
|
||||
Z3_parse_smtlib_file(ctx, file_name, 0, 0, 0, 0, 0, 0);
|
||||
hard_cnstrs = get_hard_constraints(ctx, &num_hard_cnstrs);
|
||||
soft_cnstrs = get_soft_constraints(ctx, &num_soft_cnstrs);
|
||||
opt = Z3_mk_optimize(ctx);
|
||||
Z3_optimize_inc_ref(ctx, opt);
|
||||
Z3_optimize_from_file(ctx, opt, file_name);
|
||||
hard = Z3_optimize_get_assertions(ctx, opt);
|
||||
Z3_ast_vector_inc_ref(ctx, hard);
|
||||
num_hard_cnstrs = Z3_ast_vector_size(ctx, hard);
|
||||
hard_cnstrs = (Z3_ast *) malloc(sizeof(Z3_ast) * (num_hard_cnstrs));
|
||||
for (i = 0; i < num_hard_cnstrs; i++) {
|
||||
hard_cnstrs[i] = Z3_ast_vector_get(ctx, hard, i);
|
||||
}
|
||||
objs = Z3_optimize_get_objectives(ctx, opt);
|
||||
Z3_ast_vector_inc_ref(ctx, objs);
|
||||
|
||||
// soft constraints are stored in a single objective which is a sum
|
||||
// of if-then-else expressions.
|
||||
soft = Z3_to_app(ctx, Z3_ast_vector_get(ctx, objs, 0));
|
||||
num_soft_cnstrs = Z3_get_app_num_args(ctx, soft);
|
||||
soft_cnstrs = (Z3_ast *) malloc(sizeof(Z3_ast) * (num_soft_cnstrs));
|
||||
for (i = 0; i < num_soft_cnstrs; ++i) {
|
||||
soft_cnstrs[i] = Z3_get_app_arg(ctx, Z3_to_app(ctx, Z3_get_app_arg(ctx, soft, i)), 0);
|
||||
}
|
||||
|
||||
switch (approach) {
|
||||
case NAIVE_MAXSAT:
|
||||
result = naive_maxsat(ctx, s, num_hard_cnstrs, hard_cnstrs, num_soft_cnstrs, soft_cnstrs);
|
||||
|
@ -633,6 +621,7 @@ int smtlib_maxsat(char * file_name, int approach)
|
|||
free_cnstr_array(hard_cnstrs);
|
||||
free_cnstr_array(soft_cnstrs);
|
||||
Z3_solver_dec_ref(ctx, s);
|
||||
Z3_optimize_dec_ref(ctx, opt);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
|
@ -9,7 +9,7 @@ from mk_util import *
|
|||
|
||||
# Z3 Project definition
|
||||
def init_project_def():
|
||||
set_version(4, 5, 1, 0)
|
||||
set_version(4, 6, 1, 0)
|
||||
add_lib('util', [])
|
||||
add_lib('lp', ['util'], 'util/lp')
|
||||
add_lib('polynomial', ['util'], 'math/polynomial')
|
||||
|
@ -75,10 +75,9 @@ def init_project_def():
|
|||
add_lib('smtlogic_tactics', ['ackermannization', 'sat_solver', 'arith_tactics', 'bv_tactics', 'nlsat_tactic', 'smt_tactic', 'aig_tactic', 'fp', 'muz','qe','nlsat_smt_tactic'], 'tactic/smtlogics')
|
||||
add_lib('fpa_tactics', ['fpa', 'core_tactics', 'bv_tactics', 'sat_tactic', 'smt_tactic', 'arith_tactics', 'smtlogic_tactics'], 'tactic/fpa')
|
||||
add_lib('portfolio', ['smtlogic_tactics', 'sat_solver', 'ufbv_tactic', 'fpa_tactics', 'aig_tactic', 'fp', 'qe','sls_tactic', 'subpaving_tactic'], 'tactic/portfolio')
|
||||
add_lib('smtparser', ['portfolio'], 'parsers/smt')
|
||||
add_lib('opt', ['smt', 'smtlogic_tactics', 'sls_tactic', 'sat_solver'], 'opt')
|
||||
API_files = ['z3_api.h', 'z3_ast_containers.h', 'z3_algebraic.h', 'z3_polynomial.h', 'z3_rcf.h', 'z3_fixedpoint.h', 'z3_optimization.h', 'z3_interp.h', 'z3_fpa.h', 'z3_spacer.h']
|
||||
add_lib('api', ['portfolio', 'smtparser', 'realclosure', 'interp', 'opt'],
|
||||
add_lib('api', ['portfolio', 'realclosure', 'interp', 'opt'],
|
||||
includes2install=['z3.h', 'z3_v1.h', 'z3_macros.h'] + API_files)
|
||||
add_exe('shell', ['api', 'sat', 'extra_cmds','opt'], exe_name='z3')
|
||||
add_exe('test', ['api', 'fuzzing', 'simplex'], exe_name='test-z3', install=False)
|
||||
|
|
|
@ -1990,7 +1990,7 @@ class MLComponent(Component):
|
|||
out.write('%s.cmxa: %s %s %s %s.cma\n' % (z3mls, cmxs, stubso, z3dllso, z3mls))
|
||||
out.write('\t%s -o %s -I %s %s %s %s\n' % (OCAMLMKLIB, z3mls, self.sub_dir, stubso, cmxs, LIBZ3))
|
||||
out.write('%s.cmxs: %s.cmxa\n' % (z3mls, z3mls))
|
||||
out.write('\t%s -shared -o %s.cmxs -I %s %s.cmxa\n' % (OCAMLOPTF, z3mls, self.sub_dir, z3mls))
|
||||
out.write('\t%s -linkall -shared -o %s.cmxs -I %s %s.cmxa\n' % (OCAMLOPTF, z3mls, self.sub_dir, z3mls))
|
||||
|
||||
out.write('\n')
|
||||
out.write('ml: %s.cma %s.cmxa %s.cmxs\n' % (z3mls, z3mls, z3mls))
|
||||
|
|
|
@ -1696,7 +1696,11 @@ if _lib is None:
|
|||
|
||||
def _to_ascii(s):
|
||||
if isinstance(s, str):
|
||||
return s.encode('ascii')
|
||||
try:
|
||||
return s.encode('ascii')
|
||||
except:
|
||||
# kick the bucket down the road. :-J
|
||||
return s
|
||||
else:
|
||||
return s
|
||||
|
||||
|
|
|
@ -98,7 +98,6 @@ add_subdirectory(sat/sat_solver)
|
|||
add_subdirectory(tactic/smtlogics)
|
||||
add_subdirectory(tactic/fpa)
|
||||
add_subdirectory(tactic/portfolio)
|
||||
add_subdirectory(parsers/smt)
|
||||
add_subdirectory(opt)
|
||||
add_subdirectory(api)
|
||||
add_subdirectory(api/dll)
|
||||
|
|
|
@ -27,14 +27,14 @@ public:
|
|||
: m(m), m_p(p)
|
||||
{}
|
||||
|
||||
virtual ~ackermannize_bv_tactic() { }
|
||||
~ackermannize_bv_tactic() override { }
|
||||
|
||||
virtual void operator()(goal_ref const & g,
|
||||
void operator()(goal_ref const & g,
|
||||
goal_ref_buffer & result,
|
||||
model_converter_ref & mc,
|
||||
proof_converter_ref & pc,
|
||||
expr_dependency_ref & core) {
|
||||
mc = 0;
|
||||
expr_dependency_ref & core) override {
|
||||
mc = nullptr;
|
||||
tactic_report report("ackermannize", *g);
|
||||
fail_if_unsat_core_generation("ackermannize", g);
|
||||
fail_if_proof_generation("ackermannize", g);
|
||||
|
@ -43,7 +43,7 @@ public:
|
|||
expr_ref_vector flas(m);
|
||||
const unsigned sz = g->size();
|
||||
for (unsigned i = 0; i < sz; i++) flas.push_back(g->form(i));
|
||||
lackr lackr(m, m_p, m_st, flas, NULL);
|
||||
lackr lackr(m, m_p, m_st, flas, nullptr);
|
||||
|
||||
// mk result
|
||||
goal_ref resg(alloc(goal, *g, true));
|
||||
|
@ -52,9 +52,9 @@ public:
|
|||
TRACE("ackermannize", tout << "ackermannize not run due to limit" << std::endl;);
|
||||
result.reset();
|
||||
result.push_back(g.get());
|
||||
mc = 0;
|
||||
pc = 0;
|
||||
core = 0;
|
||||
mc = nullptr;
|
||||
pc = nullptr;
|
||||
core = nullptr;
|
||||
return;
|
||||
}
|
||||
result.push_back(resg.get());
|
||||
|
@ -69,24 +69,24 @@ public:
|
|||
}
|
||||
|
||||
|
||||
void updt_params(params_ref const & _p) {
|
||||
void updt_params(params_ref const & _p) override {
|
||||
ackermannize_bv_tactic_params p(_p);
|
||||
m_lemma_limit = p.div0_ackermann_limit();
|
||||
}
|
||||
|
||||
virtual void collect_param_descrs(param_descrs & r) {
|
||||
void collect_param_descrs(param_descrs & r) override {
|
||||
ackermannize_bv_tactic_params::collect_param_descrs(r);
|
||||
}
|
||||
|
||||
virtual void collect_statistics(statistics & st) const {
|
||||
void collect_statistics(statistics & st) const override {
|
||||
st.update("ackr-constraints", m_st.m_ackrs_sz);
|
||||
}
|
||||
|
||||
virtual void reset_statistics() { m_st.reset(); }
|
||||
void reset_statistics() override { m_st.reset(); }
|
||||
|
||||
virtual void cleanup() { }
|
||||
void cleanup() override { }
|
||||
|
||||
virtual tactic* translate(ast_manager& m) {
|
||||
tactic* translate(ast_manager& m) override {
|
||||
return alloc(ackermannize_bv_tactic, m, m_p);
|
||||
}
|
||||
private:
|
||||
|
|
|
@ -45,7 +45,7 @@ class ackr_bound_probe : public probe {
|
|||
if (a->get_num_args() == 0) return;
|
||||
if (!m_ackr_helper.should_ackermannize(a)) return;
|
||||
func_decl* const fd = a->get_decl();
|
||||
app_set* ts = 0;
|
||||
app_set* ts = nullptr;
|
||||
if (!m_fun2terms.find(fd, ts)) {
|
||||
ts = alloc(app_set);
|
||||
m_fun2terms.insert(fd, ts);
|
||||
|
@ -57,7 +57,7 @@ class ackr_bound_probe : public probe {
|
|||
public:
|
||||
ackr_bound_probe() {}
|
||||
|
||||
virtual result operator()(goal const & g) {
|
||||
result operator()(goal const & g) override {
|
||||
proc p(g.m());
|
||||
unsigned sz = g.size();
|
||||
expr_fast_mark1 visited;
|
||||
|
|
|
@ -65,7 +65,7 @@ class ackr_info {
|
|||
}
|
||||
|
||||
inline app* find_term(func_decl* c) const {
|
||||
app * rv = 0;
|
||||
app * rv = nullptr;
|
||||
m_c2t.find(c,rv);
|
||||
return rv;
|
||||
}
|
||||
|
|
|
@ -37,9 +37,9 @@ public:
|
|||
, fixed_model(false)
|
||||
{ }
|
||||
|
||||
virtual ~ackr_model_converter() { }
|
||||
~ackr_model_converter() override { }
|
||||
|
||||
virtual void operator()(model_ref & md, unsigned goal_idx) {
|
||||
void operator()(model_ref & md, unsigned goal_idx) override {
|
||||
SASSERT(goal_idx == 0);
|
||||
SASSERT(!fixed_model || md.get() == 0 || (!md->get_num_constants() && !md->get_num_functions()));
|
||||
model_ref& old_model = fixed_model ? abstr_model : md;
|
||||
|
@ -49,9 +49,9 @@ public:
|
|||
md = new_model;
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & md) { operator()(md, 0); }
|
||||
void operator()(model_ref & md) override { operator()(md, 0); }
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator) {
|
||||
model_converter * translate(ast_translation & translator) override {
|
||||
ackr_info_ref retv_info = info->translate(translator);
|
||||
if (fixed_model) {
|
||||
model_ref retv_mod_ref = abstr_model->translate(translator);
|
||||
|
@ -116,7 +116,7 @@ void ackr_model_converter::add_entry(model_evaluator & evaluator,
|
|||
<< mk_ismt2_pp(value, m, 2) << "\n";
|
||||
);
|
||||
|
||||
func_interp * fi = 0;
|
||||
func_interp * fi = nullptr;
|
||||
func_decl * const declaration = term->get_decl();
|
||||
const unsigned sz = declaration->get_arity();
|
||||
SASSERT(sz == term->get_num_args());
|
||||
|
@ -133,7 +133,7 @@ void ackr_model_converter::add_entry(model_evaluator & evaluator,
|
|||
evaluator(aarg, arg_value);
|
||||
args.push_back(arg_value);
|
||||
}
|
||||
if (fi->get_entry(args.c_ptr()) == 0) {
|
||||
if (fi->get_entry(args.c_ptr()) == nullptr) {
|
||||
TRACE("ackr_model",
|
||||
tout << mk_ismt2_pp(declaration, m) << " args: " << std::endl;
|
||||
for (unsigned i = 0; i < args.size(); i++)
|
||||
|
|
|
@ -185,7 +185,7 @@ void lackr::add_term(app* a) {
|
|||
if (a->get_num_args() == 0) return;
|
||||
if (!m_ackr_helper.should_ackermannize(a)) return;
|
||||
func_decl* const fd = a->get_decl();
|
||||
app_set* ts = 0;
|
||||
app_set* ts = nullptr;
|
||||
if (!m_fun2terms.find(fd, ts)) {
|
||||
ts = alloc(app_set);
|
||||
m_fun2terms.insert(fd, ts);
|
||||
|
@ -205,7 +205,7 @@ lbool lackr::eager() {
|
|||
SASSERT(m_is_init);
|
||||
push_abstraction();
|
||||
TRACE("lackr", tout << "run sat 0\n"; );
|
||||
const lbool rv0 = m_sat->check_sat(0, 0);
|
||||
const lbool rv0 = m_sat->check_sat(0, nullptr);
|
||||
if (rv0 == l_false) return l_false;
|
||||
eager_enc();
|
||||
expr_ref all(m_m);
|
||||
|
@ -213,7 +213,7 @@ lbool lackr::eager() {
|
|||
m_simp(all);
|
||||
m_sat->assert_expr(all);
|
||||
TRACE("lackr", tout << "run sat all\n"; );
|
||||
return m_sat->check_sat(0, 0);
|
||||
return m_sat->check_sat(0, nullptr);
|
||||
}
|
||||
|
||||
lbool lackr::lazy() {
|
||||
|
@ -225,7 +225,7 @@ lbool lackr::lazy() {
|
|||
m_st.m_it++;
|
||||
checkpoint();
|
||||
TRACE("lackr", tout << "lazy check: " << m_st.m_it << "\n";);
|
||||
const lbool r = m_sat->check_sat(0, 0);
|
||||
const lbool r = m_sat->check_sat(0, nullptr);
|
||||
if (r == l_undef) return l_undef; // give up
|
||||
if (r == l_false) return l_false; // abstraction unsat
|
||||
// reconstruct model
|
||||
|
|
|
@ -34,7 +34,7 @@ struct lackr_model_constructor::imp {
|
|||
, m_conflicts(conflicts)
|
||||
, m_b_rw(m)
|
||||
, m_bv_rw(m)
|
||||
, m_evaluator(NULL)
|
||||
, m_evaluator(nullptr)
|
||||
, m_empty_model(m)
|
||||
, m_ackr_helper(m)
|
||||
{}
|
||||
|
@ -121,7 +121,7 @@ struct lackr_model_constructor::imp {
|
|||
|
||||
void add_entry(app* term, expr* value,
|
||||
obj_map<func_decl, func_interp*>& interpretations) {
|
||||
func_interp* fi = 0;
|
||||
func_interp* fi = nullptr;
|
||||
func_decl * const declaration = term->get_decl();
|
||||
const unsigned sz = declaration->get_arity();
|
||||
SASSERT(sz == term->get_num_args());
|
||||
|
@ -169,7 +169,7 @@ struct lackr_model_constructor::imp {
|
|||
// Stops upon the first failure.
|
||||
// Returns true if and only if all congruence checks succeeded.
|
||||
bool _check_stack() {
|
||||
if (m_evaluator == NULL) m_evaluator = alloc(model_evaluator, m_empty_model);
|
||||
if (m_evaluator == nullptr) m_evaluator = alloc(model_evaluator, m_empty_model);
|
||||
expr * curr;
|
||||
while (!m_stack.empty()) {
|
||||
curr = m_stack.back();
|
||||
|
@ -276,7 +276,7 @@ struct lackr_model_constructor::imp {
|
|||
SASSERT(a->get_num_args() == 0);
|
||||
func_decl * const fd = a->get_decl();
|
||||
expr * val = m_abstr_model->get_const_interp(fd);
|
||||
if (val == 0) { // TODO: avoid model completetion?
|
||||
if (val == nullptr) { // TODO: avoid model completetion?
|
||||
sort * s = fd->get_range();
|
||||
val = m_abstr_model->get_some_value(s);
|
||||
}
|
||||
|
@ -295,7 +295,7 @@ struct lackr_model_constructor::imp {
|
|||
expr_ref value(m_m);
|
||||
value = m_abstr_model->get_const_interp(ac->get_decl());
|
||||
// get ackermann constant's interpretation
|
||||
if (value.get() == 0) { // TODO: avoid model completion?
|
||||
if (value.get() == nullptr) { // TODO: avoid model completion?
|
||||
sort * s = a_fd->get_range();
|
||||
value = m_abstr_model->get_some_value(s);
|
||||
}
|
||||
|
@ -362,7 +362,7 @@ struct lackr_model_constructor::imp {
|
|||
};
|
||||
|
||||
lackr_model_constructor::lackr_model_constructor(ast_manager& m, ackr_info_ref info)
|
||||
: m_imp(0)
|
||||
: m_imp(nullptr)
|
||||
, m_m(m)
|
||||
, m_state(UNKNOWN)
|
||||
, m_info(info)
|
||||
|
@ -377,7 +377,7 @@ bool lackr_model_constructor::check(model_ref& abstr_model) {
|
|||
m_conflicts.reset();
|
||||
if (m_imp) {
|
||||
dealloc(m_imp);
|
||||
m_imp = 0;
|
||||
m_imp = nullptr;
|
||||
}
|
||||
m_imp = alloc(lackr_model_constructor::imp, m_m, m_info, abstr_model, m_conflicts);
|
||||
const bool rv = m_imp->check();
|
||||
|
|
|
@ -28,9 +28,9 @@ public:
|
|||
, model_constructor(lmc)
|
||||
{ }
|
||||
|
||||
virtual ~lackr_model_converter_lazy() { }
|
||||
~lackr_model_converter_lazy() override { }
|
||||
|
||||
virtual void operator()(model_ref & md, unsigned goal_idx) {
|
||||
void operator()(model_ref & md, unsigned goal_idx) override {
|
||||
SASSERT(goal_idx == 0);
|
||||
SASSERT(md.get() == 0 || (!md->get_num_constants() && !md->get_num_functions()));
|
||||
SASSERT(model_constructor.get());
|
||||
|
@ -39,13 +39,13 @@ public:
|
|||
model_constructor->make_model(md);
|
||||
}
|
||||
|
||||
virtual void operator()(model_ref & md) {
|
||||
void operator()(model_ref & md) override {
|
||||
operator()(md, 0);
|
||||
}
|
||||
|
||||
//void display(std::ostream & out);
|
||||
|
||||
virtual model_converter * translate(ast_translation & translator) {
|
||||
model_converter * translate(ast_translation & translator) override {
|
||||
NOT_IMPLEMENTED_YET();
|
||||
}
|
||||
protected:
|
||||
|
|
|
@ -71,5 +71,4 @@ z3_add_component(api
|
|||
opt
|
||||
portfolio
|
||||
realclosure
|
||||
smtparser
|
||||
)
|
||||
|
|
|
@ -162,57 +162,57 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_algebraic_add(c, a, b);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_IS_ALGEBRAIC_X(a, 0);
|
||||
CHECK_IS_ALGEBRAIC_X(b, 0);
|
||||
CHECK_IS_ALGEBRAIC_X(a, nullptr);
|
||||
CHECK_IS_ALGEBRAIC_X(b, nullptr);
|
||||
BIN_OP(+,add);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_algebraic_sub(Z3_context c, Z3_ast a, Z3_ast b) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_algebraic_sub(c, a, b);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_IS_ALGEBRAIC_X(a, 0);
|
||||
CHECK_IS_ALGEBRAIC_X(b, 0);
|
||||
CHECK_IS_ALGEBRAIC_X(a, nullptr);
|
||||
CHECK_IS_ALGEBRAIC_X(b, nullptr);
|
||||
BIN_OP(-,sub);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_algebraic_mul(Z3_context c, Z3_ast a, Z3_ast b) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_algebraic_mul(c, a, b);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_IS_ALGEBRAIC_X(a, 0);
|
||||
CHECK_IS_ALGEBRAIC_X(b, 0);
|
||||
CHECK_IS_ALGEBRAIC_X(a, nullptr);
|
||||
CHECK_IS_ALGEBRAIC_X(b, nullptr);
|
||||
BIN_OP(*,mul);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_algebraic_div(Z3_context c, Z3_ast a, Z3_ast b) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_algebraic_div(c, a, b);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_IS_ALGEBRAIC_X(a, 0);
|
||||
CHECK_IS_ALGEBRAIC_X(b, 0);
|
||||
CHECK_IS_ALGEBRAIC_X(a, nullptr);
|
||||
CHECK_IS_ALGEBRAIC_X(b, nullptr);
|
||||
if ((is_rational(c, b) && get_rational(c, b).is_zero()) ||
|
||||
(!is_rational(c, b) && am(c).is_zero(get_irrational(c, b)))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
BIN_OP(/,div);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_algebraic_root(Z3_context c, Z3_ast a, unsigned k) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_algebraic_root(c, a, k);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_IS_ALGEBRAIC_X(a, 0);
|
||||
CHECK_IS_ALGEBRAIC_X(a, nullptr);
|
||||
if (k % 2 == 0) {
|
||||
if ((is_rational(c, a) && get_rational(c, a).is_neg()) ||
|
||||
(!is_rational(c, a) && am(c).is_neg(get_irrational(c, a)))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
}
|
||||
algebraic_numbers::manager & _am = am(c);
|
||||
|
@ -229,14 +229,14 @@ extern "C" {
|
|||
expr * r = au(c).mk_numeral(_r, false);
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_algebraic_power(Z3_context c, Z3_ast a, unsigned k) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_algebraic_power(c, a, k);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_IS_ALGEBRAIC_X(a, 0);
|
||||
CHECK_IS_ALGEBRAIC_X(a, nullptr);
|
||||
algebraic_numbers::manager & _am = am(c);
|
||||
scoped_anum _r(_am);
|
||||
if (is_rational(c, a)) {
|
||||
|
@ -251,7 +251,7 @@ extern "C" {
|
|||
expr * r = au(c).mk_numeral(_r, false);
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
#define BIN_PRED(RAT_PRED, IRAT_PRED) \
|
||||
|
@ -345,9 +345,9 @@ extern "C" {
|
|||
public:
|
||||
vector_var2anum(scoped_anum_vector & as):m_as(as) {}
|
||||
virtual ~vector_var2anum() {}
|
||||
virtual algebraic_numbers::manager & m() const { return m_as.m(); }
|
||||
virtual bool contains(polynomial::var x) const { return static_cast<unsigned>(x) < m_as.size(); }
|
||||
virtual algebraic_numbers::anum const & operator()(polynomial::var x) const { return m_as.get(x); }
|
||||
algebraic_numbers::manager & m() const override { return m_as.m(); }
|
||||
bool contains(polynomial::var x) const override { return static_cast<unsigned>(x) < m_as.size(); }
|
||||
algebraic_numbers::anum const & operator()(polynomial::var x) const override { return m_as.get(x); }
|
||||
};
|
||||
|
||||
Z3_ast_vector Z3_API Z3_algebraic_roots(Z3_context c, Z3_ast p, unsigned n, Z3_ast a[]) {
|
||||
|
@ -357,17 +357,17 @@ extern "C" {
|
|||
polynomial::manager & pm = mk_c(c)->pm();
|
||||
polynomial_ref _p(pm);
|
||||
polynomial::scoped_numeral d(pm.m());
|
||||
expr2polynomial converter(mk_c(c)->m(), pm, 0, true);
|
||||
expr2polynomial converter(mk_c(c)->m(), pm, nullptr, true);
|
||||
if (!converter.to_polynomial(to_expr(p), _p, d) ||
|
||||
static_cast<unsigned>(max_var(_p)) >= n + 1) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
algebraic_numbers::manager & _am = am(c);
|
||||
scoped_anum_vector as(_am);
|
||||
if (!to_anum_vector(c, n, a, as)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
scoped_anum_vector roots(_am);
|
||||
{
|
||||
|
@ -383,7 +383,7 @@ extern "C" {
|
|||
result->m_ast_vector.push_back(au(c).mk_numeral(roots.get(i), false));
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(result));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
int Z3_API Z3_algebraic_eval(Z3_context c, Z3_ast p, unsigned n, Z3_ast a[]) {
|
||||
|
@ -393,7 +393,7 @@ extern "C" {
|
|||
polynomial::manager & pm = mk_c(c)->pm();
|
||||
polynomial_ref _p(pm);
|
||||
polynomial::scoped_numeral d(pm.m());
|
||||
expr2polynomial converter(mk_c(c)->m(), pm, 0, true);
|
||||
expr2polynomial converter(mk_c(c)->m(), pm, nullptr, true);
|
||||
if (!converter.to_polynomial(to_expr(p), _p, d) ||
|
||||
static_cast<unsigned>(max_var(_p)) >= n) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
|
|
|
@ -34,7 +34,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_sort r = of_sort(mk_c(c)->m().mk_sort(mk_c(c)->get_arith_fid(), INT_SORT));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c) {
|
||||
|
@ -43,7 +43,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_sort r = of_sort(mk_c(c)->m().mk_sort(mk_c(c)->get_arith_fid(), REAL_SORT));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_real(Z3_context c, int num, int den) {
|
||||
|
@ -52,12 +52,12 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (den == 0) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
sort* s = mk_c(c)->m().mk_sort(mk_c(c)->get_arith_fid(), REAL_SORT);
|
||||
ast* a = mk_c(c)->mk_numeral_core(rational(num, den), s);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
MK_ARITH_OP(Z3_mk_add, OP_ADD);
|
||||
|
@ -77,11 +77,11 @@ extern "C" {
|
|||
k = OP_DIV;
|
||||
}
|
||||
expr * args[2] = { to_expr(n1), to_expr(n2) };
|
||||
ast* a = mk_c(c)->m().mk_app(mk_c(c)->get_arith_fid(), k, 0, 0, 2, args);
|
||||
ast* a = mk_c(c)->m().mk_app(mk_c(c)->get_arith_fid(), k, 0, nullptr, 2, args);
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
check_sorts(c, a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
MK_ARITH_PRED(Z3_mk_lt, OP_LT);
|
||||
|
@ -98,17 +98,17 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (num_args == 0) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
expr* r = to_expr(args[0]);
|
||||
for (unsigned i = 1; i < num_args; ++i) {
|
||||
expr* args1[2] = { r, to_expr(args[i]) };
|
||||
r = mk_c(c)->m().mk_app(mk_c(c)->get_arith_fid(), OP_SUB, 0, 0, 2, args1);
|
||||
r = mk_c(c)->m().mk_app(mk_c(c)->get_arith_fid(), OP_SUB, 0, nullptr, 2, args1);
|
||||
check_sorts(c, r);
|
||||
}
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
RETURN_Z3(of_expr(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_unary_minus(Z3_context c, Z3_ast n) {
|
||||
|
@ -116,7 +116,7 @@ extern "C" {
|
|||
LOG_Z3_mk_unary_minus(c, n);
|
||||
RESET_ERROR_CODE();
|
||||
MK_UNARY_BODY(Z3_mk_unary_minus, mk_c(c)->get_arith_fid(), OP_UMINUS, SKIP);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a) {
|
||||
|
@ -134,7 +134,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!Z3_is_algebraic_number(c, a)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
expr * e = to_expr(a);
|
||||
algebraic_numbers::anum const & val = mk_c(c)->autil().to_irrational_algebraic_numeral(e);
|
||||
|
@ -143,7 +143,7 @@ extern "C" {
|
|||
expr * r = mk_c(c)->autil().mk_numeral(l, false);
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
RETURN_Z3(of_expr(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_get_algebraic_number_upper(Z3_context c, Z3_ast a, unsigned precision) {
|
||||
|
@ -152,7 +152,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!Z3_is_algebraic_number(c, a)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
expr * e = to_expr(a);
|
||||
algebraic_numbers::anum const & val = mk_c(c)->autil().to_irrational_algebraic_numeral(e);
|
||||
|
@ -161,7 +161,7 @@ extern "C" {
|
|||
expr * r = mk_c(c)->autil().mk_numeral(l, false);
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
RETURN_Z3(of_expr(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_get_numerator(Z3_context c, Z3_ast a) {
|
||||
|
@ -172,12 +172,12 @@ extern "C" {
|
|||
ast * _a = to_ast(a);
|
||||
if (!is_expr(_a) || !mk_c(c)->autil().is_numeral(to_expr(_a), val)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
expr * r = mk_c(c)->autil().mk_numeral(numerator(val), true);
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
RETURN_Z3(of_expr(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_get_denominator(Z3_context c, Z3_ast a) {
|
||||
|
@ -188,12 +188,12 @@ extern "C" {
|
|||
ast * _a = to_ast(a);
|
||||
if (!is_expr(_a) || !mk_c(c)->autil().is_numeral(to_expr(_a), val)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
expr * r = mk_c(c)->autil().mk_numeral(denominator(val), true);
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
RETURN_Z3(of_expr(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
@ -31,7 +31,7 @@ extern "C" {
|
|||
sort * ty = mk_c(c)->m().mk_sort(mk_c(c)->get_array_fid(), ARRAY_SORT, 2, params);
|
||||
mk_c(c)->save_ast_trail(ty);
|
||||
RETURN_Z3(of_sort(ty));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_mk_array_sort_n(Z3_context c, unsigned n, Z3_sort const* domain, Z3_sort range) {
|
||||
|
@ -44,7 +44,7 @@ extern "C" {
|
|||
sort * ty = mk_c(c)->m().mk_sort(mk_c(c)->get_array_fid(), ARRAY_SORT, params.size(), params.c_ptr());
|
||||
mk_c(c)->save_ast_trail(ty);
|
||||
RETURN_Z3(of_sort(ty));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_select(Z3_context c, Z3_ast a, Z3_ast i) {
|
||||
|
@ -58,7 +58,7 @@ extern "C" {
|
|||
sort * i_ty = m.get_sort(_i);
|
||||
if (a_ty->get_family_id() != mk_c(c)->get_array_fid()) {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
sort * domain[2] = {a_ty, i_ty};
|
||||
func_decl * d = m.mk_func_decl(mk_c(c)->get_array_fid(), OP_SELECT, 2, a_ty->get_parameters(), 2, domain);
|
||||
|
@ -67,7 +67,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(r);
|
||||
check_sorts(c, r);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_select_n(Z3_context c, Z3_ast a, unsigned n, Z3_ast const* idxs) {
|
||||
|
@ -81,7 +81,7 @@ extern "C" {
|
|||
// sort * i_ty = m.get_sort(_i);
|
||||
if (a_ty->get_family_id() != mk_c(c)->get_array_fid()) {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ptr_vector<sort> domain;
|
||||
ptr_vector<expr> args;
|
||||
|
@ -96,7 +96,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(r);
|
||||
check_sorts(c, r);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v) {
|
||||
|
@ -112,7 +112,7 @@ extern "C" {
|
|||
sort * v_ty = m.get_sort(_v);
|
||||
if (a_ty->get_family_id() != mk_c(c)->get_array_fid()) {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
sort * domain[3] = {a_ty, i_ty, v_ty};
|
||||
func_decl * d = m.mk_func_decl(mk_c(c)->get_array_fid(), OP_STORE, 2, a_ty->get_parameters(), 3, domain);
|
||||
|
@ -121,7 +121,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(r);
|
||||
check_sorts(c, r);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_store_n(Z3_context c, Z3_ast a, unsigned n, Z3_ast const* idxs, Z3_ast v) {
|
||||
|
@ -135,7 +135,7 @@ extern "C" {
|
|||
sort * v_ty = m.get_sort(_v);
|
||||
if (a_ty->get_family_id() != mk_c(c)->get_array_fid()) {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ptr_vector<sort> domain;
|
||||
ptr_vector<expr> args;
|
||||
|
@ -152,7 +152,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(r);
|
||||
check_sorts(c, r);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_map(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast const* args) {
|
||||
|
@ -161,7 +161,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (n == 0) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ast_manager & m = mk_c(c)->m();
|
||||
func_decl* _f = to_func_decl(f);
|
||||
|
@ -177,7 +177,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(r);
|
||||
check_sorts(c, r);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v) {
|
||||
|
@ -196,7 +196,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(r);
|
||||
check_sorts(c, r);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_array_default(Z3_context c, Z3_ast array) {
|
||||
|
@ -206,12 +206,12 @@ extern "C" {
|
|||
ast_manager & m = mk_c(c)->m();
|
||||
expr * _a = to_expr(array);
|
||||
|
||||
func_decl * f = m.mk_func_decl(mk_c(c)->get_array_fid(), OP_ARRAY_DEFAULT, 0, 0, 1, &_a);
|
||||
func_decl * f = m.mk_func_decl(mk_c(c)->get_array_fid(), OP_ARRAY_DEFAULT, 0, nullptr, 1, &_a);
|
||||
app * r = m.mk_app(f, 1, &_a);
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
check_sorts(c, r);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast mk_app_array_core(Z3_context c, Z3_sort domain, Z3_ast v) {
|
||||
|
@ -233,7 +233,7 @@ extern "C" {
|
|||
Z3_sort Z3_API Z3_mk_set_sort(Z3_context c, Z3_sort ty) {
|
||||
Z3_TRY;
|
||||
return Z3_mk_array_sort(c, ty, Z3_mk_bool_sort(c));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain) {
|
||||
|
@ -242,7 +242,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_ast r = mk_app_array_core(c, domain, Z3_mk_false(c));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain) {
|
||||
|
@ -251,7 +251,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_ast r = mk_app_array_core(c, domain, Z3_mk_true(c));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
MK_NARY(Z3_mk_set_union, mk_c(c)->get_array_fid(), OP_SET_UNION, SKIP);
|
||||
|
@ -270,7 +270,7 @@ extern "C" {
|
|||
app * r = a.mk_as_array(to_func_decl(f));
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
return of_ast(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set) {
|
||||
|
@ -289,22 +289,22 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_get_array_sort_domain(c, t);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_VALID_AST(t, 0);
|
||||
CHECK_VALID_AST(t, nullptr);
|
||||
if (to_sort(t)->get_family_id() == mk_c(c)->get_array_fid() &&
|
||||
to_sort(t)->get_decl_kind() == ARRAY_SORT) {
|
||||
Z3_sort r = reinterpret_cast<Z3_sort>(to_sort(t)->get_parameter(0).get_ast());
|
||||
RETURN_Z3(r);
|
||||
}
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
Z3_CATCH_RETURN(0);
|
||||
RETURN_Z3(nullptr);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_get_array_sort_range(Z3_context c, Z3_sort t) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_array_sort_range(c, t);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_VALID_AST(t, 0);
|
||||
CHECK_VALID_AST(t, nullptr);
|
||||
if (to_sort(t)->get_family_id() == mk_c(c)->get_array_fid() &&
|
||||
to_sort(t)->get_decl_kind() == ARRAY_SORT) {
|
||||
unsigned n = to_sort(t)->get_num_parameters();
|
||||
|
@ -312,8 +312,8 @@ extern "C" {
|
|||
RETURN_Z3(r);
|
||||
}
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
Z3_CATCH_RETURN(0);
|
||||
RETURN_Z3(nullptr);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
@ -49,11 +49,11 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (i < 0 || (size_t)i >= (SIZE_MAX >> PTR_ALIGNMENT)) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
Z3_symbol result = of_symbol(symbol(i));
|
||||
return result;
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, char const * str) {
|
||||
|
@ -61,13 +61,13 @@ extern "C" {
|
|||
LOG_Z3_mk_string_symbol(c, str);
|
||||
RESET_ERROR_CODE();
|
||||
symbol s;
|
||||
if (str == 0 || *str == 0)
|
||||
if (str == nullptr || *str == 0)
|
||||
s = symbol::null;
|
||||
else
|
||||
s = symbol(str);
|
||||
Z3_symbol result = of_symbol(s);
|
||||
return result;
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_is_eq_sort(Z3_context c, Z3_sort s1, Z3_sort s2) {
|
||||
|
@ -82,7 +82,7 @@ extern "C" {
|
|||
sort* ty = mk_c(c)->m().mk_uninterpreted_sort(to_symbol(name));
|
||||
mk_c(c)->save_ast_trail(ty);
|
||||
RETURN_Z3(of_sort(ty));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast s1, Z3_ast s2) {
|
||||
|
@ -107,7 +107,7 @@ extern "C" {
|
|||
|
||||
mk_c(c)->save_ast_trail(d);
|
||||
RETURN_Z3(of_func_decl(d));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_app(Z3_context c, Z3_func_decl d, unsigned num_args, Z3_ast const * args) {
|
||||
|
@ -123,7 +123,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(a);
|
||||
check_sorts(c, a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty) {
|
||||
|
@ -133,7 +133,7 @@ extern "C" {
|
|||
app* a = mk_c(c)->m().mk_const(mk_c(c)->m().mk_const_decl(to_symbol(s), to_sort(ty)));
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
|
||||
|
@ -142,7 +142,7 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_mk_fresh_func_decl(c, prefix, domain_size, domain, range);
|
||||
RESET_ERROR_CODE();
|
||||
if (prefix == 0) {
|
||||
if (prefix == nullptr) {
|
||||
prefix = "";
|
||||
}
|
||||
|
||||
|
@ -153,20 +153,20 @@ extern "C" {
|
|||
|
||||
mk_c(c)->save_ast_trail(d);
|
||||
RETURN_Z3(of_func_decl(d));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, const char * prefix, Z3_sort ty) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_mk_fresh_const(c, prefix, ty);
|
||||
RESET_ERROR_CODE();
|
||||
if (prefix == 0) {
|
||||
if (prefix == nullptr) {
|
||||
prefix = "";
|
||||
}
|
||||
app* a = mk_c(c)->m().mk_fresh_const(prefix, to_sort(ty));
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_true(Z3_context c) {
|
||||
|
@ -175,7 +175,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_ast r = of_ast(mk_c(c)->m().mk_true());
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_false(Z3_context c) {
|
||||
|
@ -184,7 +184,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_ast r = of_ast(mk_c(c)->m().mk_false());
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
MK_UNARY(Z3_mk_not, mk_c(c)->get_basic_fid(), OP_NOT, SKIP);
|
||||
|
@ -210,7 +210,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_ast r = mk_ite_core(c, t1, t2, t3);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c) {
|
||||
|
@ -219,7 +219,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_sort r = of_sort(mk_c(c)->m().mk_sort(mk_c(c)->m().get_basic_family_id(), BOOL_SORT));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_app_to_ast(Z3_context c, Z3_app a) {
|
||||
|
@ -335,7 +335,7 @@ extern "C" {
|
|||
Z3_bool Z3_API Z3_is_app(Z3_context c, Z3_ast a) {
|
||||
LOG_Z3_is_app(c, a);
|
||||
RESET_ERROR_CODE();
|
||||
return a != 0 && is_app(reinterpret_cast<ast*>(a));
|
||||
return a != nullptr && is_app(reinterpret_cast<ast*>(a));
|
||||
}
|
||||
|
||||
Z3_app Z3_API Z3_to_app(Z3_context c, Z3_ast a) {
|
||||
|
@ -357,7 +357,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_app(reinterpret_cast<ast*>(a))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
RETURN_Z3(of_func_decl(to_app(a)->get_decl()));
|
||||
}
|
||||
|
@ -373,11 +373,11 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_app(reinterpret_cast<ast*>(a))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
if (i >= to_app(a)->get_num_args()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
RETURN_Z3(of_ast(to_app(a)->get_arg(i)));
|
||||
}
|
||||
|
@ -466,15 +466,15 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
parameter const& p = to_func_decl(d)->get_parameters()[idx];
|
||||
if (!p.is_symbol()) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
return of_symbol(p.get_symbol());
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_get_decl_sort_parameter(Z3_context c, Z3_func_decl d, unsigned idx) {
|
||||
|
@ -483,15 +483,15 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
parameter const& p = to_func_decl(d)->get_parameters()[idx];
|
||||
if (!p.is_ast() || !is_sort(p.get_ast())) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
RETURN_Z3(of_sort(to_sort(p.get_ast())));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_get_decl_ast_parameter(Z3_context c, Z3_func_decl d, unsigned idx) {
|
||||
|
@ -500,15 +500,15 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
parameter const& p = to_func_decl(d)->get_parameters()[idx];
|
||||
if (!p.is_ast()) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
RETURN_Z3(of_ast(p.get_ast()));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_func_decl Z3_API Z3_get_decl_func_decl_parameter(Z3_context c, Z3_func_decl d, unsigned idx) {
|
||||
|
@ -517,15 +517,15 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (idx >= to_func_decl(d)->get_num_parameters()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
parameter const& p = to_func_decl(d)->get_parameters()[idx];
|
||||
if (!p.is_ast() || !is_func_decl(p.get_ast())) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
RETURN_Z3(of_func_decl(to_func_decl(p.get_ast())));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_get_decl_rational_parameter(Z3_context c, Z3_func_decl d, unsigned idx) {
|
||||
|
@ -551,17 +551,17 @@ extern "C" {
|
|||
LOG_Z3_get_sort_name(c, t);
|
||||
RESET_ERROR_CODE();
|
||||
return of_symbol(to_sort(t)->get_name());
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_sort(c, a);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_IS_EXPR(a, 0);
|
||||
CHECK_IS_EXPR(a, nullptr);
|
||||
Z3_sort r = of_sort(mk_c(c)->m().get_sort(to_expr(a)));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_get_arity(Z3_context c, Z3_func_decl d) {
|
||||
|
@ -586,21 +586,21 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (i >= to_func_decl(d)->get_arity()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_sort r = of_sort(to_func_decl(d)->get_domain(i));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_get_range(Z3_context c, Z3_func_decl d) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_range(c, d);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_VALID_AST(d, 0);
|
||||
CHECK_VALID_AST(d, nullptr);
|
||||
Z3_sort r = of_sort(to_func_decl(d)->get_range());
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort_kind Z3_get_sort_kind(Z3_context c, Z3_sort t) {
|
||||
|
@ -688,17 +688,17 @@ extern "C" {
|
|||
}
|
||||
catch (z3_exception & ex) {
|
||||
mk_c(c)->handle_exception(ex);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
mk_c(c)->save_ast_trail(result);
|
||||
return of_ast(result.get());
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast _a) {
|
||||
LOG_Z3_simplify(c, _a);
|
||||
RETURN_Z3(simplify(c, _a, 0));
|
||||
RETURN_Z3(simplify(c, _a, nullptr));
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast _a, Z3_params p) {
|
||||
|
@ -727,7 +727,7 @@ extern "C" {
|
|||
th_rewriter::get_param_descrs(d->m_descrs);
|
||||
Z3_param_descrs r = of_param_descrs(d);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_update_term(Z3_context c, Z3_ast _a, unsigned num_args, Z3_ast const _args[]) {
|
||||
|
@ -762,7 +762,7 @@ extern "C" {
|
|||
}
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_substitute(Z3_context c,
|
||||
|
@ -777,11 +777,11 @@ extern "C" {
|
|||
expr * a = to_expr(_a);
|
||||
expr * const * from = to_exprs(_from);
|
||||
expr * const * to = to_exprs(_to);
|
||||
expr * r = 0;
|
||||
expr * r = nullptr;
|
||||
for (unsigned i = 0; i < num_exprs; i++) {
|
||||
if (m.get_sort(from[i]) != m.get_sort(to[i])) {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
RETURN_Z3(of_expr(0));
|
||||
RETURN_Z3(of_expr(nullptr));
|
||||
}
|
||||
SASSERT(from[i]->get_ref_count() > 0);
|
||||
SASSERT(to[i]->get_ref_count() > 0);
|
||||
|
@ -795,7 +795,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(new_a);
|
||||
r = new_a.get();
|
||||
RETURN_Z3(of_expr(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_substitute_vars(Z3_context c,
|
||||
|
@ -813,7 +813,7 @@ extern "C" {
|
|||
subst(a, num_exprs, to, new_a);
|
||||
mk_c(c)->save_ast_trail(new_a);
|
||||
RETURN_Z3(of_expr(new_a.get()));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_API char const * Z3_ast_to_string(Z3_context c, Z3_ast a) {
|
||||
|
@ -832,35 +832,14 @@ extern "C" {
|
|||
case Z3_PRINT_LOW_LEVEL:
|
||||
buffer << mk_ll_pp(to_ast(a), mk_c(c)->m());
|
||||
break;
|
||||
case Z3_PRINT_SMTLIB_COMPLIANT: {
|
||||
ast_smt_pp pp(mk_c(c)->m());
|
||||
pp_params params;
|
||||
pp.set_simplify_implies(params.simplify_implies());
|
||||
ast* a1 = to_ast(a);
|
||||
pp.set_logic(mk_c(c)->fparams().m_logic);
|
||||
if (!is_expr(a1)) {
|
||||
buffer << mk_pp(a1, mk_c(c)->m());
|
||||
break;
|
||||
}
|
||||
if (mk_c(c)->get_print_mode() == Z3_PRINT_SMTLIB_COMPLIANT) {
|
||||
pp.display_expr(buffer, to_expr(a1));
|
||||
break;
|
||||
}
|
||||
if (mk_c(c)->get_print_mode() == Z3_PRINT_SMTLIB2_COMPLIANT) {
|
||||
pp.display_expr_smt2(buffer, to_expr(a1));
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Z3_PRINT_SMTLIB2_COMPLIANT: {
|
||||
case Z3_PRINT_SMTLIB2_COMPLIANT:
|
||||
buffer << mk_ismt2_pp(to_ast(a), mk_c(c)->m());
|
||||
break;
|
||||
}
|
||||
default:
|
||||
UNREACHABLE();
|
||||
}
|
||||
return mk_c(c)->mk_external_string(buffer.str());
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_API char const * Z3_sort_to_string(Z3_context c, Z3_sort s) {
|
||||
|
@ -893,12 +872,7 @@ extern "C" {
|
|||
for (unsigned i = 0; i < num_assumptions; ++i) {
|
||||
pp.add_assumption(to_expr(assumptions[i]));
|
||||
}
|
||||
if (mk_c(c)->get_print_mode() == Z3_PRINT_SMTLIB2_COMPLIANT) {
|
||||
pp.display_smt2(buffer, to_expr(formula));
|
||||
}
|
||||
else {
|
||||
pp.display(buffer, to_expr(formula));
|
||||
}
|
||||
pp.display_smt2(buffer, to_expr(formula));
|
||||
return mk_c(c)->mk_external_string(buffer.str());
|
||||
Z3_CATCH_RETURN("");
|
||||
}
|
||||
|
@ -1085,6 +1059,7 @@ extern "C" {
|
|||
switch(_d->get_decl_kind()) {
|
||||
case OP_DT_CONSTRUCTOR: return Z3_OP_DT_CONSTRUCTOR;
|
||||
case OP_DT_RECOGNISER: return Z3_OP_DT_RECOGNISER;
|
||||
case OP_DT_IS: return Z3_OP_DT_IS;
|
||||
case OP_DT_ACCESSOR: return Z3_OP_DT_ACCESSOR;
|
||||
case OP_DT_UPDATE_FIELD: return Z3_OP_DT_UPDATE_FIELD;
|
||||
default:
|
||||
|
@ -1141,7 +1116,7 @@ extern "C" {
|
|||
case _OP_STRING_SUBSTR: return Z3_OP_SEQ_EXTRACT;
|
||||
case _OP_STRING_STRIDOF: return Z3_OP_SEQ_INDEX;
|
||||
case _OP_REGEXP_EMPTY: return Z3_OP_RE_EMPTY_SET;
|
||||
case _OP_REGEXP_FULL: return Z3_OP_RE_FULL_SET;
|
||||
case _OP_REGEXP_FULL_CHAR: return Z3_OP_RE_FULL_SET;
|
||||
|
||||
case OP_STRING_STOI: return Z3_OP_STR_TO_INT;
|
||||
case OP_STRING_ITOS: return Z3_OP_INT_TO_STR;
|
||||
|
@ -1153,7 +1128,8 @@ extern "C" {
|
|||
case OP_RE_UNION: return Z3_OP_RE_UNION;
|
||||
case OP_RE_INTERSECT: return Z3_OP_RE_INTERSECT;
|
||||
case OP_RE_LOOP: return Z3_OP_RE_LOOP;
|
||||
case OP_RE_FULL_SET: return Z3_OP_RE_FULL_SET;
|
||||
// case OP_RE_FULL_SEQ_SET: return Z3_OP_RE_FULL_SET;
|
||||
case OP_RE_FULL_CHAR_SET: return Z3_OP_RE_FULL_SET;
|
||||
case OP_RE_EMPTY_SET: return Z3_OP_RE_EMPTY_SET;
|
||||
default:
|
||||
return Z3_OP_INTERNAL;
|
||||
|
@ -1258,17 +1234,17 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_translate(c, a, target);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_VALID_AST(a, 0);
|
||||
CHECK_VALID_AST(a, nullptr);
|
||||
if (c == target) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
SASSERT(mk_c(c)->m().contains(to_ast(a)));
|
||||
ast_translation translator(mk_c(c)->m(), mk_c(target)->m());
|
||||
ast * _result = translator(to_ast(a));
|
||||
mk_c(target)->save_ast_trail(_result);
|
||||
RETURN_Z3(of_ast(_result));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
@ -38,7 +38,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(m);
|
||||
Z3_ast_map r = of_ast_map(m);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_ast_map_inc_ref(Z3_context c, Z3_ast_map m) {
|
||||
|
@ -70,15 +70,15 @@ extern "C" {
|
|||
LOG_Z3_ast_map_find(c, m, k);
|
||||
RESET_ERROR_CODE();
|
||||
obj_map<ast, ast*>::obj_map_entry * entry = to_ast_map_ref(m).find_core(to_ast(k));
|
||||
if (entry == 0) {
|
||||
if (entry == nullptr) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
else {
|
||||
ast * r = entry->get_data().m_value;
|
||||
RETURN_Z3(of_ast(r));
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_ast_map_insert(Z3_context c, Z3_ast_map m, Z3_ast k, Z3_ast v) {
|
||||
|
@ -115,7 +115,7 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_ast_map_erase(c, m, k);
|
||||
RESET_ERROR_CODE();
|
||||
ast * v = 0;
|
||||
ast * v = nullptr;
|
||||
if (to_ast_map_ref(m).find(to_ast(k), v)) {
|
||||
to_ast_map_ref(m).erase(to_ast(k));
|
||||
ast_manager & mng = to_ast_map(m)->m;
|
||||
|
@ -146,7 +146,7 @@ extern "C" {
|
|||
}
|
||||
Z3_ast_vector r = of_ast_vector(v);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_ast_map_to_string(Z3_context c, Z3_ast_map m) {
|
||||
|
@ -163,7 +163,7 @@ extern "C" {
|
|||
}
|
||||
buffer << ")";
|
||||
return mk_c(c)->mk_external_string(buffer.str());
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
@ -25,7 +25,7 @@ struct Z3_ast_map_ref : public api::object {
|
|||
ast_manager & m;
|
||||
obj_map<ast, ast*> m_map;
|
||||
Z3_ast_map_ref(api::context& c, ast_manager & _m): api::object(c), m(_m) {}
|
||||
virtual ~Z3_ast_map_ref();
|
||||
~Z3_ast_map_ref() override;
|
||||
};
|
||||
|
||||
inline Z3_ast_map_ref * to_ast_map(Z3_ast_map v) { return reinterpret_cast<Z3_ast_map_ref *>(v); }
|
||||
|
|
|
@ -33,7 +33,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(v);
|
||||
Z3_ast_vector r = of_ast_vector(v);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_ast_vector_inc_ref(Z3_context c, Z3_ast_vector v) {
|
||||
|
@ -66,12 +66,12 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (i >= to_ast_vector_ref(v).size()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
// Remark: Don't need to invoke save_object.
|
||||
ast * r = to_ast_vector_ref(v).get(i);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_ast_vector_set(Z3_context c, Z3_ast_vector v, unsigned i, Z3_ast a) {
|
||||
|
@ -108,7 +108,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (c == t) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ast_translation translator(mk_c(c)->m(), mk_c(t)->m());
|
||||
Z3_ast_vector_ref * new_v = alloc(Z3_ast_vector_ref, *mk_c(t), mk_c(t)->m());
|
||||
|
@ -119,7 +119,7 @@ extern "C" {
|
|||
new_v->m_ast_vector.push_back(new_ast);
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(new_v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_ast_vector_to_string(Z3_context c, Z3_ast_vector v) {
|
||||
|
@ -134,7 +134,7 @@ extern "C" {
|
|||
}
|
||||
buffer << ")";
|
||||
return mk_c(c)->mk_external_string(buffer.str());
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
@ -27,7 +27,7 @@ namespace api {
|
|||
struct Z3_ast_vector_ref : public api::object {
|
||||
ast_ref_vector m_ast_vector;
|
||||
Z3_ast_vector_ref(api::context& c, ast_manager & m): api::object(c), m_ast_vector(m) {}
|
||||
virtual ~Z3_ast_vector_ref() {}
|
||||
~Z3_ast_vector_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_ast_vector_ref * to_ast_vector(Z3_ast_vector v) { return reinterpret_cast<Z3_ast_vector_ref *>(v); }
|
||||
|
|
|
@ -33,7 +33,7 @@ extern "C" {
|
|||
parameter p(sz);
|
||||
Z3_sort r = of_sort(mk_c(c)->m().mk_sort(mk_c(c)->get_bv_fid(), BV_SORT, 1, &p));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
#define MK_BV_UNARY(NAME, OP) MK_UNARY(NAME, mk_c(c)->get_bv_fid(), OP, SKIP)
|
||||
|
@ -85,7 +85,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_ast r = mk_extract_core(c, high, low, n);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
#define MK_BV_PUNARY(NAME, OP) \
|
||||
|
@ -146,7 +146,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
check_sorts(c, a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -164,7 +164,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
unsigned sz = Z3_get_bv_sort_size(c, s);
|
||||
if (sz == 0) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
Z3_ast x = Z3_mk_int64(c, 1, s);
|
||||
Z3_inc_ref(c, x);
|
||||
|
@ -174,7 +174,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
Z3_dec_ref(c, x);
|
||||
Z3_dec_ref(c, y);
|
||||
return result;
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_mk_bvsmin(Z3_context c, Z3_sort s) {
|
||||
|
@ -229,7 +229,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
Z3_dec_ref(c, r);
|
||||
return result;
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
// only for signed machine integers
|
||||
|
@ -257,7 +257,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
Z3_dec_ref(c, args_neg);
|
||||
Z3_dec_ref(c, zero);
|
||||
return result;
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
// only for signed machine integers
|
||||
|
@ -286,7 +286,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
Z3_dec_ref(c, z);
|
||||
Z3_dec_ref(c, zero);
|
||||
return result;
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_bool is_signed) {
|
||||
|
@ -311,7 +311,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
else {
|
||||
return Z3_mk_bvule(c, t2, t1);
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast n1, Z3_ast n2, Z3_bool is_signed) {
|
||||
|
@ -336,11 +336,11 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
Z3_TRY;
|
||||
RESET_ERROR_CODE();
|
||||
Z3_ast min = Z3_mk_bvsmin(c, Z3_get_sort(c, t));
|
||||
if (Z3_get_error_code(c) != Z3_OK) return 0;
|
||||
if (Z3_get_error_code(c) != Z3_OK) return nullptr;
|
||||
Z3_ast eq = Z3_mk_eq(c, t, min);
|
||||
if (Z3_get_error_code(c) != Z3_OK) return 0;
|
||||
if (Z3_get_error_code(c) != Z3_OK) return nullptr;
|
||||
return Z3_mk_not(c, eq);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
// only for signed machine integers
|
||||
|
@ -366,7 +366,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
Z3_dec_ref(c, z);
|
||||
Z3_dec_ref(c, u);
|
||||
return result;
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_bvsub(Z3_context c, Z3_ast n1, Z3_ast n2) {
|
||||
|
@ -374,7 +374,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
LOG_Z3_mk_bvsub(c, n1, n2);
|
||||
RESET_ERROR_CODE();
|
||||
MK_BINARY_BODY(Z3_mk_bvsub, mk_c(c)->get_bv_fid(), OP_BSUB, SKIP);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_bvneg(Z3_context c, Z3_ast n) {
|
||||
|
@ -382,7 +382,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \
|
|||
LOG_Z3_mk_bvneg(c, n);
|
||||
RESET_ERROR_CODE();
|
||||
MK_UNARY_BODY(Z3_mk_bvneg, mk_c(c)->get_bv_fid(), OP_BNEG, SKIP);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_get_bv_sort_size(Z3_context c, Z3_sort t) {
|
||||
|
|
|
@ -53,7 +53,7 @@ extern "C" {
|
|||
Z3_bool_opt Z3_API Z3_global_param_get(Z3_string param_id, Z3_string_ptr param_value) {
|
||||
memory::initialize(UINT_MAX);
|
||||
LOG_Z3_global_param_get(param_id, param_value);
|
||||
*param_value = 0;
|
||||
*param_value = nullptr;
|
||||
try {
|
||||
g_Z3_global_param_get_buffer = gparams::get_value(param_id);
|
||||
*param_value = g_Z3_global_param_get_buffer.c_str();
|
||||
|
|
|
@ -19,7 +19,6 @@ Revision History:
|
|||
--*/
|
||||
#include<typeinfo>
|
||||
#include "api/api_context.h"
|
||||
#include "parsers/smt/smtparser.h"
|
||||
#include "util/version.h"
|
||||
#include "ast/ast_pp.h"
|
||||
#include "ast/ast_ll_pp.h"
|
||||
|
@ -71,7 +70,7 @@ namespace api {
|
|||
// ------------------------
|
||||
|
||||
context::context(context_params * p, bool user_ref_count):
|
||||
m_params(p != 0 ? *p : context_params()),
|
||||
m_params(p != nullptr ? *p : context_params()),
|
||||
m_user_ref_count(user_ref_count),
|
||||
m_manager(m_params.mk_ast_manager()),
|
||||
m_plugins(m()),
|
||||
|
@ -89,10 +88,8 @@ namespace api {
|
|||
m_print_mode = Z3_PRINT_SMTLIB_FULL;
|
||||
m_searching = false;
|
||||
|
||||
m_smtlib_parser = 0;
|
||||
m_smtlib_parser_has_decls = false;
|
||||
|
||||
m_interruptable = 0;
|
||||
m_interruptable = nullptr;
|
||||
m_error_handler = &default_error_handler;
|
||||
|
||||
m_basic_fid = m().get_basic_family_id();
|
||||
|
@ -111,13 +108,13 @@ namespace api {
|
|||
|
||||
|
||||
context::~context() {
|
||||
reset_parser();
|
||||
m_last_obj = 0;
|
||||
m_last_obj = nullptr;
|
||||
u_map<api::object*>::iterator it = m_allocated_objects.begin();
|
||||
while (it != m_allocated_objects.end()) {
|
||||
DEBUG_CODE(warning_msg("Uncollected memory: %d: %s", it->m_key, typeid(*it->m_value).name()););
|
||||
api::object* val = it->m_value;
|
||||
DEBUG_CODE(warning_msg("Uncollected memory: %d: %s", it->m_key, typeid(*val).name()););
|
||||
m_allocated_objects.remove(it->m_key);
|
||||
dealloc(it->m_value);
|
||||
dealloc(val);
|
||||
it = m_allocated_objects.begin();
|
||||
}
|
||||
}
|
||||
|
@ -134,7 +131,7 @@ namespace api {
|
|||
context::set_interruptable::~set_interruptable() {
|
||||
#pragma omp critical (set_interruptable)
|
||||
{
|
||||
m_ctx.m_interruptable = 0;
|
||||
m_ctx.m_interruptable = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -155,6 +152,12 @@ namespace api {
|
|||
}
|
||||
}
|
||||
|
||||
void context::reset_error_code() {
|
||||
m_error_code = Z3_OK;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void context::check_searching() {
|
||||
if (m_searching) {
|
||||
set_error_code(Z3_INVALID_USAGE); // TBD: error code could be fixed.
|
||||
|
@ -172,7 +175,7 @@ namespace api {
|
|||
}
|
||||
|
||||
expr * context::mk_numeral_core(rational const & n, sort * s) {
|
||||
expr* e = 0;
|
||||
expr* e = nullptr;
|
||||
family_id fid = s->get_family_id();
|
||||
if (fid == m_arith_fid) {
|
||||
e = m_arith_util.mk_numeral(n, s);
|
||||
|
@ -236,7 +239,7 @@ namespace api {
|
|||
void context::reset_last_result() {
|
||||
if (m_user_ref_count)
|
||||
m_last_result.reset();
|
||||
m_last_obj = 0;
|
||||
m_last_obj = nullptr;
|
||||
}
|
||||
|
||||
void context::save_object(object * r) {
|
||||
|
@ -304,46 +307,13 @@ namespace api {
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
// ------------------------
|
||||
//
|
||||
// Parser interface for backward compatibility
|
||||
//
|
||||
// ------------------------
|
||||
|
||||
void context::reset_parser() {
|
||||
if (m_smtlib_parser) {
|
||||
dealloc(m_smtlib_parser);
|
||||
m_smtlib_parser = 0;
|
||||
m_smtlib_parser_has_decls = false;
|
||||
m_smtlib_parser_decls.reset();
|
||||
m_smtlib_parser_sorts.reset();
|
||||
}
|
||||
SASSERT(!m_smtlib_parser_has_decls);
|
||||
}
|
||||
|
||||
void context::extract_smtlib_parser_decls() {
|
||||
if (m_smtlib_parser) {
|
||||
if (!m_smtlib_parser_has_decls) {
|
||||
smtlib::symtable * table = m_smtlib_parser->get_benchmark()->get_symtable();
|
||||
table->get_func_decls(m_smtlib_parser_decls);
|
||||
table->get_sorts(m_smtlib_parser_sorts);
|
||||
m_smtlib_parser_has_decls = true;
|
||||
}
|
||||
}
|
||||
else {
|
||||
m_smtlib_parser_decls.reset();
|
||||
m_smtlib_parser_sorts.reset();
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------
|
||||
//
|
||||
// RCF manager
|
||||
//
|
||||
// -----------------------
|
||||
realclosure::manager & context::rcfm() {
|
||||
if (m_rcf_manager.get() == 0) {
|
||||
if (m_rcf_manager.get() == nullptr) {
|
||||
m_rcf_manager = alloc(realclosure::manager, m_limit, m_rcf_qm);
|
||||
}
|
||||
return *(m_rcf_manager.get());
|
||||
|
@ -366,7 +336,7 @@ extern "C" {
|
|||
memory::initialize(UINT_MAX);
|
||||
Z3_context r = reinterpret_cast<Z3_context>(alloc(api::context, reinterpret_cast<context_params*>(c), false));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN_NO_HANDLE(0);
|
||||
Z3_CATCH_RETURN_NO_HANDLE(nullptr);
|
||||
}
|
||||
|
||||
Z3_context Z3_API Z3_mk_context_rc(Z3_config c) {
|
||||
|
@ -375,7 +345,7 @@ extern "C" {
|
|||
memory::initialize(UINT_MAX);
|
||||
Z3_context r = reinterpret_cast<Z3_context>(alloc(api::context, reinterpret_cast<context_params*>(c), true));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN_NO_HANDLE(0);
|
||||
Z3_CATCH_RETURN_NO_HANDLE(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_del_context(Z3_context c) {
|
||||
|
@ -489,7 +459,7 @@ extern "C" {
|
|||
case Z3_INTERNAL_FATAL: return "internal error";
|
||||
case Z3_INVALID_USAGE: return "invalid usage";
|
||||
case Z3_DEC_REF_ERROR: return "invalid dec_ref command";
|
||||
case Z3_EXCEPTION: return c == 0 ? "Z3 exception" : mk_c(c)->get_exception_msg();
|
||||
case Z3_EXCEPTION: return c == nullptr ? "Z3 exception" : mk_c(c)->get_exception_msg();
|
||||
default: return "unknown";
|
||||
}
|
||||
}
|
||||
|
|
|
@ -51,7 +51,7 @@ namespace api {
|
|||
class context : public tactic_manager {
|
||||
struct add_plugins { add_plugins(ast_manager & m); };
|
||||
context_params m_params;
|
||||
bool m_user_ref_count; //!< if true, the user is responsible for managing referenc counters.
|
||||
bool m_user_ref_count; //!< if true, the user is responsible for managing reference counters.
|
||||
scoped_ptr<ast_manager> m_manager;
|
||||
add_plugins m_plugins;
|
||||
|
||||
|
@ -138,7 +138,7 @@ namespace api {
|
|||
datatype_decl_plugin * get_dt_plugin() const { return m_dt_plugin; }
|
||||
|
||||
Z3_error_code get_error_code() const { return m_error_code; }
|
||||
void reset_error_code() { m_error_code = Z3_OK; }
|
||||
void reset_error_code();
|
||||
void set_error_code(Z3_error_code err);
|
||||
void set_error_handler(Z3_error_handler h) { m_error_handler = h; }
|
||||
// Sign an error if solver is searching
|
||||
|
@ -158,7 +158,7 @@ namespace api {
|
|||
// Create a numeral of the given sort
|
||||
expr * mk_numeral_core(rational const & n, sort * s);
|
||||
|
||||
// Return a conjuction that will be exposed to the "external" world.
|
||||
// Return a conjunction that will be exposed to the "external" world.
|
||||
expr * mk_and(unsigned num_exprs, expr * const * exprs);
|
||||
|
||||
// Hack for preventing an AST for being GC when ref-count is not used
|
||||
|
@ -220,19 +220,11 @@ namespace api {
|
|||
|
||||
// ------------------------
|
||||
//
|
||||
// Parser interface for backward compatibility
|
||||
// Parser interface
|
||||
//
|
||||
// ------------------------
|
||||
|
||||
// TODO: move to a "parser" object visible to the external world.
|
||||
std::string m_smtlib_error_buffer;
|
||||
smtlib::parser * m_smtlib_parser;
|
||||
bool m_smtlib_parser_has_decls;
|
||||
ptr_vector<func_decl> m_smtlib_parser_decls;
|
||||
ptr_vector<sort> m_smtlib_parser_sorts;
|
||||
|
||||
void reset_parser();
|
||||
void extract_smtlib_parser_decls();
|
||||
std::string m_parser_error_buffer;
|
||||
|
||||
};
|
||||
|
||||
|
|
|
@ -45,14 +45,14 @@ namespace api {
|
|||
ast_ref_vector m_trail;
|
||||
public:
|
||||
fixedpoint_context(ast_manager& m, smt_params& p):
|
||||
m_state(0),
|
||||
m_reduce_app(0),
|
||||
m_reduce_assign(0),
|
||||
m_state(nullptr),
|
||||
m_reduce_app(nullptr),
|
||||
m_reduce_assign(nullptr),
|
||||
m_context(m, m_register_engine, p),
|
||||
m_trail(m) {}
|
||||
|
||||
virtual ~fixedpoint_context() {}
|
||||
family_id get_family_id() const { return const_cast<datalog::context&>(m_context).get_decl_util().get_family_id(); }
|
||||
~fixedpoint_context() override {}
|
||||
family_id get_family_id() const override { return const_cast<datalog::context&>(m_context).get_decl_util().get_family_id(); }
|
||||
void set_state(void* state) {
|
||||
SASSERT(!m_state);
|
||||
m_state = state;
|
||||
|
@ -73,8 +73,8 @@ namespace api {
|
|||
void set_reduce_assign(reduce_assign_callback_fptr f) {
|
||||
m_reduce_assign = f;
|
||||
}
|
||||
virtual void reduce(func_decl* f, unsigned num_args, expr * const* args, expr_ref& result) {
|
||||
expr* r = 0;
|
||||
void reduce(func_decl* f, unsigned num_args, expr * const* args, expr_ref& result) override {
|
||||
expr* r = nullptr;
|
||||
if (m_reduce_app) {
|
||||
m_reduce_app(m_state, f, num_args, args, &r);
|
||||
result = r;
|
||||
|
@ -85,12 +85,12 @@ namespace api {
|
|||
m_trail.push_back(r);
|
||||
}
|
||||
// allow fallthrough.
|
||||
if (r == 0) {
|
||||
if (r == nullptr) {
|
||||
ast_manager& m = m_context.get_manager();
|
||||
result = m.mk_app(f, num_args, args);
|
||||
}
|
||||
}
|
||||
virtual void reduce_assign(func_decl* f, unsigned num_args, expr * const* args, unsigned num_out, expr* const* outs) {
|
||||
void reduce_assign(func_decl* f, unsigned num_args, expr * const* args, unsigned num_out, expr* const* outs) override {
|
||||
if (m_reduce_assign) {
|
||||
m_trail.push_back(f);
|
||||
for (unsigned i = 0; i < num_args; ++i) {
|
||||
|
@ -171,22 +171,22 @@ extern "C" {
|
|||
sort * r = to_sort(s);
|
||||
if (Z3_get_sort_kind(c, s) != Z3_RELATION_SORT) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
if (col >= r->get_num_parameters()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
parameter const& p = r->get_parameter(col);
|
||||
if (!p.is_ast() || !is_sort(p.get_ast())) {
|
||||
UNREACHABLE();
|
||||
warning_msg("Sort parameter expected at %d", col);
|
||||
SET_ERROR_CODE(Z3_INTERNAL_FATAL);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_sort res = of_sort(to_sort(p.get_ast()));
|
||||
RETURN_Z3(res);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, __uint64 size) {
|
||||
|
@ -196,7 +196,7 @@ extern "C" {
|
|||
sort* s = mk_c(c)->datalog_util().mk_sort(to_symbol(name), size);
|
||||
mk_c(c)->save_ast_trail(s);
|
||||
RETURN_Z3(of_sort(s));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_get_finite_domain_sort_size(Z3_context c, Z3_sort s, __uint64 * out) {
|
||||
|
@ -228,7 +228,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(d);
|
||||
Z3_fixedpoint r = of_datalog(d);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_fixedpoint_inc_ref(Z3_context c, Z3_fixedpoint s) {
|
||||
|
@ -331,7 +331,7 @@ extern "C" {
|
|||
expr* e = to_fixedpoint_ref(d)->ctx().get_answer_as_formula();
|
||||
mk_c(c)->save_ast_trail(e);
|
||||
RETURN_Z3(of_expr(e));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_fixedpoint_get_reason_unknown(Z3_context c,Z3_fixedpoint d) {
|
||||
|
@ -366,7 +366,7 @@ extern "C" {
|
|||
ctx.set_ignore_check(true);
|
||||
if (!parse_smt2_commands(ctx, s)) {
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
Z3_ast_vector_ref* v = alloc(Z3_ast_vector_ref, *mk_c(c), m);
|
||||
|
@ -398,7 +398,7 @@ extern "C" {
|
|||
std::string str(s);
|
||||
std::istringstream is(str);
|
||||
RETURN_Z3(Z3_fixedpoint_from_stream(c, d, is));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast_vector Z3_API Z3_fixedpoint_from_file(
|
||||
|
@ -410,10 +410,10 @@ extern "C" {
|
|||
std::ifstream is(s);
|
||||
if (!is) {
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
RETURN_Z3(Z3_fixedpoint_from_stream(c, d, is));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
|
||||
|
@ -426,7 +426,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(st);
|
||||
Z3_stats r = of_stats(st);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_fixedpoint_register_relation(Z3_context c,Z3_fixedpoint d, Z3_func_decl f) {
|
||||
|
@ -473,7 +473,7 @@ extern "C" {
|
|||
v->m_ast_vector.push_back(m.mk_not(queries[i].get()));
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast_vector Z3_API Z3_fixedpoint_get_assertions(
|
||||
|
@ -490,7 +490,7 @@ extern "C" {
|
|||
v->m_ast_vector.push_back(to_fixedpoint_ref(d)->ctx().get_assertion(i));
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_fixedpoint_set_reduce_assign_callback(
|
||||
|
@ -541,7 +541,7 @@ extern "C" {
|
|||
expr_ref r = to_fixedpoint_ref(d)->get_cover_delta(level, to_func_decl(pred));
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
RETURN_Z3(of_expr(r.get()));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_fixedpoint_add_cover(Z3_context c, Z3_fixedpoint d, int level, Z3_func_decl pred, Z3_ast property) {
|
||||
|
@ -573,7 +573,7 @@ extern "C" {
|
|||
to_fixedpoint_ref(f)->collect_param_descrs(d->m_descrs);
|
||||
Z3_param_descrs r = of_param_descrs(d);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_fixedpoint_set_params(Z3_context c, Z3_fixedpoint d, Z3_params p) {
|
||||
|
|
|
@ -37,8 +37,8 @@ namespace api {
|
|||
struct Z3_fixedpoint_ref : public api::object {
|
||||
api::fixedpoint_context * m_datalog;
|
||||
params_ref m_params;
|
||||
Z3_fixedpoint_ref(api::context& c): api::object(c), m_datalog(0) {}
|
||||
virtual ~Z3_fixedpoint_ref() { dealloc(m_datalog); }
|
||||
Z3_fixedpoint_ref(api::context& c): api::object(c), m_datalog(nullptr) {}
|
||||
~Z3_fixedpoint_ref() override { dealloc(m_datalog); }
|
||||
};
|
||||
|
||||
inline Z3_fixedpoint_ref * to_fixedpoint(Z3_fixedpoint s) { return reinterpret_cast<Z3_fixedpoint_ref *>(s); }
|
||||
|
|
|
@ -49,7 +49,7 @@ Notes:
|
|||
expr* e = to_fixedpoint_ref(d)->ctx().get_ground_sat_answer();
|
||||
mk_c(c)->save_ast_trail(e);
|
||||
RETURN_Z3(of_expr(e));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast_vector Z3_API Z3_fixedpoint_get_rules_along_trace(
|
||||
|
@ -69,7 +69,7 @@ Notes:
|
|||
v->m_ast_vector.push_back(rules[i].get());
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_symbol Z3_API Z3_fixedpoint_get_rule_names_along_trace(
|
||||
|
@ -90,7 +90,7 @@ Notes:
|
|||
ss << ";" << names[i].str();
|
||||
}
|
||||
RETURN_Z3(of_symbol(symbol(ss.str().substr(1).c_str())));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_fixedpoint_add_invariant(Z3_context c, Z3_fixedpoint d, Z3_func_decl pred, Z3_ast property) {
|
||||
|
@ -108,6 +108,6 @@ Notes:
|
|||
expr_ref r = to_fixedpoint_ref(d)->ctx().get_reachable(to_func_decl(pred));
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
RETURN_Z3(of_expr(r.get()));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
|
|
|
@ -52,12 +52,12 @@ extern "C" {
|
|||
|
||||
{
|
||||
datatype_decl * dt = mk_datatype_decl(dt_util, to_symbol(name), 0, nullptr, 1, constrs);
|
||||
bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &dt, 0, 0, tuples);
|
||||
bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &dt, 0, nullptr, tuples);
|
||||
del_datatype_decl(dt);
|
||||
|
||||
if (!is_ok) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -82,7 +82,7 @@ extern "C" {
|
|||
proj_decls[i] = of_func_decl(_accs[i]);
|
||||
}
|
||||
RETURN_Z3_mk_tuple_sort(of_sort(tuple));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_mk_enumeration_sort(Z3_context c,
|
||||
|
@ -108,18 +108,18 @@ extern "C" {
|
|||
recognizer_s += e_name.str();
|
||||
symbol recognizer(recognizer_s.c_str());
|
||||
|
||||
constrs.push_back(mk_constructor_decl(e_name, recognizer, 0, 0));
|
||||
constrs.push_back(mk_constructor_decl(e_name, recognizer, 0, nullptr));
|
||||
}
|
||||
|
||||
|
||||
{
|
||||
datatype_decl * dt = mk_datatype_decl(dt_util, to_symbol(name), 0, 0, n, constrs.c_ptr());
|
||||
bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &dt, 0, 0, sorts);
|
||||
datatype_decl * dt = mk_datatype_decl(dt_util, to_symbol(name), 0, nullptr, n, constrs.c_ptr());
|
||||
bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &dt, 0, nullptr, sorts);
|
||||
del_datatype_decl(dt);
|
||||
|
||||
if (!is_ok) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -137,13 +137,13 @@ extern "C" {
|
|||
func_decl* decl = (decls)[i];
|
||||
mk_c(c)->save_multiple_ast_trail(decl);
|
||||
enum_consts[i] = of_func_decl(decl);
|
||||
decl = dt_util.get_constructor_recognizer(decl);
|
||||
decl = dt_util.get_constructor_is(decl);
|
||||
mk_c(c)->save_multiple_ast_trail(decl);
|
||||
enum_testers[i] = of_func_decl(decl);
|
||||
}
|
||||
|
||||
RETURN_Z3_mk_enumeration_sort(of_sort(e));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_mk_list_sort(Z3_context c,
|
||||
|
@ -168,7 +168,7 @@ extern "C" {
|
|||
mk_accessor_decl(m, symbol("tail"), type_ref(0))
|
||||
};
|
||||
constructor_decl* constrs[2] = {
|
||||
mk_constructor_decl(symbol("nil"), symbol("is_nil"), 0, 0),
|
||||
mk_constructor_decl(symbol("nil"), symbol("is_nil"), 0, nullptr),
|
||||
// Leo: SMT 2.0 document uses 'insert' instead of cons
|
||||
mk_constructor_decl(symbol("cons"), symbol("is_cons"), 2, head_tail)
|
||||
};
|
||||
|
@ -176,12 +176,12 @@ extern "C" {
|
|||
sort_ref_vector sorts(m);
|
||||
{
|
||||
datatype_decl * decl = mk_datatype_decl(dt_util, to_symbol(name), 0, nullptr, 2, constrs);
|
||||
bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &decl, 0, 0, sorts);
|
||||
bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &decl, 0, nullptr, sorts);
|
||||
del_datatype_decl(decl);
|
||||
|
||||
if (!is_ok) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
}
|
||||
sort * s = sorts.get(0);
|
||||
|
@ -196,7 +196,7 @@ extern "C" {
|
|||
*nil_decl = of_func_decl(f);
|
||||
}
|
||||
if (is_nil_decl) {
|
||||
f = data_util.get_constructor_recognizer(cnstrs[0]);
|
||||
f = data_util.get_constructor_is(cnstrs[0]);
|
||||
mk_c(c)->save_multiple_ast_trail(f);
|
||||
*is_nil_decl = of_func_decl(f);
|
||||
}
|
||||
|
@ -206,7 +206,7 @@ extern "C" {
|
|||
*cons_decl = of_func_decl(f);
|
||||
}
|
||||
if (is_cons_decl) {
|
||||
f = data_util.get_constructor_recognizer(cnstrs[1]);
|
||||
f = data_util.get_constructor_is(cnstrs[1]);
|
||||
mk_c(c)->save_multiple_ast_trail(f);
|
||||
*is_cons_decl = of_func_decl(f);
|
||||
}
|
||||
|
@ -225,7 +225,7 @@ extern "C" {
|
|||
*tail_decl = of_func_decl(f);
|
||||
}
|
||||
RETURN_Z3_mk_list_sort(of_sort(s));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
struct constructor {
|
||||
|
@ -259,7 +259,7 @@ extern "C" {
|
|||
cnstr->m_sort_refs.push_back(sort_refs[i]);
|
||||
}
|
||||
RETURN_Z3(reinterpret_cast<Z3_constructor>(cnstr));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
|
||||
|
@ -290,7 +290,7 @@ extern "C" {
|
|||
*constructor_decl = of_func_decl(f);
|
||||
}
|
||||
if (tester) {
|
||||
func_decl* f2 = data_util.get_constructor_recognizer(f);
|
||||
func_decl* f2 = data_util.get_constructor_is(f);
|
||||
mk_c(c)->save_multiple_ast_trail(f2);
|
||||
*tester = of_func_decl(f2);
|
||||
}
|
||||
|
@ -349,12 +349,12 @@ extern "C" {
|
|||
sort_ref_vector sorts(m);
|
||||
{
|
||||
datatype_decl * data = mk_datatype_decl(c, name, num_constructors, constructors);
|
||||
bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &data, 0, 0, sorts);
|
||||
bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &data, 0, nullptr, sorts);
|
||||
del_datatype_decl(data);
|
||||
|
||||
if (!is_ok) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
}
|
||||
sort * s = sorts.get(0);
|
||||
|
@ -367,7 +367,7 @@ extern "C" {
|
|||
cn->m_constructor = cnstrs[i];
|
||||
}
|
||||
RETURN_Z3_mk_datatype(of_sort(s));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
typedef ptr_vector<constructor> constructor_list;
|
||||
|
@ -383,7 +383,7 @@ extern "C" {
|
|||
result->push_back(reinterpret_cast<constructor*>(constructors[i]));
|
||||
}
|
||||
RETURN_Z3(reinterpret_cast<Z3_constructor_list>(result));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_del_constructor_list(Z3_context c, Z3_constructor_list clist) {
|
||||
|
@ -412,7 +412,7 @@ extern "C" {
|
|||
datas.push_back(mk_datatype_decl(c, sort_names[i], cl->size(), reinterpret_cast<Z3_constructor*>(cl->c_ptr())));
|
||||
}
|
||||
sort_ref_vector _sorts(m);
|
||||
bool ok = mk_c(c)->get_dt_plugin()->mk_datatypes(datas.size(), datas.c_ptr(), 0, 0, _sorts);
|
||||
bool ok = mk_c(c)->get_dt_plugin()->mk_datatypes(datas.size(), datas.c_ptr(), 0, nullptr, _sorts);
|
||||
del_datatype_decls(datas.size(), datas.c_ptr());
|
||||
|
||||
if (!ok) {
|
||||
|
@ -454,17 +454,17 @@ extern "C" {
|
|||
|
||||
Z3_func_decl get_datatype_sort_constructor_core(Z3_context c, Z3_sort t, unsigned idx) {
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_VALID_AST(t, 0);
|
||||
CHECK_VALID_AST(t, nullptr);
|
||||
sort * _t = to_sort(t);
|
||||
datatype_util& dt_util = mk_c(c)->dtutil();
|
||||
if (!dt_util.is_datatype(_t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
ptr_vector<func_decl> const & decls = *dt_util.get_datatype_constructors(_t);
|
||||
if (idx >= decls.size()) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
func_decl* decl = (decls)[idx];
|
||||
mk_c(c)->save_ast_trail(decl);
|
||||
|
@ -477,7 +477,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_func_decl r = get_datatype_sort_constructor_core(c, t, idx);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_func_decl Z3_API Z3_get_datatype_sort_recognizer(Z3_context c, Z3_sort t, unsigned idx) {
|
||||
|
@ -489,18 +489,18 @@ extern "C" {
|
|||
|
||||
if (!dt_util.is_datatype(_t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ptr_vector<func_decl> const & decls = *dt_util.get_datatype_constructors(_t);
|
||||
if (idx >= decls.size()) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
func_decl* decl = (decls)[idx];
|
||||
decl = dt_util.get_constructor_recognizer(decl);
|
||||
decl = dt_util.get_constructor_is(decl);
|
||||
mk_c(c)->save_ast_trail(decl);
|
||||
RETURN_Z3(of_func_decl(decl));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_func_decl Z3_API Z3_get_datatype_sort_constructor_accessor(Z3_context c, Z3_sort t, unsigned idx_c, unsigned idx_a) {
|
||||
|
@ -512,28 +512,28 @@ extern "C" {
|
|||
|
||||
if (!dt_util.is_datatype(_t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ptr_vector<func_decl> const & decls = *dt_util.get_datatype_constructors(_t);
|
||||
if (idx_c >= decls.size()) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
func_decl* decl = (decls)[idx_c];
|
||||
if (decl->get_arity() <= idx_a) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ptr_vector<func_decl> const & accs = *dt_util.get_constructor_accessors(decl);
|
||||
SASSERT(accs.size() == decl->get_arity());
|
||||
if (accs.size() <= idx_a) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
decl = (accs)[idx_a];
|
||||
mk_c(c)->save_ast_trail(decl);
|
||||
RETURN_Z3(of_func_decl(decl));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_func_decl Z3_API Z3_get_tuple_sort_mk_decl(Z3_context c, Z3_sort t) {
|
||||
|
@ -544,11 +544,11 @@ extern "C" {
|
|||
datatype_util& dt_util = mk_c(c)->dtutil();
|
||||
if (!dt_util.is_datatype(tuple) || dt_util.is_recursive(tuple) || dt_util.get_datatype_num_constructors(tuple) != 1) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_func_decl r = get_datatype_sort_constructor_core(c, t, 0);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_get_tuple_sort_num_fields(Z3_context c, Z3_sort t) {
|
||||
|
@ -579,22 +579,22 @@ extern "C" {
|
|||
datatype_util& dt_util = mk_c(c)->dtutil();
|
||||
if (!dt_util.is_datatype(tuple) || dt_util.is_recursive(tuple) || dt_util.get_datatype_num_constructors(tuple) != 1) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ptr_vector<func_decl> const & decls = *dt_util.get_datatype_constructors(tuple);
|
||||
if (decls.size() != 1) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ptr_vector<func_decl> const & accs = *dt_util.get_constructor_accessors((decls)[0]);
|
||||
if (accs.size() <= i) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
func_decl* acc = (accs)[i];
|
||||
mk_c(c)->save_ast_trail(acc);
|
||||
RETURN_Z3(of_func_decl(acc));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_datatype_update_field(
|
||||
|
@ -614,7 +614,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(r);
|
||||
check_sorts(c, r);
|
||||
RETURN_Z3(of_ast(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -56,7 +56,7 @@ extern "C" {
|
|||
sort * s = ctx->fpautil().mk_rm_sort();
|
||||
mk_c(c)->save_ast_trail(s);
|
||||
RETURN_Z3(of_sort(s));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_round_nearest_ties_to_even(Z3_context c) {
|
||||
|
@ -67,7 +67,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_round_nearest_ties_to_even();
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_rne(Z3_context c) {
|
||||
|
@ -78,7 +78,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_round_nearest_ties_to_even();
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_round_nearest_ties_to_away(Z3_context c) {
|
||||
|
@ -89,7 +89,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_round_nearest_ties_to_away();
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_rna(Z3_context c) {
|
||||
|
@ -100,7 +100,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_round_nearest_ties_to_away();
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_round_toward_positive(Z3_context c) {
|
||||
|
@ -111,7 +111,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_round_toward_positive();
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_rtp(Z3_context c) {
|
||||
|
@ -122,7 +122,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_round_toward_positive();
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_round_toward_negative(Z3_context c) {
|
||||
|
@ -133,7 +133,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_round_toward_negative();
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_rtn(Z3_context c) {
|
||||
|
@ -144,7 +144,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_round_toward_negative();
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_round_toward_zero(Z3_context c) {
|
||||
|
@ -155,7 +155,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_round_toward_zero();
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_rtz(Z3_context c) {
|
||||
|
@ -166,7 +166,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_round_toward_zero();
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
|
||||
|
@ -181,7 +181,7 @@ extern "C" {
|
|||
sort * s = ctx->fpautil().mk_float_sort(ebits, sbits);
|
||||
ctx->save_ast_trail(s);
|
||||
RETURN_Z3(of_sort(s));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_mk_fpa_sort_half(Z3_context c) {
|
||||
|
@ -220,50 +220,50 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_mk_fpa_nan(c, s);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_VALID_AST(s, 0);
|
||||
CHECK_VALID_AST(s, nullptr);
|
||||
if (!is_fp_sort(c, s)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_nan(to_sort(s));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, Z3_bool negative) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_mk_fpa_inf(c, s, negative);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_VALID_AST(s, 0);
|
||||
CHECK_VALID_AST(s, nullptr);
|
||||
if (!is_fp_sort(c, s)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = negative != 0 ? ctx->fpautil().mk_ninf(to_sort(s)) :
|
||||
ctx->fpautil().mk_pinf(to_sort(s));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, Z3_bool negative) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_mk_fpa_inf(c, s, negative);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_VALID_AST(s, 0);
|
||||
CHECK_VALID_AST(s, nullptr);
|
||||
if (!is_fp_sort(c, s)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = negative != 0 ? ctx->fpautil().mk_nzero(to_sort(s)) :
|
||||
ctx->fpautil().mk_pzero(to_sort(s));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_fp(Z3_context c, Z3_ast sgn, Z3_ast exp, Z3_ast sig) {
|
||||
|
@ -272,13 +272,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_bv(c, sgn) || !is_bv(c, exp) || !is_bv(c, sig)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_fp(to_expr(sgn), to_expr(exp), to_expr(sig));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_numeral_float(Z3_context c, float v, Z3_sort ty) {
|
||||
|
@ -287,7 +287,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp_sort(c, ty)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
scoped_mpf tmp(ctx->fpautil().fm());
|
||||
|
@ -298,7 +298,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_value(tmp);
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_numeral_double(Z3_context c, double v, Z3_sort ty) {
|
||||
|
@ -307,7 +307,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp_sort(c, ty)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
scoped_mpf tmp(ctx->fpautil().fm());
|
||||
|
@ -315,7 +315,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_value(tmp);
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_numeral_int(Z3_context c, signed v, Z3_sort ty) {
|
||||
|
@ -324,7 +324,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp_sort(c, ty)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
scoped_mpf tmp(ctx->fpautil().fm());
|
||||
|
@ -335,7 +335,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_value(tmp);
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_numeral_int_uint(Z3_context c, Z3_bool sgn, signed exp, unsigned sig, Z3_sort ty) {
|
||||
|
@ -344,7 +344,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp_sort(c, ty)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
scoped_mpf tmp(ctx->fpautil().fm());
|
||||
|
@ -355,7 +355,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_value(tmp);
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_numeral_int64_uint64(Z3_context c, Z3_bool sgn, __int64 exp, __uint64 sig, Z3_sort ty) {
|
||||
|
@ -364,7 +364,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp_sort(c, ty)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
scoped_mpf tmp(ctx->fpautil().fm());
|
||||
|
@ -375,7 +375,7 @@ extern "C" {
|
|||
expr * a = ctx->fpautil().mk_value(tmp);
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t) {
|
||||
|
@ -384,13 +384,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_abs(to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t) {
|
||||
|
@ -399,13 +399,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_neg(to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_add(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -414,13 +414,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_rm(c, rm) || !is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_add(to_expr(rm), to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_sub(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -429,13 +429,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_rm(c, rm) || !is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_sub(to_expr(rm), to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_mul(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -444,13 +444,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_rm(c, rm) || !is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_mul(to_expr(rm), to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_div(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -459,13 +459,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_rm(c, rm) || !is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_div(to_expr(rm), to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_fma(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2, Z3_ast t3) {
|
||||
|
@ -474,13 +474,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_rm(c, rm) || !is_fp(c, t1) || !is_fp(c, t2) || !is_fp(c, t3)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_fma(to_expr(rm), to_expr(t1), to_expr(t2), to_expr(t3));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_sqrt(Z3_context c, Z3_ast rm, Z3_ast t) {
|
||||
|
@ -489,13 +489,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_rm(c, rm) || !is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_sqrt(to_expr(rm), to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_rem(Z3_context c, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -504,13 +504,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_rem(to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_round_to_integral(Z3_context c, Z3_ast rm, Z3_ast t) {
|
||||
|
@ -519,13 +519,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_rm(c, rm) || !is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_round_to_integral(to_expr(rm), to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_min(Z3_context c, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -534,13 +534,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_min(to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_max(Z3_context c, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -549,13 +549,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_max(to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_leq(Z3_context c, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -564,13 +564,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_le(to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_lt(Z3_context c, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -579,13 +579,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_lt(to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_geq(Z3_context c, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -594,13 +594,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_ge(to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_gt(Z3_context c, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -609,13 +609,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_gt(to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_eq(Z3_context c, Z3_ast t1, Z3_ast t2) {
|
||||
|
@ -624,13 +624,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t1) || !is_fp(c, t2)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_float_eq(to_expr(t1), to_expr(t2));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_is_normal(Z3_context c, Z3_ast t) {
|
||||
|
@ -639,13 +639,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_is_normal(to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_is_subnormal(Z3_context c, Z3_ast t) {
|
||||
|
@ -654,13 +654,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_is_subnormal(to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_is_zero(Z3_context c, Z3_ast t) {
|
||||
|
@ -669,13 +669,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_is_zero(to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_is_infinite(Z3_context c, Z3_ast t) {
|
||||
|
@ -684,13 +684,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_is_inf(to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_is_nan(Z3_context c, Z3_ast t) {
|
||||
|
@ -699,13 +699,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_is_nan(to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_is_negative(Z3_context c, Z3_ast t) {
|
||||
|
@ -714,13 +714,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_is_negative(to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_is_positive(Z3_context c, Z3_ast t) {
|
||||
|
@ -729,13 +729,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_is_positive(to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
|
||||
|
@ -745,19 +745,19 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_bv(c, bv) || !is_fp_sort(c, s)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
fpa_util & fu = ctx->fpautil();
|
||||
if (!ctx->bvutil().is_bv(to_expr(bv)) ||
|
||||
!fu.is_float(to_sort(s))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
expr * a = fu.mk_to_fp(to_sort(s), to_expr(bv));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_to_fp_float(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s) {
|
||||
|
@ -770,12 +770,12 @@ extern "C" {
|
|||
!fu.is_float(to_expr(t)) ||
|
||||
!fu.is_float(to_sort(s))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
expr * a = fu.mk_to_fp(to_sort(s), to_expr(rm), to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_to_fp_real(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s) {
|
||||
|
@ -788,12 +788,12 @@ extern "C" {
|
|||
!ctx->autil().is_real(to_expr(t)) ||
|
||||
!fu.is_float(to_sort(s))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
expr * a = fu.mk_to_fp(to_sort(s), to_expr(rm), to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_to_fp_signed(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s) {
|
||||
|
@ -806,12 +806,12 @@ extern "C" {
|
|||
!ctx->bvutil().is_bv(to_expr(t)) ||
|
||||
!fu.is_float(to_sort(s))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
expr * a = fu.mk_to_fp(to_sort(s), to_expr(rm), to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_to_fp_unsigned(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s) {
|
||||
|
@ -824,12 +824,12 @@ extern "C" {
|
|||
!ctx->bvutil().is_bv(to_expr(t)) ||
|
||||
!fu.is_float(to_sort(s))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
expr * a = fu.mk_to_fp_unsigned(to_sort(s), to_expr(rm), to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_to_ubv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz) {
|
||||
|
@ -838,13 +838,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_rm(c, rm) || !is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_to_ubv(to_expr(rm), to_expr(t), sz);
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_to_sbv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz) {
|
||||
|
@ -853,13 +853,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_rm(c, rm) || !is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_to_sbv(to_expr(rm), to_expr(t), sz);
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_to_real(Z3_context c, Z3_ast t) {
|
||||
|
@ -868,13 +868,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
expr * a = ctx->fpautil().mk_to_real(to_expr(t));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_fpa_get_ebits(Z3_context c, Z3_sort s) {
|
||||
|
@ -911,7 +911,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(t, 0);
|
||||
CHECK_VALID_AST(t, 0);
|
||||
if (sgn == 0) {
|
||||
if (sgn == nullptr) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
}
|
||||
|
@ -939,8 +939,8 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_fpa_get_numeral_sign_bv(c, t);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(t, 0);
|
||||
CHECK_VALID_AST(t, 0);
|
||||
CHECK_NON_NULL(t, nullptr);
|
||||
CHECK_VALID_AST(t, nullptr);
|
||||
ast_manager & m = mk_c(c)->m();
|
||||
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
||||
family_id fid = mk_c(c)->get_fpa_fid();
|
||||
|
@ -949,13 +949,13 @@ extern "C" {
|
|||
expr * e = to_expr(t);
|
||||
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
scoped_mpf val(mpfm);
|
||||
bool r = plugin->is_numeral(to_expr(t), val);
|
||||
if (!r || mpfm.is_nan(val)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
app * a;
|
||||
if (mpfm.is_pos(val))
|
||||
|
@ -964,15 +964,15 @@ extern "C" {
|
|||
a = ctx->bvutil().mk_numeral(1, 1);
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_fpa_get_numeral_significand_bv(Z3_context c, Z3_ast t) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_fpa_get_numeral_significand_bv(c, t);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(t, 0);
|
||||
CHECK_VALID_AST(t, 0);
|
||||
CHECK_NON_NULL(t, nullptr);
|
||||
CHECK_VALID_AST(t, nullptr);
|
||||
ast_manager & m = mk_c(c)->m();
|
||||
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
||||
unsynch_mpq_manager & mpqm = mpfm.mpq_manager();
|
||||
|
@ -982,13 +982,13 @@ extern "C" {
|
|||
expr * e = to_expr(t);
|
||||
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
scoped_mpf val(mpfm);
|
||||
bool r = plugin->is_numeral(e, val);
|
||||
if (!r || !(mpfm.is_normal(val) || mpfm.is_denormal(val) || mpfm.is_zero(val) || mpfm.is_inf(val))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
unsigned sbits = val.get().get_sbits();
|
||||
scoped_mpq q(mpqm);
|
||||
|
@ -997,15 +997,15 @@ extern "C" {
|
|||
app * a = mk_c(c)->bvutil().mk_numeral(q.get(), sbits-1);
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_fpa_get_numeral_significand_string(Z3_context c, Z3_ast t) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_fpa_get_numeral_significand_string(c, t);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(t, 0);
|
||||
CHECK_VALID_AST(t, 0);
|
||||
CHECK_NON_NULL(t, nullptr);
|
||||
CHECK_VALID_AST(t, nullptr);
|
||||
ast_manager & m = mk_c(c)->m();
|
||||
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
||||
unsynch_mpq_manager & mpqm = mpfm.mpq_manager();
|
||||
|
@ -1041,7 +1041,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(t, 0);
|
||||
CHECK_VALID_AST(t, 0);
|
||||
if (n == 0) {
|
||||
if (n == nullptr) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
}
|
||||
|
@ -1076,8 +1076,8 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_fpa_get_numeral_exponent_string(c, t, biased);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(t, 0);
|
||||
CHECK_VALID_AST(t, 0);
|
||||
CHECK_NON_NULL(t, nullptr);
|
||||
CHECK_VALID_AST(t, nullptr);
|
||||
ast_manager & m = mk_c(c)->m();
|
||||
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
||||
family_id fid = mk_c(c)->get_fpa_fid();
|
||||
|
@ -1119,7 +1119,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(t, 0);
|
||||
CHECK_VALID_AST(t, 0);
|
||||
if (n == 0) {
|
||||
if (n == nullptr) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
}
|
||||
|
@ -1161,8 +1161,8 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_fpa_get_numeral_exponent_bv(c, t, biased);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(t, 0);
|
||||
CHECK_VALID_AST(t, 0);
|
||||
CHECK_NON_NULL(t, nullptr);
|
||||
CHECK_VALID_AST(t, nullptr);
|
||||
ast_manager & m = mk_c(c)->m();
|
||||
mpf_manager & mpfm = mk_c(c)->fpautil().fm();
|
||||
family_id fid = mk_c(c)->get_fpa_fid();
|
||||
|
@ -1170,13 +1170,13 @@ extern "C" {
|
|||
expr * e = to_expr(t);
|
||||
if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
scoped_mpf val(mpfm);
|
||||
bool r = plugin->is_numeral(e, val);
|
||||
if (!r || !(mpfm.is_normal(val) || mpfm.is_denormal(val) || mpfm.is_zero(val) || mpfm.is_inf(val))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
unsigned ebits = val.get().get_ebits();
|
||||
mpf_exp_t exp;
|
||||
|
@ -1194,23 +1194,23 @@ extern "C" {
|
|||
app * a = mk_c(c)->bvutil().mk_numeral(exp, ebits);
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_to_ieee_bv(Z3_context c, Z3_ast t) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_mk_fpa_to_ieee_bv(c, t);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(t, 0);
|
||||
CHECK_VALID_AST(t, 0);
|
||||
CHECK_NON_NULL(t, nullptr);
|
||||
CHECK_VALID_AST(t, nullptr);
|
||||
if (!is_fp(c, t)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
api::context * ctx = mk_c(c);
|
||||
Z3_ast r = of_ast(ctx->fpautil().mk_to_ieee_bv(to_expr(t)));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_fpa_to_fp_int_real(Z3_context c, Z3_ast rm, Z3_ast exp, Z3_ast sig, Z3_sort s) {
|
||||
|
@ -1224,12 +1224,12 @@ extern "C" {
|
|||
!ctx->autil().is_real(to_expr(sig)) ||
|
||||
!fu.is_float(to_sort(s))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
expr * a = fu.mk_to_fp(to_sort(s), to_expr(rm), to_expr(exp), to_expr(sig));
|
||||
ctx->save_ast_trail(a);
|
||||
RETURN_Z3(of_expr(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_fpa_is_numeral_nan(Z3_context c, Z3_ast t) {
|
||||
|
|
|
@ -30,14 +30,14 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (proofs != 0 && !mk_c(c)->m().proofs_enabled()) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_goal_ref * g = alloc(Z3_goal_ref, *mk_c(c));
|
||||
g->m_goal = alloc(goal, mk_c(c)->m(), proofs != 0, models != 0, unsat_cores != 0);
|
||||
mk_c(c)->save_object(g);
|
||||
Z3_goal r = of_goal(g);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_goal_inc_ref(Z3_context c, Z3_goal g) {
|
||||
|
@ -119,12 +119,12 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (idx >= to_goal_ref(g)->size()) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
expr * result = to_goal_ref(g)->form(idx);
|
||||
mk_c(c)->save_ast_trail(result);
|
||||
RETURN_Z3(of_ast(result));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_goal_num_exprs(Z3_context c, Z3_goal g) {
|
||||
|
@ -161,7 +161,7 @@ extern "C" {
|
|||
mk_c(target)->save_object(_r);
|
||||
Z3_goal r = of_goal(_r);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_goal_to_string(Z3_context c, Z3_goal g) {
|
||||
|
|
|
@ -24,11 +24,11 @@ Revision History:
|
|||
struct Z3_goal_ref : public api::object {
|
||||
goal_ref m_goal;
|
||||
Z3_goal_ref(api::context& c) : api::object(c) {}
|
||||
virtual ~Z3_goal_ref() {}
|
||||
~Z3_goal_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_goal_ref * to_goal(Z3_goal g) { return reinterpret_cast<Z3_goal_ref *>(g); }
|
||||
inline Z3_goal of_goal(Z3_goal_ref * g) { return reinterpret_cast<Z3_goal>(g); }
|
||||
inline goal_ref to_goal_ref(Z3_goal g) { return g == 0 ? goal_ref() : to_goal(g)->m_goal; }
|
||||
inline goal_ref to_goal_ref(Z3_goal g) { return g == nullptr ? goal_ref() : to_goal(g)->m_goal; }
|
||||
|
||||
#endif
|
||||
|
|
|
@ -110,7 +110,7 @@ extern "C" {
|
|||
pre_parents_vec,
|
||||
interpolants,
|
||||
theory_vec,
|
||||
0); // ignore params for now FIXME
|
||||
nullptr); // ignore params for now FIXME
|
||||
|
||||
// copy result back
|
||||
for (unsigned i = 0; i < interpolants.size(); i++){
|
||||
|
@ -174,7 +174,7 @@ extern "C" {
|
|||
itp_vec,
|
||||
theory_vec);
|
||||
|
||||
*error = res ? 0 : itp_err.str().c_str();
|
||||
*error = res ? nullptr : itp_err.str().c_str();
|
||||
return res;
|
||||
}
|
||||
|
||||
|
@ -227,7 +227,7 @@ extern "C" {
|
|||
cnsts,
|
||||
_pat,
|
||||
interp,
|
||||
(interpolation_options_struct *)0 // ignore params for now
|
||||
(interpolation_options_struct *)nullptr // ignore params for now
|
||||
);
|
||||
|
||||
// copy result back
|
||||
|
@ -236,7 +236,7 @@ extern "C" {
|
|||
_m.dec_ref(interp[i]);
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_lbool Z3_API Z3_compute_interpolant(Z3_context c, Z3_ast pat, Z3_params p, Z3_ast_vector *out_interp, Z3_model *model){
|
||||
|
@ -283,7 +283,7 @@ extern "C" {
|
|||
cnsts,
|
||||
interp,
|
||||
m,
|
||||
0 // ignore params for now
|
||||
nullptr // ignore params for now
|
||||
);
|
||||
}
|
||||
catch (z3_exception & ex) {
|
||||
|
@ -297,8 +297,8 @@ extern "C" {
|
|||
|
||||
Z3_lbool status = of_lbool(_status);
|
||||
|
||||
Z3_ast_vector_ref *v = 0;
|
||||
*model = 0;
|
||||
Z3_ast_vector_ref *v = nullptr;
|
||||
*model = nullptr;
|
||||
|
||||
if (_status == l_false){
|
||||
// copy result back
|
||||
|
@ -510,36 +510,20 @@ extern "C" {
|
|||
read_error.clear();
|
||||
try {
|
||||
std::string foo(filename);
|
||||
if (foo.size() >= 5 && foo.substr(foo.size() - 5) == ".smt2"){
|
||||
Z3_ast assrts = Z3_parse_smtlib2_file(ctx, filename, 0, 0, 0, 0, 0, 0);
|
||||
Z3_app app = Z3_to_app(ctx, assrts);
|
||||
int nconjs = Z3_get_app_num_args(ctx, app);
|
||||
assertions.resize(nconjs);
|
||||
for (int k = 0; k < nconjs; k++)
|
||||
assertions[k] = Z3_get_app_arg(ctx, app, k);
|
||||
}
|
||||
else {
|
||||
Z3_parse_smtlib_file(ctx, filename, 0, 0, 0, 0, 0, 0);
|
||||
int numa = Z3_get_smtlib_num_assumptions(ctx);
|
||||
int numf = Z3_get_smtlib_num_formulas(ctx);
|
||||
int num = numa + numf;
|
||||
|
||||
assertions.resize(num);
|
||||
for (int j = 0; j < num; j++){
|
||||
if (j < numa)
|
||||
assertions[j] = Z3_get_smtlib_assumption(ctx, j);
|
||||
else
|
||||
assertions[j] = Z3_get_smtlib_formula(ctx, j - numa);
|
||||
}
|
||||
}
|
||||
Z3_ast assrts = Z3_parse_smtlib2_file(ctx, filename, 0, nullptr, nullptr, 0, nullptr, nullptr);
|
||||
Z3_app app = Z3_to_app(ctx, assrts);
|
||||
int nconjs = Z3_get_app_num_args(ctx, app);
|
||||
assertions.resize(nconjs);
|
||||
for (int k = 0; k < nconjs; k++)
|
||||
assertions[k] = Z3_get_app_arg(ctx, app, k);
|
||||
}
|
||||
catch (...) {
|
||||
read_error << "SMTLIB parse error: " << Z3_get_smtlib_error(ctx);
|
||||
read_error << "SMTLIB parse error: " << Z3_get_parser_error(ctx);
|
||||
read_msg = read_error.str();
|
||||
*error = read_msg.c_str();
|
||||
return false;
|
||||
}
|
||||
Z3_set_error_handler(ctx, 0);
|
||||
Z3_set_error_handler(ctx, nullptr);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -587,7 +571,7 @@ extern "C" {
|
|||
hash_map<Z3_ast, int> pred_map;
|
||||
|
||||
for (unsigned j = 0; j < num; j++){
|
||||
Z3_ast lhs = 0, rhs = read_cnsts[j];
|
||||
Z3_ast lhs = nullptr, rhs = read_cnsts[j];
|
||||
|
||||
if (Z3_get_decl_kind(ctx, Z3_get_app_decl(ctx, Z3_to_app(ctx, rhs))) == Z3_OP_IMPLIES){
|
||||
Z3_app app1 = Z3_to_app(ctx, rhs);
|
||||
|
|
|
@ -21,15 +21,15 @@ Revision History:
|
|||
#include "util/util.h"
|
||||
#include "util/version.h"
|
||||
|
||||
std::ostream * g_z3_log = 0;
|
||||
std::ostream * g_z3_log = nullptr;
|
||||
bool g_z3_log_enabled = false;
|
||||
|
||||
extern "C" {
|
||||
void Z3_close_log_unsafe(void) {
|
||||
if (g_z3_log != 0) {
|
||||
if (g_z3_log != nullptr) {
|
||||
dealloc(g_z3_log);
|
||||
g_z3_log_enabled = false;
|
||||
g_z3_log = 0;
|
||||
g_z3_log = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -40,12 +40,12 @@ extern "C" {
|
|||
#pragma omp critical (z3_log)
|
||||
{
|
||||
#endif
|
||||
if (g_z3_log != 0)
|
||||
if (g_z3_log != nullptr)
|
||||
Z3_close_log_unsafe();
|
||||
g_z3_log = alloc(std::ofstream, filename);
|
||||
if (g_z3_log->bad() || g_z3_log->fail()) {
|
||||
dealloc(g_z3_log);
|
||||
g_z3_log = 0;
|
||||
g_z3_log = nullptr;
|
||||
res = Z3_FALSE;
|
||||
}
|
||||
else {
|
||||
|
@ -61,13 +61,13 @@ extern "C" {
|
|||
}
|
||||
|
||||
void Z3_API Z3_append_log(Z3_string str) {
|
||||
if (g_z3_log == 0)
|
||||
if (g_z3_log == nullptr)
|
||||
return;
|
||||
#ifdef Z3_LOG_SYNC
|
||||
#pragma omp critical (z3_log)
|
||||
{
|
||||
#endif
|
||||
if (g_z3_log != 0)
|
||||
if (g_z3_log != nullptr)
|
||||
_Z3_append_log(static_cast<char const *>(str));
|
||||
#ifdef Z3_LOG_SYNC
|
||||
}
|
||||
|
@ -75,7 +75,7 @@ extern "C" {
|
|||
}
|
||||
|
||||
void Z3_API Z3_close_log(void) {
|
||||
if (g_z3_log != 0) {
|
||||
if (g_z3_log != nullptr) {
|
||||
#ifdef Z3_LOG_SYNC
|
||||
#pragma omp critical (z3_log)
|
||||
{
|
||||
|
|
|
@ -38,7 +38,7 @@ extern "C" {
|
|||
m_ref->m_model = alloc(model, mk_c(c)->m());
|
||||
mk_c(c)->save_object(m_ref);
|
||||
RETURN_Z3(of_model(m_ref));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_model_inc_ref(Z3_context c, Z3_model m) {
|
||||
|
@ -65,14 +65,14 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_model_get_const_interp(c, m, a);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(m, 0);
|
||||
CHECK_NON_NULL(m, nullptr);
|
||||
expr * r = to_model_ref(m)->get_const_interp(to_func_decl(a));
|
||||
if (!r) {
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
mk_c(c)->save_ast_trail(r);
|
||||
RETURN_Z3(of_expr(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_model_has_interp(Z3_context c, Z3_model m, Z3_func_decl a) {
|
||||
|
@ -91,17 +91,17 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_model_get_func_interp(c, m, f);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(m, 0);
|
||||
CHECK_NON_NULL(m, nullptr);
|
||||
func_interp * _fi = to_model_ref(m)->get_func_interp(to_func_decl(f));
|
||||
if (!_fi) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_func_interp_ref * fi = alloc(Z3_func_interp_ref, *mk_c(c), to_model_ref(m));
|
||||
fi->m_func_interp = _fi;
|
||||
mk_c(c)->save_object(fi);
|
||||
RETURN_Z3(of_func_interp(fi));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_model_get_num_consts(Z3_context c, Z3_model m) {
|
||||
|
@ -117,16 +117,16 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_model_get_const_decl(c, m, i);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(m, 0);
|
||||
CHECK_NON_NULL(m, nullptr);
|
||||
model * _m = to_model_ref(m);
|
||||
if (i < _m->get_num_constants()) {
|
||||
RETURN_Z3(of_func_decl(_m->get_constant(i)));
|
||||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_model_get_num_funcs(Z3_context c, Z3_model m) {
|
||||
|
@ -139,11 +139,11 @@ extern "C" {
|
|||
}
|
||||
|
||||
Z3_func_decl get_model_func_decl_core(Z3_context c, Z3_model m, unsigned i) {
|
||||
CHECK_NON_NULL(m, 0);
|
||||
CHECK_NON_NULL(m, nullptr);
|
||||
model * _m = to_model_ref(m);
|
||||
if (i >= _m->get_num_functions()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
return of_func_decl(_m->get_function(i));
|
||||
}
|
||||
|
@ -154,13 +154,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_func_decl r = get_model_func_decl_core(c, m, i);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, Z3_bool model_completion, Z3_ast * v) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_model_eval(c, m, t, model_completion, v);
|
||||
if (v) *v = 0;
|
||||
if (v) *v = nullptr;
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(m, Z3_FALSE);
|
||||
CHECK_IS_EXPR(t, Z3_FALSE);
|
||||
|
@ -187,11 +187,11 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (i >= to_model_ref(m)->get_num_uninterpreted_sorts()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
sort * s = to_model_ref(m)->get_uninterpreted_sort(i);
|
||||
RETURN_Z3(of_sort(s));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast_vector Z3_API Z3_model_get_sort_universe(Z3_context c, Z3_model m, Z3_sort s) {
|
||||
|
@ -200,7 +200,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (!to_model_ref(m)->has_uninterpreted_sort(to_sort(s))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ptr_vector<expr> const & universe = to_model_ref(m)->get_universe(to_sort(s));
|
||||
Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m());
|
||||
|
@ -210,7 +210,19 @@ extern "C" {
|
|||
v->m_ast_vector.push_back(universe[i]);
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_model Z3_API Z3_model_translate(Z3_context c, Z3_model m, Z3_context target) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_model_translate(c, m, target);
|
||||
RESET_ERROR_CODE();
|
||||
Z3_model_ref* dst = alloc(Z3_model_ref, *mk_c(target));
|
||||
ast_translation tr(mk_c(c)->m(), mk_c(target)->m());
|
||||
dst->m_model = to_model_ref(m)->translate(tr);
|
||||
mk_c(target)->save_object(dst);
|
||||
RETURN_Z3(of_model(dst));
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a) {
|
||||
|
@ -230,9 +242,9 @@ extern "C" {
|
|||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_func_interp Z3_API Z3_add_func_interp(Z3_context c, Z3_model m, Z3_func_decl f, Z3_ast else_val) {
|
||||
|
@ -247,7 +259,7 @@ extern "C" {
|
|||
mdl->register_decl(d, f_ref->m_func_interp);
|
||||
f_ref->m_func_interp->set_else(to_expr(else_val));
|
||||
RETURN_Z3(of_func_interp(f_ref));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_add_const_interp(Z3_context c, Z3_model m, Z3_func_decl f, Z3_ast a) {
|
||||
|
@ -298,30 +310,30 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_func_interp_get_entry(c, f, i);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(f, 0);
|
||||
CHECK_NON_NULL(f, nullptr);
|
||||
if (i >= to_func_interp_ref(f)->num_entries()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_func_entry_ref * e = alloc(Z3_func_entry_ref, *mk_c(c), to_func_interp(f)->m_model.get());
|
||||
e->m_func_interp = to_func_interp_ref(f);
|
||||
e->m_func_entry = to_func_interp_ref(f)->get_entry(i);
|
||||
mk_c(c)->save_object(e);
|
||||
RETURN_Z3(of_func_entry(e));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_func_interp_get_else(Z3_context c, Z3_func_interp f) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_func_interp_get_else(c, f);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(f, 0);
|
||||
CHECK_NON_NULL(f, nullptr);
|
||||
expr * e = to_func_interp_ref(f)->get_else();
|
||||
if (e) {
|
||||
mk_c(c)->save_ast_trail(e);
|
||||
}
|
||||
RETURN_Z3(of_expr(e));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_func_interp_set_else(Z3_context c, Z3_func_interp f, Z3_ast else_value) {
|
||||
|
@ -387,7 +399,7 @@ extern "C" {
|
|||
expr * v = to_func_entry_ref(e)->get_result();
|
||||
mk_c(c)->save_ast_trail(v);
|
||||
RETURN_Z3(of_expr(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_func_entry_get_num_args(Z3_context c, Z3_func_entry e) {
|
||||
|
@ -404,11 +416,11 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (i >= to_func_entry(e)->m_func_interp->get_arity()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
expr * r = to_func_entry(e)->m_func_entry->get_arg(i);
|
||||
RETURN_Z3(of_expr(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
// ----------------------------
|
||||
|
@ -479,7 +491,7 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_model_to_string(c, m);
|
||||
RESET_ERROR_CODE();
|
||||
CHECK_NON_NULL(m, 0);
|
||||
CHECK_NON_NULL(m, nullptr);
|
||||
std::ostringstream buffer;
|
||||
std::string result;
|
||||
if (mk_c(c)->get_print_mode() == Z3_PRINT_SMTLIB2_COMPLIANT) {
|
||||
|
@ -495,7 +507,7 @@ extern "C" {
|
|||
result = buffer.str();
|
||||
}
|
||||
return mk_c(c)->mk_external_string(result);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
@ -24,7 +24,7 @@ Revision History:
|
|||
struct Z3_model_ref : public api::object {
|
||||
model_ref m_model;
|
||||
Z3_model_ref(api::context& c): api::object(c) {}
|
||||
virtual ~Z3_model_ref() {}
|
||||
~Z3_model_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_model_ref * to_model(Z3_model s) { return reinterpret_cast<Z3_model_ref *>(s); }
|
||||
|
@ -34,8 +34,8 @@ inline model * to_model_ref(Z3_model s) { return to_model(s)->m_model.get(); }
|
|||
struct Z3_func_interp_ref : public api::object {
|
||||
model_ref m_model; // must have it to prevent reference to m_func_interp to be killed.
|
||||
func_interp * m_func_interp;
|
||||
Z3_func_interp_ref(api::context& c, model * m): api::object(c), m_model(m), m_func_interp(0) {}
|
||||
virtual ~Z3_func_interp_ref() {}
|
||||
Z3_func_interp_ref(api::context& c, model * m): api::object(c), m_model(m), m_func_interp(nullptr) {}
|
||||
~Z3_func_interp_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_func_interp_ref * to_func_interp(Z3_func_interp s) { return reinterpret_cast<Z3_func_interp_ref *>(s); }
|
||||
|
@ -46,8 +46,8 @@ struct Z3_func_entry_ref : public api::object {
|
|||
model_ref m_model; // must have it to prevent reference to m_func_entry to be killed.
|
||||
func_interp * m_func_interp;
|
||||
func_entry const * m_func_entry;
|
||||
Z3_func_entry_ref(api::context& c, model * m):api::object(c), m_model(m), m_func_interp(0), m_func_entry(0) {}
|
||||
virtual ~Z3_func_entry_ref() {}
|
||||
Z3_func_entry_ref(api::context& c, model * m):api::object(c), m_model(m), m_func_interp(nullptr), m_func_entry(nullptr) {}
|
||||
~Z3_func_entry_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_func_entry_ref * to_func_entry(Z3_func_entry s) { return reinterpret_cast<Z3_func_entry_ref *>(s); }
|
||||
|
|
|
@ -52,11 +52,11 @@ extern "C" {
|
|||
LOG_Z3_mk_numeral(c, n, ty);
|
||||
RESET_ERROR_CODE();
|
||||
if (!check_numeral_sort(c, ty)) {
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
if (!n) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
sort * _ty = to_sort(ty);
|
||||
bool is_float = mk_c(c)->fpautil().is_float(_ty);
|
||||
|
@ -73,11 +73,11 @@ extern "C" {
|
|||
('P' == *m) ||
|
||||
('+' == *m))))) {
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
return 0;
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
++m;
|
||||
}
|
||||
ast * a = 0;
|
||||
ast * a = nullptr;
|
||||
if (_ty->get_family_id() == mk_c(c)->get_fpa_fid()) {
|
||||
// avoid expanding floats into huge rationals.
|
||||
fpa_util & fu = mk_c(c)->fpautil();
|
||||
|
@ -89,7 +89,7 @@ extern "C" {
|
|||
else
|
||||
a = mk_c(c)->mk_numeral_core(rational(n), _ty);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_int(Z3_context c, int value, Z3_sort ty) {
|
||||
|
@ -97,11 +97,11 @@ extern "C" {
|
|||
LOG_Z3_mk_int(c, value, ty);
|
||||
RESET_ERROR_CODE();
|
||||
if (!check_numeral_sort(c, ty)) {
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ast * a = mk_c(c)->mk_numeral_core(rational(value), to_sort(ty));
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_unsigned_int(Z3_context c, unsigned value, Z3_sort ty) {
|
||||
|
@ -109,11 +109,11 @@ extern "C" {
|
|||
LOG_Z3_mk_unsigned_int(c, value, ty);
|
||||
RESET_ERROR_CODE();
|
||||
if (!check_numeral_sort(c, ty)) {
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
ast * a = mk_c(c)->mk_numeral_core(rational(value), to_sort(ty));
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_int64(Z3_context c, long long value, Z3_sort ty) {
|
||||
|
@ -121,12 +121,12 @@ extern "C" {
|
|||
LOG_Z3_mk_int64(c, value, ty);
|
||||
RESET_ERROR_CODE();
|
||||
if (!check_numeral_sort(c, ty)) {
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
rational n(value, rational::i64());
|
||||
ast* a = mk_c(c)->mk_numeral_core(n, to_sort(ty));
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_unsigned_int64(Z3_context c, unsigned long long value, Z3_sort ty) {
|
||||
|
@ -134,12 +134,12 @@ extern "C" {
|
|||
LOG_Z3_mk_unsigned_int64(c, value, ty);
|
||||
RESET_ERROR_CODE();
|
||||
if (!check_numeral_sort(c, ty)) {
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
rational n(value, rational::ui64());
|
||||
ast * a = mk_c(c)->mk_numeral_core(n, to_sort(ty));
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a) {
|
||||
|
@ -397,7 +397,7 @@ extern "C" {
|
|||
}
|
||||
ast * a = mk_c(c)->mk_numeral_core(r, mk_c(c)->bvutil().mk_sort(sz));
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
@ -16,25 +16,27 @@ Revision History:
|
|||
|
||||
--*/
|
||||
#include<iostream>
|
||||
#include "util/cancel_eh.h"
|
||||
#include "util/file_path.h"
|
||||
#include "util/scoped_timer.h"
|
||||
#include "parsers/smt2/smt2parser.h"
|
||||
#include "opt/opt_context.h"
|
||||
#include "opt/opt_cmds.h"
|
||||
#include "opt/opt_parse.h"
|
||||
#include "api/z3.h"
|
||||
#include "api/api_log_macros.h"
|
||||
#include "api/api_stats.h"
|
||||
#include "api/api_context.h"
|
||||
#include "api/api_util.h"
|
||||
#include "api/api_model.h"
|
||||
#include "opt/opt_context.h"
|
||||
#include "opt/opt_cmds.h"
|
||||
#include "util/cancel_eh.h"
|
||||
#include "util/scoped_timer.h"
|
||||
#include "parsers/smt2/smt2parser.h"
|
||||
#include "api/api_ast_vector.h"
|
||||
|
||||
extern "C" {
|
||||
|
||||
struct Z3_optimize_ref : public api::object {
|
||||
opt::context* m_opt;
|
||||
Z3_optimize_ref(api::context& c): api::object(c), m_opt(0) {}
|
||||
virtual ~Z3_optimize_ref() { dealloc(m_opt); }
|
||||
Z3_optimize_ref(api::context& c): api::object(c), m_opt(nullptr) {}
|
||||
~Z3_optimize_ref() override { dealloc(m_opt); }
|
||||
};
|
||||
inline Z3_optimize_ref * to_optimize(Z3_optimize o) { return reinterpret_cast<Z3_optimize_ref *>(o); }
|
||||
inline Z3_optimize of_optimize(Z3_optimize_ref * o) { return reinterpret_cast<Z3_optimize>(o); }
|
||||
|
@ -48,7 +50,7 @@ extern "C" {
|
|||
o->m_opt = alloc(opt::context,mk_c(c)->m());
|
||||
mk_c(c)->save_object(o);
|
||||
RETURN_Z3(of_optimize(o));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_optimize_inc_ref(Z3_context c, Z3_optimize o) {
|
||||
|
@ -169,7 +171,7 @@ extern "C" {
|
|||
}
|
||||
mk_c(c)->save_object(m_ref);
|
||||
RETURN_Z3(of_model(m_ref));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_optimize_set_params(Z3_context c, Z3_optimize o, Z3_params p) {
|
||||
|
@ -193,7 +195,7 @@ extern "C" {
|
|||
to_optimize_ptr(o)->collect_param_descrs(d->m_descrs);
|
||||
Z3_param_descrs r = of_param_descrs(d);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
// get lower value or current approximation
|
||||
|
@ -204,7 +206,7 @@ extern "C" {
|
|||
expr_ref e = to_optimize_ptr(o)->get_lower(idx);
|
||||
mk_c(c)->save_ast_trail(e);
|
||||
RETURN_Z3(of_expr(e));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
// get upper or current approximation
|
||||
|
@ -215,7 +217,7 @@ extern "C" {
|
|||
expr_ref e = to_optimize_ptr(o)->get_upper(idx);
|
||||
mk_c(c)->save_ast_trail(e);
|
||||
RETURN_Z3(of_expr(e));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
// get lower value or current approximation
|
||||
|
@ -229,7 +231,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(v);
|
||||
v->m_ast_vector.append(es.size(), (ast*const*)es.c_ptr());
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
// get upper or current approximation
|
||||
|
@ -243,7 +245,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(v);
|
||||
v->m_ast_vector.append(es.size(), (ast*const*)es.c_ptr());
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_optimize_to_string(Z3_context c, Z3_optimize o) {
|
||||
|
@ -275,22 +277,46 @@ extern "C" {
|
|||
mk_c(c)->save_object(st);
|
||||
Z3_stats r = of_stats(st);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
static void Z3_optimize_from_stream(
|
||||
Z3_context c,
|
||||
Z3_optimize opt,
|
||||
std::istream& s) {
|
||||
ast_manager& m = mk_c(c)->m();
|
||||
std::istream& s,
|
||||
char const* ext) {
|
||||
ast_manager& m = mk_c(c)->m();
|
||||
if (ext && std::string("opb") == ext) {
|
||||
unsigned_vector h;
|
||||
parse_opb(*to_optimize_ptr(opt), s, h);
|
||||
return;
|
||||
}
|
||||
if (ext && std::string("wcnf") == ext) {
|
||||
unsigned_vector h;
|
||||
parse_wcnf(*to_optimize_ptr(opt), s, h);
|
||||
return;
|
||||
}
|
||||
scoped_ptr<cmd_context> ctx = alloc(cmd_context, false, &m);
|
||||
install_opt_cmds(*ctx.get(), to_optimize_ptr(opt));
|
||||
std::stringstream errstrm;
|
||||
ctx->set_regular_stream(errstrm);
|
||||
ctx->set_ignore_check(true);
|
||||
if (!parse_smt2_commands(*ctx.get(), s)) {
|
||||
try {
|
||||
if (!parse_smt2_commands(*ctx.get(), s)) {
|
||||
mk_c(c)->m_parser_error_buffer = errstrm.str();
|
||||
ctx = nullptr;
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
return;
|
||||
}
|
||||
}
|
||||
catch (z3_exception& e) {
|
||||
errstrm << e.msg();
|
||||
mk_c(c)->m_parser_error_buffer = errstrm.str();
|
||||
ctx = nullptr;
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
ptr_vector<expr>::const_iterator it = ctx->begin_assertions();
|
||||
ptr_vector<expr>::const_iterator end = ctx->end_assertions();
|
||||
for (; it != end; ++it) {
|
||||
|
@ -298,6 +324,8 @@ extern "C" {
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void Z3_API Z3_optimize_from_string(
|
||||
Z3_context c,
|
||||
Z3_optimize d,
|
||||
|
@ -306,7 +334,7 @@ extern "C" {
|
|||
//LOG_Z3_optimize_from_string(c, d, s);
|
||||
std::string str(s);
|
||||
std::istringstream is(str);
|
||||
Z3_optimize_from_stream(c, d, is);
|
||||
Z3_optimize_from_stream(c, d, is, nullptr);
|
||||
Z3_CATCH;
|
||||
}
|
||||
|
||||
|
@ -322,7 +350,7 @@ extern "C" {
|
|||
strm << "Could not open file " << s;
|
||||
throw default_exception(strm.str());
|
||||
}
|
||||
Z3_optimize_from_stream(c, d, is);
|
||||
Z3_optimize_from_stream(c, d, is, get_extension(s));
|
||||
Z3_CATCH;
|
||||
}
|
||||
|
||||
|
@ -335,11 +363,11 @@ extern "C" {
|
|||
mk_c(c)->save_object(v);
|
||||
expr_ref_vector hard(mk_c(c)->m());
|
||||
to_optimize_ptr(o)->get_hard_constraints(hard);
|
||||
for (unsigned i = 0; i < hard.size(); i++) {
|
||||
v->m_ast_vector.push_back(hard[i].get());
|
||||
for (expr* h : hard) {
|
||||
v->m_ast_vector.push_back(h);
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast_vector Z3_API Z3_optimize_get_objectives(Z3_context c, Z3_optimize o) {
|
||||
|
@ -353,7 +381,7 @@ extern "C" {
|
|||
v->m_ast_vector.push_back(to_optimize_ptr(o)->get_objective(i));
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -34,7 +34,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(p);
|
||||
Z3_params r = of_params(p);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -172,11 +172,11 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (i >= to_param_descrs_ptr(p)->size()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_symbol result = of_symbol(to_param_descrs_ptr(p)->get_param_name(i));
|
||||
return result;
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_param_descrs_get_documentation(Z3_context c, Z3_param_descrs p, Z3_symbol s) {
|
||||
|
@ -184,12 +184,12 @@ extern "C" {
|
|||
LOG_Z3_param_descrs_get_documentation(c, p, s);
|
||||
RESET_ERROR_CODE();
|
||||
char const* result = to_param_descrs_ptr(p)->get_descr(to_symbol(s));
|
||||
if (result == 0) {
|
||||
if (result == nullptr) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
return mk_c(c)->mk_external_string(result);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_param_descrs_to_string(Z3_context c, Z3_param_descrs p) {
|
||||
|
|
|
@ -22,232 +22,16 @@ Revision History:
|
|||
#include "api/api_util.h"
|
||||
#include "cmd_context/cmd_context.h"
|
||||
#include "parsers/smt2/smt2parser.h"
|
||||
#include "parsers/smt/smtparser.h"
|
||||
#include "solver/solver_na2as.h"
|
||||
|
||||
extern "C" {
|
||||
|
||||
void init_smtlib_parser(Z3_context c,
|
||||
unsigned num_sorts,
|
||||
Z3_symbol const sort_names[],
|
||||
Z3_sort const types[],
|
||||
unsigned num_decls,
|
||||
Z3_symbol const decl_names[],
|
||||
Z3_func_decl const decls[]) {
|
||||
mk_c(c)->reset_parser();
|
||||
mk_c(c)->m_smtlib_parser = smtlib::parser::create(mk_c(c)->m());
|
||||
mk_c(c)->m_smtlib_parser->initialize_smtlib();
|
||||
smtlib::symtable * table = mk_c(c)->m_smtlib_parser->get_benchmark()->get_symtable();
|
||||
for (unsigned i = 0; i < num_sorts; i++) {
|
||||
table->insert(to_symbol(sort_names[i]), to_sort(types[i]));
|
||||
}
|
||||
for (unsigned i = 0; i < num_decls; i++) {
|
||||
table->insert(to_symbol(decl_names[i]), to_func_decl(decls[i]));
|
||||
}
|
||||
}
|
||||
|
||||
void Z3_API Z3_parse_smtlib_string(Z3_context c,
|
||||
const char * str,
|
||||
unsigned num_sorts,
|
||||
Z3_symbol const sort_names[],
|
||||
Z3_sort const sorts[],
|
||||
unsigned num_decls,
|
||||
Z3_symbol const decl_names[],
|
||||
Z3_func_decl const decls[]) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_parse_smtlib_string(c, str, num_sorts, sort_names, sorts, num_decls, decl_names, decls);
|
||||
scoped_ptr<std::ostringstream> outs = alloc(std::ostringstream);
|
||||
bool ok = false;
|
||||
|
||||
RESET_ERROR_CODE();
|
||||
init_smtlib_parser(c, num_sorts, sort_names, sorts, num_decls, decl_names, decls);
|
||||
mk_c(c)->m_smtlib_parser->set_error_stream(*outs);
|
||||
try {
|
||||
ok = mk_c(c)->m_smtlib_parser->parse_string(str);
|
||||
}
|
||||
catch (...) {
|
||||
ok = false;
|
||||
}
|
||||
mk_c(c)->m_smtlib_error_buffer = outs->str();
|
||||
outs = nullptr;
|
||||
if (!ok) {
|
||||
mk_c(c)->reset_parser();
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
}
|
||||
Z3_CATCH;
|
||||
}
|
||||
|
||||
void Z3_API Z3_parse_smtlib_file(Z3_context c,
|
||||
const char * file_name,
|
||||
unsigned num_sorts,
|
||||
Z3_symbol const sort_names[],
|
||||
Z3_sort const types[],
|
||||
unsigned num_decls,
|
||||
Z3_symbol const decl_names[],
|
||||
Z3_func_decl const decls[]) {
|
||||
Z3_string Z3_API Z3_get_parser_error(Z3_context c) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_parse_smtlib_file(c, file_name, num_sorts, sort_names, types, num_decls, decl_names, decls);
|
||||
bool ok = false;
|
||||
RESET_ERROR_CODE();
|
||||
scoped_ptr<std::ostringstream> outs = alloc(std::ostringstream);
|
||||
init_smtlib_parser(c, num_sorts, sort_names, types, num_decls, decl_names, decls);
|
||||
mk_c(c)->m_smtlib_parser->set_error_stream(*outs);
|
||||
try {
|
||||
ok = mk_c(c)->m_smtlib_parser->parse_file(file_name);
|
||||
}
|
||||
catch(...) {
|
||||
ok = false;
|
||||
}
|
||||
mk_c(c)->m_smtlib_error_buffer = outs->str();
|
||||
outs = nullptr;
|
||||
if (!ok) {
|
||||
mk_c(c)->reset_parser();
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
}
|
||||
Z3_CATCH;
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_get_smtlib_num_formulas(Z3_context c) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_smtlib_num_formulas(c);
|
||||
RESET_ERROR_CODE();
|
||||
if (mk_c(c)->m_smtlib_parser) {
|
||||
return mk_c(c)->m_smtlib_parser->get_benchmark()->get_num_formulas();
|
||||
}
|
||||
SET_ERROR_CODE(Z3_NO_PARSER);
|
||||
return 0;
|
||||
Z3_CATCH_RETURN(0);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_get_smtlib_formula(Z3_context c, unsigned i) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_smtlib_formula(c, i);
|
||||
RESET_ERROR_CODE();
|
||||
if (mk_c(c)->m_smtlib_parser) {
|
||||
if (i < mk_c(c)->m_smtlib_parser->get_benchmark()->get_num_formulas()) {
|
||||
ast * f = mk_c(c)->m_smtlib_parser->get_benchmark()->begin_formulas()[i];
|
||||
mk_c(c)->save_ast_trail(f);
|
||||
RETURN_Z3(of_ast(f));
|
||||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
}
|
||||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_NO_PARSER);
|
||||
}
|
||||
RETURN_Z3(0);
|
||||
Z3_CATCH_RETURN(0);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_get_smtlib_num_assumptions(Z3_context c) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_smtlib_num_assumptions(c);
|
||||
RESET_ERROR_CODE();
|
||||
if (mk_c(c)->m_smtlib_parser) {
|
||||
return mk_c(c)->m_smtlib_parser->get_benchmark()->get_num_axioms();
|
||||
}
|
||||
SET_ERROR_CODE(Z3_NO_PARSER);
|
||||
return 0;
|
||||
Z3_CATCH_RETURN(0);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_get_smtlib_assumption(Z3_context c, unsigned i) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_smtlib_assumption(c, i);
|
||||
RESET_ERROR_CODE();
|
||||
if (mk_c(c)->m_smtlib_parser) {
|
||||
if (i < mk_c(c)->m_smtlib_parser->get_benchmark()->get_num_axioms()) {
|
||||
ast * a = mk_c(c)->m_smtlib_parser->get_benchmark()->begin_axioms()[i];
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
}
|
||||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_NO_PARSER);
|
||||
}
|
||||
RETURN_Z3(0);
|
||||
Z3_CATCH_RETURN(0);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_get_smtlib_num_decls(Z3_context c) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_smtlib_num_decls(c);
|
||||
RESET_ERROR_CODE();
|
||||
if (mk_c(c)->m_smtlib_parser) {
|
||||
mk_c(c)->extract_smtlib_parser_decls();
|
||||
return mk_c(c)->m_smtlib_parser_decls.size();
|
||||
}
|
||||
SET_ERROR_CODE(Z3_NO_PARSER);
|
||||
return 0;
|
||||
Z3_CATCH_RETURN(0);
|
||||
}
|
||||
|
||||
Z3_func_decl Z3_API Z3_get_smtlib_decl(Z3_context c, unsigned i) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_smtlib_decl(c, i);
|
||||
LOG_Z3_get_parser_error(c);
|
||||
RESET_ERROR_CODE();
|
||||
mk_c(c)->extract_smtlib_parser_decls();
|
||||
if (mk_c(c)->m_smtlib_parser) {
|
||||
if (i < mk_c(c)->m_smtlib_parser_decls.size()) {
|
||||
func_decl * d = mk_c(c)->m_smtlib_parser_decls[i];
|
||||
mk_c(c)->save_ast_trail(d);
|
||||
RETURN_Z3(of_func_decl(d));
|
||||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
}
|
||||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_NO_PARSER);
|
||||
}
|
||||
RETURN_Z3(0);
|
||||
Z3_CATCH_RETURN(0);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_get_smtlib_num_sorts(Z3_context c) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_smtlib_num_sorts(c);
|
||||
RESET_ERROR_CODE();
|
||||
if (mk_c(c)->m_smtlib_parser) {
|
||||
mk_c(c)->extract_smtlib_parser_decls();
|
||||
return mk_c(c)->m_smtlib_parser_sorts.size();
|
||||
}
|
||||
SET_ERROR_CODE(Z3_NO_PARSER);
|
||||
return 0;
|
||||
Z3_CATCH_RETURN(0);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_get_smtlib_sort(Z3_context c, unsigned i) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_smtlib_sort(c, i);
|
||||
RESET_ERROR_CODE();
|
||||
if (mk_c(c)->m_smtlib_parser) {
|
||||
mk_c(c)->extract_smtlib_parser_decls();
|
||||
if (i < mk_c(c)->m_smtlib_parser_sorts.size()) {
|
||||
sort* s = mk_c(c)->m_smtlib_parser_sorts[i];
|
||||
mk_c(c)->save_ast_trail(s);
|
||||
RETURN_Z3(of_sort(s));
|
||||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
}
|
||||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_NO_PARSER);
|
||||
}
|
||||
RETURN_Z3(0);
|
||||
Z3_CATCH_RETURN(0);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_get_smtlib_error(Z3_context c) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_get_smtlib_error(c);
|
||||
RESET_ERROR_CODE();
|
||||
return mk_c(c)->m_smtlib_error_buffer.c_str();
|
||||
return mk_c(c)->m_parser_error_buffer.c_str();
|
||||
Z3_CATCH_RETURN("");
|
||||
}
|
||||
|
||||
|
@ -268,10 +52,26 @@ extern "C" {
|
|||
ctx->insert(to_symbol(decl_names[i]), to_func_decl(decls[i]));
|
||||
}
|
||||
for (unsigned i = 0; i < num_sorts; ++i) {
|
||||
psort* ps = ctx->pm().mk_psort_cnst(to_sort(sorts[i]));
|
||||
ctx->insert(ctx->pm().mk_psort_user_decl(0, to_symbol(sort_names[i]), ps));
|
||||
sort* srt = to_sort(sorts[i]);
|
||||
symbol name(to_symbol(sort_names[i]));
|
||||
if (!ctx->find_psort_decl(name)) {
|
||||
psort* ps = ctx->pm().mk_psort_cnst(srt);
|
||||
ctx->insert(ctx->pm().mk_psort_user_decl(0, name, ps));
|
||||
}
|
||||
}
|
||||
if (!parse_smt2_commands(*ctx.get(), is)) {
|
||||
std::stringstream errstrm;
|
||||
ctx->set_regular_stream(errstrm);
|
||||
try {
|
||||
if (!parse_smt2_commands(*ctx.get(), is)) {
|
||||
ctx = nullptr;
|
||||
mk_c(c)->m_parser_error_buffer = errstrm.str();
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
return of_ast(mk_c(c)->m().mk_true());
|
||||
}
|
||||
}
|
||||
catch (z3_exception& e) {
|
||||
errstrm << e.msg();
|
||||
mk_c(c)->m_parser_error_buffer = errstrm.str();
|
||||
ctx = nullptr;
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
return of_ast(mk_c(c)->m().mk_true());
|
||||
|
@ -280,7 +80,7 @@ extern "C" {
|
|||
ptr_vector<expr>::const_iterator end = ctx->end_assertions();
|
||||
unsigned size = static_cast<unsigned>(end - it);
|
||||
return of_ast(mk_c(c)->mk_and(size, it));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_parse_smtlib2_string(Z3_context c, Z3_string str,
|
||||
|
@ -296,7 +96,7 @@ extern "C" {
|
|||
std::istringstream is(s);
|
||||
Z3_ast r = parse_smtlib2_stream(false, c, is, num_sorts, sort_names, sorts, num_decls, decl_names, decls);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_parse_smtlib2_file(Z3_context c, Z3_string file_name,
|
||||
|
@ -311,10 +111,10 @@ extern "C" {
|
|||
std::ifstream is(file_name);
|
||||
if (!is) {
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
Z3_ast r = parse_smtlib2_stream(false, c, is, num_sorts, sort_names, sorts, num_decls, decl_names, decls);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
};
|
||||
|
|
|
@ -34,7 +34,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(a);
|
||||
check_sorts(c, a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_atleast(Z3_context c, unsigned num_args,
|
||||
|
@ -48,7 +48,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(a);
|
||||
check_sorts(c, a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_pble(Z3_context c, unsigned num_args,
|
||||
|
@ -66,7 +66,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(a);
|
||||
check_sorts(c, a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_pbge(Z3_context c, unsigned num_args,
|
||||
|
@ -84,7 +84,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(a);
|
||||
check_sorts(c, a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_pbeq(Z3_context c, unsigned num_args,
|
||||
|
@ -102,7 +102,7 @@ extern "C" {
|
|||
mk_c(c)->save_ast_trail(a);
|
||||
check_sorts(c, a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -50,7 +50,7 @@ extern "C" {
|
|||
if (!converter.to_polynomial(to_expr(p), _p, d) ||
|
||||
!converter.to_polynomial(to_expr(q), _q, d)) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
Z3_ast_vector_ref* result = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m());
|
||||
mk_c(c)->save_object(result);
|
||||
|
@ -74,7 +74,7 @@ extern "C" {
|
|||
}
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(result));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
@ -56,7 +56,7 @@ extern "C"
|
|||
app_ref_vector vars(mk_c(c)->m ());
|
||||
if (!to_apps(num_bounds, bound, vars)) {
|
||||
SET_ERROR_CODE (Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
|
||||
expr_ref result (mk_c(c)->m ());
|
||||
|
@ -66,7 +66,7 @@ extern "C"
|
|||
mk_c(c)->save_ast_trail (result.get ());
|
||||
|
||||
return of_expr (result.get ());
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_qe_model_project_skolem (Z3_context c,
|
||||
|
@ -83,7 +83,7 @@ extern "C"
|
|||
ast_manager& man = mk_c(c)->m ();
|
||||
app_ref_vector vars(man);
|
||||
if (!to_apps(num_bounds, bound, vars)) {
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
|
||||
expr_ref result (mk_c(c)->m ());
|
||||
|
@ -103,7 +103,7 @@ extern "C"
|
|||
}
|
||||
|
||||
return of_expr (result.get ());
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_model_extrapolate (Z3_context c,
|
||||
|
@ -130,7 +130,7 @@ extern "C"
|
|||
mk_c(c)->save_ast_trail (result.get ());
|
||||
|
||||
return of_expr (result.get ());
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_qe_lite (Z3_context c, Z3_ast_vector vars, Z3_ast body)
|
||||
|
@ -145,7 +145,7 @@ extern "C"
|
|||
app *a = to_app (vVars.get (i));
|
||||
if (a->get_kind () != AST_APP) {
|
||||
SET_ERROR_CODE (Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
vApps.push_back (a);
|
||||
}
|
||||
|
@ -167,7 +167,7 @@ extern "C"
|
|||
|
||||
mk_c(c)->save_ast_trail (result.get ());
|
||||
return of_expr (result);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -37,10 +37,10 @@ extern "C" {
|
|||
c,
|
||||
is_forall,
|
||||
weight,
|
||||
0,
|
||||
0,
|
||||
nullptr,
|
||||
nullptr,
|
||||
num_patterns, patterns,
|
||||
0, 0,
|
||||
0, nullptr,
|
||||
num_decls, sorts,
|
||||
decl_names,
|
||||
body
|
||||
|
@ -104,7 +104,7 @@ extern "C" {
|
|||
}
|
||||
mk_c(c)->save_ast_trail(result.get());
|
||||
return of_ast(result.get());
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_quantifier_ex(
|
||||
|
@ -166,17 +166,17 @@ extern "C" {
|
|||
ptr_vector<expr> bound_asts;
|
||||
if (num_patterns > 0 && num_no_patterns > 0) {
|
||||
SET_ERROR_CODE(Z3_INVALID_USAGE);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
if (num_bound == 0) {
|
||||
SET_ERROR_CODE(Z3_INVALID_USAGE);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
for (unsigned i = 0; i < num_bound; ++i) {
|
||||
app* a = to_app(bound[i]);
|
||||
if (a->get_kind() != AST_APP) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
symbol s(to_app(a)->get_decl()->get_name());
|
||||
names.push_back(of_symbol(s));
|
||||
|
@ -184,7 +184,7 @@ extern "C" {
|
|||
bound_asts.push_back(a);
|
||||
if (a->get_family_id() != null_family_id || a->get_num_args() != 0) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
}
|
||||
// Abstract patterns
|
||||
|
@ -205,7 +205,7 @@ extern "C" {
|
|||
expr_ref result(mk_c(c)->m());
|
||||
if (!is_app(to_expr(no_patterns[i]))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
app* pat = to_app(to_expr(no_patterns[i]));
|
||||
expr_abstract(mk_c(c)->m(), 0, num_bound, bound_asts.c_ptr(), pat, result);
|
||||
|
@ -224,7 +224,7 @@ extern "C" {
|
|||
names.size(), types.c_ptr(), names.c_ptr(),
|
||||
of_ast(abs_body.get()));
|
||||
RETURN_Z3(result);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_quantifier_const(Z3_context c,
|
||||
|
@ -235,10 +235,10 @@ extern "C" {
|
|||
unsigned num_patterns,
|
||||
Z3_pattern const patterns[],
|
||||
Z3_ast body) {
|
||||
return Z3_mk_quantifier_const_ex(c, is_forall, weight, 0, 0,
|
||||
return Z3_mk_quantifier_const_ex(c, is_forall, weight, nullptr, nullptr,
|
||||
num_bound, bound,
|
||||
num_patterns, patterns,
|
||||
0, 0,
|
||||
0, nullptr,
|
||||
body);
|
||||
}
|
||||
|
||||
|
@ -269,13 +269,13 @@ extern "C" {
|
|||
for (unsigned i = 0; i < num_patterns; ++i) {
|
||||
if (!is_app(to_expr(terms[i]))) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
}
|
||||
app* a = mk_c(c)->m().mk_pattern(num_patterns, reinterpret_cast<app*const*>(to_exprs(terms)));
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_pattern(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty) {
|
||||
|
@ -285,7 +285,7 @@ extern "C" {
|
|||
ast* a = mk_c(c)->m().mk_var(index, to_sort(ty));
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a) {
|
||||
|
@ -344,9 +344,9 @@ extern "C" {
|
|||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
|
||||
|
@ -376,9 +376,9 @@ extern "C" {
|
|||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_symbol Z3_API Z3_get_quantifier_bound_name(Z3_context c, Z3_ast a, unsigned i) {
|
||||
|
@ -391,9 +391,9 @@ extern "C" {
|
|||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_get_quantifier_bound_sort(Z3_context c, Z3_ast a, unsigned i) {
|
||||
|
@ -407,9 +407,9 @@ extern "C" {
|
|||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_get_quantifier_body(Z3_context c, Z3_ast a) {
|
||||
|
@ -423,9 +423,9 @@ extern "C" {
|
|||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_get_quantifier_num_bound(Z3_context c, Z3_ast a) {
|
||||
|
@ -470,9 +470,9 @@ extern "C" {
|
|||
}
|
||||
else {
|
||||
SET_ERROR_CODE(Z3_SORT_ERROR);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_pattern_to_ast(Z3_context c, Z3_pattern p) {
|
||||
|
|
|
@ -62,7 +62,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).set(r, q);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_rcf_num Z3_API Z3_rcf_mk_small_int(Z3_context c, int val) {
|
||||
|
@ -73,7 +73,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).set(r, val);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_rcf_num Z3_API Z3_rcf_mk_pi(Z3_context c) {
|
||||
|
@ -84,7 +84,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).mk_pi(r);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_rcf_num Z3_API Z3_rcf_mk_e(Z3_context c) {
|
||||
|
@ -95,7 +95,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).mk_e(r);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_rcf_num Z3_API Z3_rcf_mk_infinitesimal(Z3_context c) {
|
||||
|
@ -106,7 +106,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).mk_infinitesimal(r);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_rcf_mk_roots(Z3_context c, unsigned n, Z3_rcf_num const a[], Z3_rcf_num roots[]) {
|
||||
|
@ -145,7 +145,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).add(to_rcnumeral(a), to_rcnumeral(b), r);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_rcf_num Z3_API Z3_rcf_sub(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
||||
|
@ -156,7 +156,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).sub(to_rcnumeral(a), to_rcnumeral(b), r);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_rcf_num Z3_API Z3_rcf_mul(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
||||
|
@ -167,7 +167,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).mul(to_rcnumeral(a), to_rcnumeral(b), r);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_rcf_num Z3_API Z3_rcf_div(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
||||
|
@ -178,7 +178,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).div(to_rcnumeral(a), to_rcnumeral(b), r);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_rcf_num Z3_API Z3_rcf_neg(Z3_context c, Z3_rcf_num a) {
|
||||
|
@ -189,7 +189,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).neg(to_rcnumeral(a), r);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_rcf_num Z3_API Z3_rcf_inv(Z3_context c, Z3_rcf_num a) {
|
||||
|
@ -200,7 +200,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).inv(to_rcnumeral(a), r);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_rcf_num Z3_API Z3_rcf_power(Z3_context c, Z3_rcf_num a, unsigned k) {
|
||||
|
@ -211,7 +211,7 @@ extern "C" {
|
|||
rcnumeral r;
|
||||
rcfm(c).power(to_rcnumeral(a), k, r);
|
||||
RETURN_Z3(from_rcnumeral(r));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_rcf_lt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) {
|
||||
|
|
|
@ -31,7 +31,7 @@ extern "C" {
|
|||
sort * ty = mk_c(c)->sutil().str.mk_seq(to_sort(domain));
|
||||
mk_c(c)->save_ast_trail(ty);
|
||||
RETURN_Z3(of_sort(ty));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_mk_re_sort(Z3_context c, Z3_sort domain) {
|
||||
|
@ -41,7 +41,7 @@ extern "C" {
|
|||
sort * ty = mk_c(c)->sutil().re.mk_re(to_sort(domain));
|
||||
mk_c(c)->save_ast_trail(ty);
|
||||
RETURN_Z3(of_sort(ty));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_mk_string(Z3_context c, Z3_string str) {
|
||||
|
@ -52,7 +52,7 @@ extern "C" {
|
|||
app* a = mk_c(c)->sutil().str.mk_string(s);
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c) {
|
||||
|
@ -62,7 +62,7 @@ extern "C" {
|
|||
sort* ty = mk_c(c)->sutil().str.mk_string_sort();
|
||||
mk_c(c)->save_ast_trail(ty);
|
||||
RETURN_Z3(of_sort(ty));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_bool Z3_API Z3_is_seq_sort(Z3_context c, Z3_sort s) {
|
||||
|
@ -152,7 +152,7 @@ extern "C" {
|
|||
app* a = hi == 0 ? mk_c(c)->sutil().re.mk_loop(to_expr(r), lo) : mk_c(c)->sutil().re.mk_loop(to_expr(r), lo, hi);
|
||||
mk_c(c)->save_ast_trail(a);
|
||||
RETURN_Z3(of_ast(a));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
MK_UNARY(Z3_mk_re_plus, mk_c(c)->get_seq_fid(), OP_RE_PLUS, SKIP);
|
||||
|
@ -165,7 +165,7 @@ extern "C" {
|
|||
MK_BINARY(Z3_mk_re_range, mk_c(c)->get_seq_fid(), OP_RE_RANGE, SKIP);
|
||||
|
||||
MK_SORTED(Z3_mk_re_empty, mk_c(c)->sutil().re.mk_empty);
|
||||
MK_SORTED(Z3_mk_re_full, mk_c(c)->sutil().re.mk_full);
|
||||
MK_SORTED(Z3_mk_re_full, mk_c(c)->sutil().re.mk_full_seq);
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -17,6 +17,11 @@ Revision History:
|
|||
|
||||
--*/
|
||||
#include<iostream>
|
||||
#include "util/scoped_ctrl_c.h"
|
||||
#include "util/cancel_eh.h"
|
||||
#include "util/file_path.h"
|
||||
#include "util/scoped_timer.h"
|
||||
#include "ast/ast_pp.h"
|
||||
#include "api/z3.h"
|
||||
#include "api/api_log_macros.h"
|
||||
#include "api/api_context.h"
|
||||
|
@ -26,13 +31,15 @@ Revision History:
|
|||
#include "api/api_stats.h"
|
||||
#include "api/api_ast_vector.h"
|
||||
#include "solver/tactic2solver.h"
|
||||
#include "util/scoped_ctrl_c.h"
|
||||
#include "util/cancel_eh.h"
|
||||
#include "util/scoped_timer.h"
|
||||
#include "solver/smt_logics.h"
|
||||
#include "tactic/portfolio/smt_strategic_solver.h"
|
||||
#include "smt/smt_solver.h"
|
||||
#include "smt/smt_implied_equalities.h"
|
||||
#include "solver/smt_logics.h"
|
||||
#include "cmd_context/cmd_context.h"
|
||||
#include "parsers/smt2/smt2parser.h"
|
||||
#include "sat/dimacs.h"
|
||||
#include "sat/sat_solver.h"
|
||||
#include "sat/tactic/goal2sat.h"
|
||||
|
||||
extern "C" {
|
||||
|
||||
|
@ -51,7 +58,7 @@ extern "C" {
|
|||
}
|
||||
|
||||
static void init_solver(Z3_context c, Z3_solver s) {
|
||||
if (to_solver(s)->m_solver.get() == 0)
|
||||
if (to_solver(s)->m_solver.get() == nullptr)
|
||||
init_solver_core(c, s);
|
||||
}
|
||||
|
||||
|
@ -63,7 +70,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(s);
|
||||
Z3_solver r = of_solver(s);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_solver Z3_API Z3_mk_solver(Z3_context c) {
|
||||
|
@ -74,7 +81,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(s);
|
||||
Z3_solver r = of_solver(s);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_solver Z3_API Z3_mk_solver_for_logic(Z3_context c, Z3_symbol logic) {
|
||||
|
@ -85,7 +92,7 @@ extern "C" {
|
|||
std::ostringstream strm;
|
||||
strm << "logic '" << to_symbol(logic) << "' is not recognized";
|
||||
throw default_exception(strm.str());
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
else {
|
||||
Z3_solver_ref * s = alloc(Z3_solver_ref, *mk_c(c), mk_smt_strategic_solver_factory(to_symbol(logic)));
|
||||
|
@ -93,7 +100,7 @@ extern "C" {
|
|||
Z3_solver r = of_solver(s);
|
||||
RETURN_Z3(r);
|
||||
}
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_solver Z3_API Z3_mk_solver_from_tactic(Z3_context c, Z3_tactic t) {
|
||||
|
@ -104,7 +111,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(s);
|
||||
Z3_solver r = of_solver(s);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_solver Z3_API Z3_solver_translate(Z3_context c, Z3_solver s, Z3_context target) {
|
||||
|
@ -112,13 +119,70 @@ extern "C" {
|
|||
LOG_Z3_solver_translate(c, s, target);
|
||||
RESET_ERROR_CODE();
|
||||
params_ref const& p = to_solver(s)->m_params;
|
||||
Z3_solver_ref * sr = alloc(Z3_solver_ref, *mk_c(target), 0);
|
||||
Z3_solver_ref * sr = alloc(Z3_solver_ref, *mk_c(target), nullptr);
|
||||
init_solver(c, s);
|
||||
sr->m_solver = to_solver(s)->m_solver->translate(mk_c(target)->m(), p);
|
||||
mk_c(target)->save_object(sr);
|
||||
Z3_solver r = of_solver(sr);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void solver_from_stream(Z3_context c, Z3_solver s, std::istream& is) {
|
||||
scoped_ptr<cmd_context> ctx = alloc(cmd_context, false, &(mk_c(c)->m()));
|
||||
ctx->set_ignore_check(true);
|
||||
|
||||
if (!parse_smt2_commands(*ctx.get(), is)) {
|
||||
ctx = nullptr;
|
||||
SET_ERROR_CODE(Z3_PARSER_ERROR);
|
||||
return;
|
||||
}
|
||||
|
||||
bool initialized = to_solver(s)->m_solver.get() != nullptr;
|
||||
if (!initialized)
|
||||
init_solver(c, s);
|
||||
ptr_vector<expr>::const_iterator it = ctx->begin_assertions();
|
||||
ptr_vector<expr>::const_iterator end = ctx->end_assertions();
|
||||
for (; it != end; ++it) {
|
||||
to_solver_ref(s)->assert_expr(*it);
|
||||
}
|
||||
// to_solver_ref(s)->set_model_converter(ctx->get_model_converter());
|
||||
}
|
||||
|
||||
void Z3_API Z3_solver_from_string(Z3_context c, Z3_solver s, Z3_string c_str) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_solver_from_string(c, s, c_str);
|
||||
std::string str(c_str);
|
||||
std::istringstream is(str);
|
||||
solver_from_stream(c, s, is);
|
||||
Z3_CATCH;
|
||||
}
|
||||
|
||||
void Z3_API Z3_solver_from_file(Z3_context c, Z3_solver s, Z3_string file_name) {
|
||||
Z3_TRY;
|
||||
LOG_Z3_solver_from_file(c, s, file_name);
|
||||
char const* ext = get_extension(file_name);
|
||||
std::ifstream is(file_name);
|
||||
if (!is) {
|
||||
SET_ERROR_CODE(Z3_FILE_ACCESS_ERROR);
|
||||
}
|
||||
else if (ext && std::string("dimacs") == ext) {
|
||||
ast_manager& m = to_solver_ref(s)->get_manager();
|
||||
sat::solver solver(to_solver_ref(s)->get_params(), m.limit(), nullptr);
|
||||
parse_dimacs(is, solver);
|
||||
sat2goal s2g;
|
||||
model_converter_ref mc;
|
||||
atom2bool_var a2b(m);
|
||||
goal g(m);
|
||||
s2g(solver, a2b, to_solver_ref(s)->get_params(), g, mc);
|
||||
for (unsigned i = 0; i < g.size(); ++i) {
|
||||
to_solver_ref(s)->assert_expr(g.form(i));
|
||||
}
|
||||
}
|
||||
else {
|
||||
solver_from_stream(c, s, is);
|
||||
}
|
||||
Z3_CATCH;
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_solver_get_help(Z3_context c, Z3_solver s) {
|
||||
|
@ -127,13 +191,13 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
std::ostringstream buffer;
|
||||
param_descrs descrs;
|
||||
bool initialized = to_solver(s)->m_solver.get() != 0;
|
||||
bool initialized = to_solver(s)->m_solver.get() != nullptr;
|
||||
if (!initialized)
|
||||
init_solver(c, s);
|
||||
to_solver_ref(s)->collect_param_descrs(descrs);
|
||||
context_params::collect_solver_param_descrs(descrs);
|
||||
if (!initialized)
|
||||
to_solver(s)->m_solver = 0;
|
||||
to_solver(s)->m_solver = nullptr;
|
||||
descrs.display(buffer);
|
||||
return mk_c(c)->mk_external_string(buffer.str());
|
||||
Z3_CATCH_RETURN("");
|
||||
|
@ -145,16 +209,16 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
Z3_param_descrs_ref * d = alloc(Z3_param_descrs_ref, *mk_c(c));
|
||||
mk_c(c)->save_object(d);
|
||||
bool initialized = to_solver(s)->m_solver.get() != 0;
|
||||
bool initialized = to_solver(s)->m_solver.get() != nullptr;
|
||||
if (!initialized)
|
||||
init_solver(c, s);
|
||||
to_solver_ref(s)->collect_param_descrs(d->m_descrs);
|
||||
context_params::collect_solver_param_descrs(d->m_descrs);
|
||||
if (!initialized)
|
||||
to_solver(s)->m_solver = 0;
|
||||
to_solver(s)->m_solver = nullptr;
|
||||
Z3_param_descrs r = of_param_descrs(d);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_solver_set_params(Z3_context c, Z3_solver s, Z3_params p) {
|
||||
|
@ -225,7 +289,7 @@ extern "C" {
|
|||
Z3_TRY;
|
||||
LOG_Z3_solver_reset(c, s);
|
||||
RESET_ERROR_CODE();
|
||||
to_solver(s)->m_solver = 0;
|
||||
to_solver(s)->m_solver = nullptr;
|
||||
Z3_CATCH;
|
||||
}
|
||||
|
||||
|
@ -271,7 +335,7 @@ extern "C" {
|
|||
v->m_ast_vector.push_back(to_solver_ref(s)->get_assertion(i));
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
static Z3_lbool _solver_check(Z3_context c, Z3_solver s, unsigned num_assumptions, Z3_ast const assumptions[]) {
|
||||
|
@ -312,7 +376,7 @@ extern "C" {
|
|||
LOG_Z3_solver_check(c, s);
|
||||
RESET_ERROR_CODE();
|
||||
init_solver(c, s);
|
||||
return _solver_check(c, s, 0, 0);
|
||||
return _solver_check(c, s, 0, nullptr);
|
||||
Z3_CATCH_RETURN(Z3_L_UNDEF);
|
||||
}
|
||||
|
||||
|
@ -334,13 +398,13 @@ extern "C" {
|
|||
to_solver_ref(s)->get_model(_m);
|
||||
if (!_m) {
|
||||
SET_ERROR_CODE(Z3_INVALID_USAGE);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_model_ref * m_ref = alloc(Z3_model_ref, *mk_c(c));
|
||||
m_ref->m_model = _m;
|
||||
mk_c(c)->save_object(m_ref);
|
||||
RETURN_Z3(of_model(m_ref));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast Z3_API Z3_solver_get_proof(Z3_context c, Z3_solver s) {
|
||||
|
@ -351,11 +415,11 @@ extern "C" {
|
|||
proof * p = to_solver_ref(s)->get_proof();
|
||||
if (!p) {
|
||||
SET_ERROR_CODE(Z3_INVALID_USAGE);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
mk_c(c)->save_ast_trail(p);
|
||||
RETURN_Z3(of_ast(p));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_ast_vector Z3_API Z3_solver_get_unsat_core(Z3_context c, Z3_solver s) {
|
||||
|
@ -371,7 +435,7 @@ extern "C" {
|
|||
v->m_ast_vector.push_back(core[i]);
|
||||
}
|
||||
RETURN_Z3(of_ast_vector(v));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_solver_get_reason_unknown(Z3_context c, Z3_solver s) {
|
||||
|
@ -395,7 +459,7 @@ extern "C" {
|
|||
mk_c(c)->save_object(st);
|
||||
Z3_stats r = of_stats(st);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_solver_to_string(Z3_context c, Z3_solver s) {
|
||||
|
|
|
@ -26,8 +26,8 @@ struct Z3_solver_ref : public api::object {
|
|||
ref<solver> m_solver;
|
||||
params_ref m_params;
|
||||
symbol m_logic;
|
||||
Z3_solver_ref(api::context& c, solver_factory * f): api::object(c), m_solver_factory(f), m_solver(0), m_logic(symbol::null) {}
|
||||
virtual ~Z3_solver_ref() {}
|
||||
Z3_solver_ref(api::context& c, solver_factory * f): api::object(c), m_solver_factory(f), m_solver(nullptr), m_logic(symbol::null) {}
|
||||
~Z3_solver_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_solver_ref * to_solver(Z3_solver s) { return reinterpret_cast<Z3_solver_ref *>(s); }
|
||||
|
|
|
@ -24,7 +24,7 @@ Revision History:
|
|||
struct Z3_stats_ref : public api::object {
|
||||
statistics m_stats;
|
||||
Z3_stats_ref(api::context& c): api::object(c) {}
|
||||
virtual ~Z3_stats_ref() {}
|
||||
~Z3_stats_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_stats_ref * to_stats(Z3_stats s) { return reinterpret_cast<Z3_stats_ref *>(s); }
|
||||
|
|
|
@ -51,13 +51,13 @@ extern "C" {
|
|||
LOG_Z3_mk_tactic(c, name);
|
||||
RESET_ERROR_CODE();
|
||||
tactic_cmd * t = mk_c(c)->find_tactic_cmd(symbol(name));
|
||||
if (t == 0) {
|
||||
if (t == nullptr) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
tactic * new_t = t->mk(mk_c(c)->m());
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_tactic_inc_ref(Z3_context c, Z3_tactic t) {
|
||||
|
@ -81,13 +81,13 @@ extern "C" {
|
|||
LOG_Z3_mk_probe(c, name);
|
||||
RESET_ERROR_CODE();
|
||||
probe_info * p = mk_c(c)->find_probe(symbol(name));
|
||||
if (p == 0) {
|
||||
if (p == nullptr) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
probe * new_p = p->get();
|
||||
RETURN_PROBE(new_p);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_probe_inc_ref(Z3_context c, Z3_probe p) {
|
||||
|
@ -112,7 +112,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = and_then(to_tactic_ref(t1), to_tactic_ref(t2));
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_or_else(Z3_context c, Z3_tactic t1, Z3_tactic t2) {
|
||||
|
@ -121,7 +121,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = or_else(to_tactic_ref(t1), to_tactic_ref(t2));
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_par_or(Z3_context c, unsigned num, Z3_tactic const ts[]) {
|
||||
|
@ -134,7 +134,7 @@ extern "C" {
|
|||
}
|
||||
tactic * new_t = par(num, _ts.c_ptr());
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_par_and_then(Z3_context c, Z3_tactic t1, Z3_tactic t2) {
|
||||
|
@ -143,7 +143,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = par_and_then(to_tactic_ref(t1), to_tactic_ref(t2));
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_try_for(Z3_context c, Z3_tactic t, unsigned ms) {
|
||||
|
@ -152,7 +152,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = try_for(to_tactic_ref(t), ms);
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_when(Z3_context c, Z3_probe p, Z3_tactic t) {
|
||||
|
@ -161,7 +161,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = when(to_probe_ref(p), to_tactic_ref(t));
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_cond(Z3_context c, Z3_probe p, Z3_tactic t1, Z3_tactic t2) {
|
||||
|
@ -170,7 +170,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = cond(to_probe_ref(p), to_tactic_ref(t1), to_tactic_ref(t2));
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_repeat(Z3_context c, Z3_tactic t, unsigned max) {
|
||||
|
@ -179,7 +179,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = repeat(to_tactic_ref(t), max);
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_skip(Z3_context c) {
|
||||
|
@ -188,7 +188,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = mk_skip_tactic();
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_fail(Z3_context c) {
|
||||
|
@ -197,7 +197,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = mk_fail_tactic();
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_fail_if(Z3_context c, Z3_probe p) {
|
||||
|
@ -206,7 +206,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = fail_if(to_probe_ref(p));
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_fail_if_not_decided(Z3_context c) {
|
||||
|
@ -215,7 +215,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
tactic * new_t = mk_fail_if_undecided_tactic();
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_tactic Z3_API Z3_tactic_using_params(Z3_context c, Z3_tactic t, Z3_params p) {
|
||||
|
@ -227,7 +227,7 @@ extern "C" {
|
|||
to_param_ref(p).validate(r);
|
||||
tactic * new_t = using_params(to_tactic_ref(t), to_param_ref(p));
|
||||
RETURN_TACTIC(new_t);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_probe Z3_API Z3_probe_const(Z3_context c, double val) {
|
||||
|
@ -236,7 +236,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
probe * new_p = mk_const_probe(val);
|
||||
RETURN_PROBE(new_p);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_probe Z3_API Z3_probe_lt(Z3_context c, Z3_probe p1, Z3_probe p2) {
|
||||
|
@ -245,7 +245,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
probe * new_p = mk_lt(to_probe_ref(p1), to_probe_ref(p2));
|
||||
RETURN_PROBE(new_p);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_probe Z3_API Z3_probe_gt(Z3_context c, Z3_probe p1, Z3_probe p2) {
|
||||
|
@ -254,7 +254,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
probe * new_p = mk_gt(to_probe_ref(p1), to_probe_ref(p2));
|
||||
RETURN_PROBE(new_p);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_probe Z3_API Z3_probe_le(Z3_context c, Z3_probe p1, Z3_probe p2) {
|
||||
|
@ -263,7 +263,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
probe * new_p = mk_le(to_probe_ref(p1), to_probe_ref(p2));
|
||||
RETURN_PROBE(new_p);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_probe Z3_API Z3_probe_ge(Z3_context c, Z3_probe p1, Z3_probe p2) {
|
||||
|
@ -272,7 +272,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
probe * new_p = mk_ge(to_probe_ref(p1), to_probe_ref(p2));
|
||||
RETURN_PROBE(new_p);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_probe Z3_API Z3_probe_eq(Z3_context c, Z3_probe p1, Z3_probe p2) {
|
||||
|
@ -281,7 +281,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
probe * new_p = mk_eq(to_probe_ref(p1), to_probe_ref(p2));
|
||||
RETURN_PROBE(new_p);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_probe Z3_API Z3_probe_and(Z3_context c, Z3_probe p1, Z3_probe p2) {
|
||||
|
@ -290,7 +290,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
probe * new_p = mk_and(to_probe_ref(p1), to_probe_ref(p2));
|
||||
RETURN_PROBE(new_p);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_probe Z3_API Z3_probe_or(Z3_context c, Z3_probe p1, Z3_probe p2) {
|
||||
|
@ -299,7 +299,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
probe * new_p = mk_or(to_probe_ref(p1), to_probe_ref(p2));
|
||||
RETURN_PROBE(new_p);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_probe Z3_API Z3_probe_not(Z3_context c, Z3_probe p) {
|
||||
|
@ -308,7 +308,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
probe * new_p = mk_not(to_probe_ref(p));
|
||||
RETURN_PROBE(new_p);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
unsigned Z3_API Z3_get_num_tactics(Z3_context c) {
|
||||
|
@ -372,7 +372,7 @@ extern "C" {
|
|||
to_tactic_ref(t)->collect_param_descrs(d->m_descrs);
|
||||
Z3_param_descrs r = of_param_descrs(d);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_string Z3_API Z3_tactic_get_descr(Z3_context c, Z3_string name) {
|
||||
|
@ -380,7 +380,7 @@ extern "C" {
|
|||
LOG_Z3_tactic_get_descr(c, name);
|
||||
RESET_ERROR_CODE();
|
||||
tactic_cmd * t = mk_c(c)->find_tactic_cmd(symbol(name));
|
||||
if (t == 0) {
|
||||
if (t == nullptr) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return "";
|
||||
}
|
||||
|
@ -393,7 +393,7 @@ extern "C" {
|
|||
LOG_Z3_probe_get_descr(c, name);
|
||||
RESET_ERROR_CODE();
|
||||
probe_info * p = mk_c(c)->find_probe(symbol(name));
|
||||
if (p == 0) {
|
||||
if (p == nullptr) {
|
||||
SET_ERROR_CODE(Z3_INVALID_ARG);
|
||||
return "";
|
||||
}
|
||||
|
@ -423,7 +423,7 @@ extern "C" {
|
|||
}
|
||||
catch (z3_exception & ex) {
|
||||
mk_c(c)->handle_exception(ex);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -443,7 +443,7 @@ extern "C" {
|
|||
params_ref p;
|
||||
Z3_apply_result r = _tactic_apply(c, t, g, p);
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_apply_result Z3_API Z3_tactic_apply_ex(Z3_context c, Z3_tactic t, Z3_goal g, Z3_params p) {
|
||||
|
@ -455,7 +455,7 @@ extern "C" {
|
|||
to_param_ref(p).validate(pd);
|
||||
Z3_apply_result r = _tactic_apply(c, t, g, to_param_ref(p));
|
||||
RETURN_Z3(r);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
void Z3_API Z3_apply_result_inc_ref(Z3_context c, Z3_apply_result r) {
|
||||
|
@ -503,14 +503,14 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (i > to_apply_result(r)->m_subgoals.size()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
Z3_goal_ref * g = alloc(Z3_goal_ref, *mk_c(c));
|
||||
g->m_goal = to_apply_result(r)->m_subgoals[i];
|
||||
mk_c(c)->save_object(g);
|
||||
Z3_goal result = of_goal(g);
|
||||
RETURN_Z3(result);
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
Z3_model Z3_API Z3_apply_result_convert_model(Z3_context c, Z3_apply_result r, unsigned i, Z3_model m) {
|
||||
|
@ -519,7 +519,7 @@ extern "C" {
|
|||
RESET_ERROR_CODE();
|
||||
if (i > to_apply_result(r)->m_subgoals.size()) {
|
||||
SET_ERROR_CODE(Z3_IOB);
|
||||
RETURN_Z3(0);
|
||||
RETURN_Z3(nullptr);
|
||||
}
|
||||
model_ref new_m = to_model_ref(m)->copy();
|
||||
if (to_apply_result(r)->m_mc)
|
||||
|
@ -528,7 +528,7 @@ extern "C" {
|
|||
m_ref->m_model = new_m;
|
||||
mk_c(c)->save_object(m_ref);
|
||||
RETURN_Z3(of_model(m_ref));
|
||||
Z3_CATCH_RETURN(0);
|
||||
Z3_CATCH_RETURN(nullptr);
|
||||
}
|
||||
|
||||
};
|
||||
|
|
|
@ -29,22 +29,22 @@ namespace api {
|
|||
struct Z3_tactic_ref : public api::object {
|
||||
tactic_ref m_tactic;
|
||||
Z3_tactic_ref(api::context& c): api::object(c) {}
|
||||
virtual ~Z3_tactic_ref() {}
|
||||
~Z3_tactic_ref() override {}
|
||||
};
|
||||
|
||||
struct Z3_probe_ref : public api::object {
|
||||
probe_ref m_probe;
|
||||
Z3_probe_ref(api::context& c):api::object(c) {}
|
||||
virtual ~Z3_probe_ref() {}
|
||||
~Z3_probe_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_tactic_ref * to_tactic(Z3_tactic g) { return reinterpret_cast<Z3_tactic_ref *>(g); }
|
||||
inline Z3_tactic of_tactic(Z3_tactic_ref * g) { return reinterpret_cast<Z3_tactic>(g); }
|
||||
inline tactic * to_tactic_ref(Z3_tactic g) { return g == 0 ? 0 : to_tactic(g)->m_tactic.get(); }
|
||||
inline tactic * to_tactic_ref(Z3_tactic g) { return g == nullptr ? nullptr : to_tactic(g)->m_tactic.get(); }
|
||||
|
||||
inline Z3_probe_ref * to_probe(Z3_probe g) { return reinterpret_cast<Z3_probe_ref *>(g); }
|
||||
inline Z3_probe of_probe(Z3_probe_ref * g) { return reinterpret_cast<Z3_probe>(g); }
|
||||
inline probe * to_probe_ref(Z3_probe g) { return g == 0 ? 0 : to_probe(g)->m_probe.get(); }
|
||||
inline probe * to_probe_ref(Z3_probe g) { return g == nullptr ? nullptr : to_probe(g)->m_probe.get(); }
|
||||
|
||||
struct Z3_apply_result_ref : public api::object {
|
||||
goal_ref_buffer m_subgoals;
|
||||
|
@ -52,7 +52,7 @@ struct Z3_apply_result_ref : public api::object {
|
|||
proof_converter_ref m_pc;
|
||||
expr_dependency_ref m_core;
|
||||
Z3_apply_result_ref(api::context& c, ast_manager & m);
|
||||
virtual ~Z3_apply_result_ref() {}
|
||||
~Z3_apply_result_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_apply_result_ref * to_apply_result(Z3_apply_result g) { return reinterpret_cast<Z3_apply_result_ref *>(g); }
|
||||
|
|
|
@ -88,22 +88,22 @@ inline lbool to_lbool(Z3_lbool b) { return static_cast<lbool>(b); }
|
|||
struct Z3_params_ref : public api::object {
|
||||
params_ref m_params;
|
||||
Z3_params_ref(api::context& c): api::object(c) {}
|
||||
virtual ~Z3_params_ref() {}
|
||||
~Z3_params_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_params_ref * to_params(Z3_params p) { return reinterpret_cast<Z3_params_ref *>(p); }
|
||||
inline Z3_params of_params(Z3_params_ref * p) { return reinterpret_cast<Z3_params>(p); }
|
||||
inline params_ref to_param_ref(Z3_params p) { return p == 0 ? params_ref() : to_params(p)->m_params; }
|
||||
inline params_ref to_param_ref(Z3_params p) { return p == nullptr ? params_ref() : to_params(p)->m_params; }
|
||||
|
||||
struct Z3_param_descrs_ref : public api::object {
|
||||
param_descrs m_descrs;
|
||||
Z3_param_descrs_ref(api::context& c): api::object(c) {}
|
||||
virtual ~Z3_param_descrs_ref() {}
|
||||
~Z3_param_descrs_ref() override {}
|
||||
};
|
||||
|
||||
inline Z3_param_descrs_ref * to_param_descrs(Z3_param_descrs p) { return reinterpret_cast<Z3_param_descrs_ref *>(p); }
|
||||
inline Z3_param_descrs of_param_descrs(Z3_param_descrs_ref * p) { return reinterpret_cast<Z3_param_descrs>(p); }
|
||||
inline param_descrs * to_param_descrs_ptr(Z3_param_descrs p) { return p == 0 ? 0 : &(to_param_descrs(p)->m_descrs); }
|
||||
inline param_descrs * to_param_descrs_ptr(Z3_param_descrs p) { return p == nullptr ? nullptr : &(to_param_descrs(p)->m_descrs); }
|
||||
|
||||
|
||||
#define SKIP ((void) 0)
|
||||
|
|
|
@ -174,12 +174,21 @@ namespace z3 {
|
|||
return e;
|
||||
}
|
||||
|
||||
void check_parser_error() const {
|
||||
Z3_error_code e = Z3_get_error_code(*this);
|
||||
if (e != Z3_OK && enable_exceptions()) {
|
||||
Z3_string s = Z3_get_parser_error(*this);
|
||||
if (s && *s) Z3_THROW(exception(s));
|
||||
}
|
||||
check_error();
|
||||
}
|
||||
|
||||
/**
|
||||
\brief The C++ API uses by defaults exceptions on errors.
|
||||
For applications that don't work well with exceptions (there should be only few)
|
||||
you have the ability to turn off exceptions. The tradeoffs are that applications
|
||||
have to very careful about using check_error() after calls that may result in an errornous
|
||||
state.
|
||||
have to very careful about using check_error() after calls that may result in an
|
||||
erroneous state.
|
||||
*/
|
||||
void set_enable_exceptions(bool f) { m_enable_exceptions = f; }
|
||||
|
||||
|
@ -204,7 +213,7 @@ namespace z3 {
|
|||
|
||||
/**
|
||||
\brief Interrupt the current procedure being executed by any object managed by this context.
|
||||
This is a soft interruption: there is no guarantee the object will actualy stop.
|
||||
This is a soft interruption: there is no guarantee the object will actually stop.
|
||||
*/
|
||||
void interrupt() { Z3_interrupt(m_ctx); }
|
||||
|
||||
|
@ -700,7 +709,7 @@ namespace z3 {
|
|||
|
||||
It only makes sense to use this function if the caller can ensure that
|
||||
the result is an integer or if exceptions are enabled.
|
||||
If exceptions are disabled, then use the the is_numeral_i function.
|
||||
If exceptions are disabled, then use the is_numeral_i function.
|
||||
|
||||
\pre is_numeral()
|
||||
*/
|
||||
|
@ -720,7 +729,7 @@ namespace z3 {
|
|||
|
||||
It only makes sense to use this function if the caller can ensure that
|
||||
the result is an integer or if exceptions are enabled.
|
||||
If exceptions are disabled, then use the the is_numeral_u function.
|
||||
If exceptions are disabled, then use the is_numeral_u function.
|
||||
\pre is_numeral()
|
||||
*/
|
||||
unsigned get_numeral_uint() const {
|
||||
|
@ -1527,6 +1536,38 @@ namespace z3 {
|
|||
m_vector = s.m_vector;
|
||||
return *this;
|
||||
}
|
||||
/*
|
||||
Disabled pending C++98 build upgrade
|
||||
bool contains(T const& x) const {
|
||||
for (T y : *this) if (eq(x, y)) return true;
|
||||
return false;
|
||||
}
|
||||
*/
|
||||
|
||||
class iterator {
|
||||
ast_vector_tpl const* m_vector;
|
||||
unsigned m_index;
|
||||
public:
|
||||
iterator(ast_vector_tpl const* v, unsigned i): m_vector(v), m_index(i) {}
|
||||
iterator(iterator& other): m_vector(other.m_vector), m_index(other.m_index) {}
|
||||
iterator operator=(iterator const& other) { m_vector = other.m_vector; m_index = other.m_index; return *this; }
|
||||
|
||||
bool operator==(iterator const& other) {
|
||||
return other.m_index == m_index;
|
||||
};
|
||||
bool operator!=(iterator const& other) {
|
||||
return other.m_index != m_index;
|
||||
};
|
||||
iterator& operator++() {
|
||||
++m_index;
|
||||
return *this;
|
||||
}
|
||||
iterator operator++(int) { iterator tmp = *this; ++m_index; return tmp; }
|
||||
T * operator->() const { return &(operator*()); }
|
||||
T operator*() const { return (*m_vector)[m_index]; }
|
||||
};
|
||||
iterator begin() const { return iterator(this, 0); }
|
||||
iterator end() const { return iterator(this, size()); }
|
||||
friend std::ostream & operator<<(std::ostream & out, ast_vector_tpl const & v) { out << Z3_ast_vector_to_string(v.ctx(), v); return out; }
|
||||
};
|
||||
|
||||
|
@ -1768,9 +1809,11 @@ namespace z3 {
|
|||
Z3_model_inc_ref(ctx(), m);
|
||||
}
|
||||
public:
|
||||
struct translate {};
|
||||
model(context & c):object(c) { init(Z3_mk_model(c)); }
|
||||
model(context & c, Z3_model m):object(c) { init(m); }
|
||||
model(model const & s):object(s) { init(s.m_model); }
|
||||
model(model& src, context& dst, translate) : object(dst) { init(Z3_model_translate(src.ctx(), src, dst)); }
|
||||
~model() { Z3_model_dec_ref(ctx(), m_model); }
|
||||
operator Z3_model() const { return m_model; }
|
||||
model & operator=(model const & s) {
|
||||
|
@ -1902,6 +1945,11 @@ namespace z3 {
|
|||
return *this;
|
||||
}
|
||||
void set(params const & p) { Z3_solver_set_params(ctx(), m_solver, p); check_error(); }
|
||||
void set(char const * k, bool v) { params p(ctx()); p.set(k, v); set(p); }
|
||||
void set(char const * k, unsigned v) { params p(ctx()); p.set(k, v); set(p); }
|
||||
void set(char const * k, double v) { params p(ctx()); p.set(k, v); set(p); }
|
||||
void set(char const * k, symbol const & v) { params p(ctx()); p.set(k, v); set(p); }
|
||||
void set(char const * k, char const* v) { params p(ctx()); p.set(k, v); set(p); }
|
||||
void push() { Z3_solver_push(ctx(), m_solver); check_error(); }
|
||||
void pop(unsigned n = 1) { Z3_solver_pop(ctx(), m_solver, n); check_error(); }
|
||||
void reset() { Z3_solver_reset(ctx(), m_solver); check_error(); }
|
||||
|
@ -1914,6 +1962,11 @@ namespace z3 {
|
|||
void add(expr const & e, char const * p) {
|
||||
add(e, ctx().bool_const(p));
|
||||
}
|
||||
// fails for some compilers:
|
||||
// void add(expr_vector const& v) { check_context(*this, v); for (expr e : v) add(e); }
|
||||
void from_file(char const* file) { Z3_solver_from_file(ctx(), m_solver, file); ctx().check_parser_error(); }
|
||||
void from_string(char const* s) { Z3_solver_from_string(ctx(), m_solver, s); ctx().check_parser_error(); }
|
||||
|
||||
check_result check() { Z3_lbool r = Z3_solver_check(ctx(), m_solver); check_error(); return to_check_result(r); }
|
||||
check_result check(unsigned n, expr * const assumptions) {
|
||||
array<Z3_ast> _assumptions(n);
|
||||
|
@ -1994,6 +2047,8 @@ namespace z3 {
|
|||
return *this;
|
||||
}
|
||||
void add(expr const & f) { check_context(*this, f); Z3_goal_assert(ctx(), m_goal, f); check_error(); }
|
||||
// fails for some compilers:
|
||||
// void add(expr_vector const& v) { check_context(*this, v); for (expr e : v) add(e); }
|
||||
unsigned size() const { return Z3_goal_size(ctx(), m_goal); }
|
||||
expr operator[](int i) const { assert(0 <= i); Z3_ast r = Z3_goal_formula(ctx(), m_goal, i); check_error(); return expr(ctx(), r); }
|
||||
Z3_goal_prec precision() const { return Z3_goal_precision(ctx(), m_goal); }
|
||||
|
@ -2046,6 +2101,19 @@ namespace z3 {
|
|||
check_error();
|
||||
return model(ctx(), new_m);
|
||||
}
|
||||
expr as_expr() const {
|
||||
unsigned n = size();
|
||||
if (n == 0)
|
||||
return ctx().bool_val(true);
|
||||
else if (n == 1)
|
||||
return operator[](0).as_expr();
|
||||
else {
|
||||
array<Z3_ast> args(n);
|
||||
for (unsigned i = 0; i < n; i++)
|
||||
args[i] = operator[](i).as_expr();
|
||||
return expr(ctx(), Z3_mk_or(ctx(), n, args.ptr()));
|
||||
}
|
||||
}
|
||||
friend std::ostream & operator<<(std::ostream & out, apply_result const & r);
|
||||
};
|
||||
inline std::ostream & operator<<(std::ostream & out, apply_result const & r) { out << Z3_apply_result_to_string(r.ctx(), r); return out; }
|
||||
|
@ -2469,11 +2537,11 @@ namespace z3 {
|
|||
inline expr context::real_val(__uint64 n) { Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }
|
||||
inline expr context::real_val(char const * n) { Z3_ast r = Z3_mk_numeral(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }
|
||||
|
||||
inline expr context::bv_val(int n, unsigned sz) { Z3_ast r = Z3_mk_int(m_ctx, n, bv_sort(sz)); check_error(); return expr(*this, r); }
|
||||
inline expr context::bv_val(unsigned n, unsigned sz) { Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, bv_sort(sz)); check_error(); return expr(*this, r); }
|
||||
inline expr context::bv_val(__int64 n, unsigned sz) { Z3_ast r = Z3_mk_int64(m_ctx, n, bv_sort(sz)); check_error(); return expr(*this, r); }
|
||||
inline expr context::bv_val(__uint64 n, unsigned sz) { Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, bv_sort(sz)); check_error(); return expr(*this, r); }
|
||||
inline expr context::bv_val(char const * n, unsigned sz) { Z3_ast r = Z3_mk_numeral(m_ctx, n, bv_sort(sz)); check_error(); return expr(*this, r); }
|
||||
inline expr context::bv_val(int n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_int(m_ctx, n, s); check_error(); return expr(*this, r); }
|
||||
inline expr context::bv_val(unsigned n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, s); check_error(); return expr(*this, r); }
|
||||
inline expr context::bv_val(__int64 n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_int64(m_ctx, n, s); check_error(); return expr(*this, r); }
|
||||
inline expr context::bv_val(__uint64 n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, s); check_error(); return expr(*this, r); }
|
||||
inline expr context::bv_val(char const * n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_numeral(m_ctx, n, s); check_error(); return expr(*this, r); }
|
||||
inline expr context::bv_val(unsigned n, bool const* bits) {
|
||||
array<Z3_bool> _bits(n);
|
||||
for (unsigned i = 0; i < n; ++i) _bits[i] = bits[i] ? 1 : 0;
|
||||
|
@ -2774,13 +2842,12 @@ namespace z3 {
|
|||
|
||||
inline expr context::parse_string(char const* s) {
|
||||
Z3_ast r = Z3_parse_smtlib2_string(*this, s, 0, 0, 0, 0, 0, 0);
|
||||
check_error();
|
||||
return expr(*this, r);
|
||||
|
||||
check_parser_error();
|
||||
return expr(*this, r);
|
||||
}
|
||||
inline expr context::parse_file(char const* s) {
|
||||
Z3_ast r = Z3_parse_smtlib2_file(*this, s, 0, 0, 0, 0, 0, 0);
|
||||
check_error();
|
||||
check_parser_error();
|
||||
return expr(*this, r);
|
||||
}
|
||||
|
||||
|
@ -2796,7 +2863,7 @@ namespace z3 {
|
|||
decl_names[i] = decls[i].name();
|
||||
}
|
||||
Z3_ast r = Z3_parse_smtlib2_string(*this, s, sorts.size(), sort_names.ptr(), sorts1.ptr(), decls.size(), decl_names.ptr(), decls1.ptr());
|
||||
check_error();
|
||||
check_parser_error();
|
||||
return expr(*this, r);
|
||||
}
|
||||
|
||||
|
@ -2812,7 +2879,7 @@ namespace z3 {
|
|||
decl_names[i] = decls[i].name();
|
||||
}
|
||||
Z3_ast r = Z3_parse_smtlib2_file(*this, s, sorts.size(), sort_names.ptr(), sorts1.ptr(), decls.size(), decl_names.ptr(), decls1.ptr());
|
||||
check_error();
|
||||
check_parser_error();
|
||||
return expr(*this, r);
|
||||
}
|
||||
|
||||
|
|
|
@ -2262,7 +2262,7 @@ namespace Microsoft.Z3
|
|||
/// Maps f on the argument arrays.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Eeach element of <c>args</c> must be of an array sort <c>[domain_i -> range_i]</c>.
|
||||
/// Each element of <c>args</c> must be of an array sort <c>[domain_i -> range_i]</c>.
|
||||
/// The function declaration <c>f</c> must have type <c> range_1 .. range_n -> range</c>.
|
||||
/// <c>v</c> must have sort range. The sort of the result is <c>[domain_i -> range]</c>.
|
||||
/// <seealso cref="MkArraySort(Sort, Sort)"/>
|
||||
|
@ -2862,7 +2862,7 @@ namespace Microsoft.Z3
|
|||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer.
|
||||
/// Create a Term of a given sort. This function can be used to create numerals that fit in a machine integer.
|
||||
/// It is slightly faster than <c>MakeNumeral</c> since it is not necessary to parse a string.
|
||||
/// </summary>
|
||||
/// <param name="v">Value of the numeral</param>
|
||||
|
@ -2878,7 +2878,7 @@ namespace Microsoft.Z3
|
|||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer.
|
||||
/// Create a Term of a given sort. This function can be used to create numerals that fit in a machine integer.
|
||||
/// It is slightly faster than <c>MakeNumeral</c> since it is not necessary to parse a string.
|
||||
/// </summary>
|
||||
/// <param name="v">Value of the numeral</param>
|
||||
|
@ -2894,7 +2894,7 @@ namespace Microsoft.Z3
|
|||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer.
|
||||
/// Create a Term of a given sort. This function can be used to create numerals that fit in a machine integer.
|
||||
/// It is slightly faster than <c>MakeNumeral</c> since it is not necessary to parse a string.
|
||||
/// </summary>
|
||||
/// <param name="v">Value of the numeral</param>
|
||||
|
@ -2910,7 +2910,7 @@ namespace Microsoft.Z3
|
|||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer.
|
||||
/// Create a Term of a given sort. This function can be used to create numerals that fit in a machine integer.
|
||||
/// It is slightly faster than <c>MakeNumeral</c> since it is not necessary to parse a string.
|
||||
/// </summary>
|
||||
/// <param name="v">Value of the numeral</param>
|
||||
|
@ -3211,7 +3211,7 @@ namespace Microsoft.Z3
|
|||
/// Create an existential Quantifier.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Creates an existential quantifier using de-Brujin indexed variables.
|
||||
/// Creates an existential quantifier using de-Bruijn indexed variables.
|
||||
/// (<see cref="MkForall(Sort[], Symbol[], Expr, uint, Pattern[], Expr[], Symbol, Symbol)"/>).
|
||||
/// </remarks>
|
||||
public Quantifier MkExists(Sort[] sorts, Symbol[] names, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null)
|
||||
|
@ -3320,160 +3320,10 @@ namespace Microsoft.Z3
|
|||
#endregion
|
||||
|
||||
#region SMT Files & Strings
|
||||
/// <summary>
|
||||
/// Convert a benchmark into an SMT-LIB formatted string.
|
||||
/// </summary>
|
||||
/// <param name="name">Name of the benchmark. The argument is optional.</param>
|
||||
/// <param name="logic">The benchmark logic. </param>
|
||||
/// <param name="status">The status string (sat, unsat, or unknown)</param>
|
||||
/// <param name="attributes">Other attributes, such as source, difficulty or category.</param>
|
||||
/// <param name="assumptions">Auxiliary assumptions.</param>
|
||||
/// <param name="formula">Formula to be checked for consistency in conjunction with assumptions.</param>
|
||||
/// <returns>A string representation of the benchmark.</returns>
|
||||
public string BenchmarkToSMTString(string name, string logic, string status, string attributes,
|
||||
BoolExpr[] assumptions, BoolExpr formula)
|
||||
{
|
||||
Contract.Requires(assumptions != null);
|
||||
Contract.Requires(formula != null);
|
||||
Contract.Ensures(Contract.Result<string>() != null);
|
||||
|
||||
return Native.Z3_benchmark_to_smtlib_string(nCtx, name, logic, status, attributes,
|
||||
(uint)assumptions.Length, AST.ArrayToNative(assumptions),
|
||||
formula.NativeObject);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Parse the given string using the SMT-LIB parser.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// The symbol table of the parser can be initialized using the given sorts and declarations.
|
||||
/// The symbols in the arrays <paramref name="sortNames"/> and <paramref name="declNames"/>
|
||||
/// don't need to match the names of the sorts and declarations in the arrays <paramref name="sorts"/>
|
||||
/// and <paramref name="decls"/>. This is a useful feature since we can use arbitrary names to
|
||||
/// reference sorts and declarations.
|
||||
/// </remarks>
|
||||
public void ParseSMTLIBString(string str, Symbol[] sortNames = null, Sort[] sorts = null, Symbol[] declNames = null, FuncDecl[] decls = null)
|
||||
{
|
||||
uint csn = Symbol.ArrayLength(sortNames);
|
||||
uint cs = Sort.ArrayLength(sorts);
|
||||
uint cdn = Symbol.ArrayLength(declNames);
|
||||
uint cd = AST.ArrayLength(decls);
|
||||
if (csn != cs || cdn != cd)
|
||||
throw new Z3Exception("Argument size mismatch");
|
||||
Native.Z3_parse_smtlib_string(nCtx, str,
|
||||
AST.ArrayLength(sorts), Symbol.ArrayToNative(sortNames), AST.ArrayToNative(sorts),
|
||||
AST.ArrayLength(decls), Symbol.ArrayToNative(declNames), AST.ArrayToNative(decls));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Parse the given file using the SMT-LIB parser.
|
||||
/// </summary>
|
||||
/// <seealso cref="ParseSMTLIBString"/>
|
||||
public void ParseSMTLIBFile(string fileName, Symbol[] sortNames = null, Sort[] sorts = null, Symbol[] declNames = null, FuncDecl[] decls = null)
|
||||
{
|
||||
uint csn = Symbol.ArrayLength(sortNames);
|
||||
uint cs = Sort.ArrayLength(sorts);
|
||||
uint cdn = Symbol.ArrayLength(declNames);
|
||||
uint cd = AST.ArrayLength(decls);
|
||||
if (csn != cs || cdn != cd)
|
||||
throw new Z3Exception("Argument size mismatch");
|
||||
Native.Z3_parse_smtlib_file(nCtx, fileName,
|
||||
AST.ArrayLength(sorts), Symbol.ArrayToNative(sortNames), AST.ArrayToNative(sorts),
|
||||
AST.ArrayLength(decls), Symbol.ArrayToNative(declNames), AST.ArrayToNative(decls));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The number of SMTLIB formulas parsed by the last call to <c>ParseSMTLIBString</c> or <c>ParseSMTLIBFile</c>.
|
||||
/// </summary>
|
||||
public uint NumSMTLIBFormulas { get { return Native.Z3_get_smtlib_num_formulas(nCtx); } }
|
||||
|
||||
/// <summary>
|
||||
/// The formulas parsed by the last call to <c>ParseSMTLIBString</c> or <c>ParseSMTLIBFile</c>.
|
||||
/// </summary>
|
||||
public BoolExpr[] SMTLIBFormulas
|
||||
{
|
||||
get
|
||||
{
|
||||
Contract.Ensures(Contract.Result<BoolExpr[]>() != null);
|
||||
|
||||
uint n = NumSMTLIBFormulas;
|
||||
BoolExpr[] res = new BoolExpr[n];
|
||||
for (uint i = 0; i < n; i++)
|
||||
res[i] = (BoolExpr)Expr.Create(this, Native.Z3_get_smtlib_formula(nCtx, i));
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The number of SMTLIB assumptions parsed by the last call to <c>ParseSMTLIBString</c> or <c>ParseSMTLIBFile</c>.
|
||||
/// </summary>
|
||||
public uint NumSMTLIBAssumptions { get { return Native.Z3_get_smtlib_num_assumptions(nCtx); } }
|
||||
|
||||
/// <summary>
|
||||
/// The assumptions parsed by the last call to <c>ParseSMTLIBString</c> or <c>ParseSMTLIBFile</c>.
|
||||
/// </summary>
|
||||
public BoolExpr[] SMTLIBAssumptions
|
||||
{
|
||||
get
|
||||
{
|
||||
Contract.Ensures(Contract.Result<BoolExpr[]>() != null);
|
||||
|
||||
uint n = NumSMTLIBAssumptions;
|
||||
BoolExpr[] res = new BoolExpr[n];
|
||||
for (uint i = 0; i < n; i++)
|
||||
res[i] = (BoolExpr)Expr.Create(this, Native.Z3_get_smtlib_assumption(nCtx, i));
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The number of SMTLIB declarations parsed by the last call to <c>ParseSMTLIBString</c> or <c>ParseSMTLIBFile</c>.
|
||||
/// </summary>
|
||||
public uint NumSMTLIBDecls { get { return Native.Z3_get_smtlib_num_decls(nCtx); } }
|
||||
|
||||
/// <summary>
|
||||
/// The declarations parsed by the last call to <c>ParseSMTLIBString</c> or <c>ParseSMTLIBFile</c>.
|
||||
/// </summary>
|
||||
public FuncDecl[] SMTLIBDecls
|
||||
{
|
||||
get
|
||||
{
|
||||
Contract.Ensures(Contract.Result<FuncDecl[]>() != null);
|
||||
|
||||
uint n = NumSMTLIBDecls;
|
||||
FuncDecl[] res = new FuncDecl[n];
|
||||
for (uint i = 0; i < n; i++)
|
||||
res[i] = new FuncDecl(this, Native.Z3_get_smtlib_decl(nCtx, i));
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The number of SMTLIB sorts parsed by the last call to <c>ParseSMTLIBString</c> or <c>ParseSMTLIBFile</c>.
|
||||
/// </summary>
|
||||
public uint NumSMTLIBSorts { get { return Native.Z3_get_smtlib_num_sorts(nCtx); } }
|
||||
|
||||
/// <summary>
|
||||
/// The declarations parsed by the last call to <c>ParseSMTLIBString</c> or <c>ParseSMTLIBFile</c>.
|
||||
/// </summary>
|
||||
public Sort[] SMTLIBSorts
|
||||
{
|
||||
get
|
||||
{
|
||||
Contract.Ensures(Contract.Result<Sort[]>() != null);
|
||||
|
||||
uint n = NumSMTLIBSorts;
|
||||
Sort[] res = new Sort[n];
|
||||
for (uint i = 0; i < n; i++)
|
||||
res[i] = Sort.Create(this, Native.Z3_get_smtlib_sort(nCtx, i));
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Parse the given string using the SMT-LIB2 parser.
|
||||
/// </summary>
|
||||
/// <seealso cref="ParseSMTLIBString"/>
|
||||
/// <returns>A conjunction of assertions in the scope (up to push/pop) at the end of the string.</returns>
|
||||
public BoolExpr ParseSMTLIB2String(string str, Symbol[] sortNames = null, Sort[] sorts = null, Symbol[] declNames = null, FuncDecl[] decls = null)
|
||||
{
|
||||
|
|
|
@ -959,7 +959,7 @@ namespace Microsoft.Z3
|
|||
/// 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.
|
||||
/// That is, reflexivity proofs are suppressed to save space.
|
||||
/// </remarks>
|
||||
public bool IsProofMonotonicity { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_MONOTONICITY; } }
|
||||
|
||||
|
@ -1002,7 +1002,7 @@ namespace Microsoft.Z3
|
|||
public bool IsProofAndElimination { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_AND_ELIM; } }
|
||||
|
||||
/// <summary>
|
||||
/// Indicates whether the term is a proof by eliminiation of not-or
|
||||
/// Indicates whether the term is a proof by elimination of not-or
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Given a proof for (not (or l_1 ... l_n)), produces a proof for (not l_i).
|
||||
|
@ -1112,7 +1112,7 @@ namespace Microsoft.Z3
|
|||
public bool IsProofQuantInst { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_QUANT_INST; } }
|
||||
|
||||
/// <summary>
|
||||
/// Indicates whether the term is a hypthesis marker.
|
||||
/// Indicates whether the term is a hypothesis marker.
|
||||
/// </summary>
|
||||
/// <remarks>Mark a hypothesis in a natural deduction style proof.</remarks>
|
||||
public bool IsProofHypothesis { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_HYPOTHESIS; } }
|
||||
|
@ -1433,7 +1433,7 @@ namespace Microsoft.Z3
|
|||
/// <remarks>
|
||||
/// 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
|
||||
/// The second argument is a predicate with free de-Bruijn indices
|
||||
/// corresponding to the columns of the relation.
|
||||
/// So the first column in the relation has index 0.
|
||||
/// </remarks>
|
||||
|
@ -1649,7 +1649,7 @@ namespace Microsoft.Z3
|
|||
public bool IsFPMul { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_FPA_MUL; } }
|
||||
|
||||
/// <summary>
|
||||
/// Indicates whether the term is a floating-point divison term
|
||||
/// Indicates whether the term is a floating-point division term
|
||||
/// </summary>
|
||||
public bool IsFPDiv { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_FPA_DIV; } }
|
||||
|
||||
|
@ -1709,7 +1709,7 @@ namespace Microsoft.Z3
|
|||
public bool IsFPLe { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_FPA_LE; } }
|
||||
|
||||
/// <summary>
|
||||
/// Indicates whether the term is a floating-point greater-than or erqual term
|
||||
/// Indicates whether the term is a floating-point greater-than or equal term
|
||||
/// </summary>
|
||||
public bool IsFPGe { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_FPA_GE; } }
|
||||
|
||||
|
@ -1789,7 +1789,7 @@ namespace Microsoft.Z3
|
|||
|
||||
#region Bound Variables
|
||||
/// <summary>
|
||||
/// The de-Burijn index of a bound variable.
|
||||
/// The de-Bruijn index of a bound variable.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Bound variables are indexed by de-Bruijn indices. It is perhaps easiest to explain
|
||||
|
|
|
@ -253,7 +253,7 @@ namespace Microsoft.Z3
|
|||
/// The uninterpreted sorts that the model has an interpretation for.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Z3 also provides an intepretation for uninterpreted sorts used in a formula.
|
||||
/// Z3 also provides an interpretation for uninterpreted sorts used in a formula.
|
||||
/// The interpretation for a sort is a finite set of distinct values. We say this finite set is
|
||||
/// the "universe" of the sort.
|
||||
/// </remarks>
|
||||
|
|
|
@ -31,98 +31,108 @@ namespace Microsoft.Z3
|
|||
/// <summary>
|
||||
/// Adds a parameter setting.
|
||||
/// </summary>
|
||||
public void Add(Symbol name, bool value)
|
||||
public Params Add(Symbol name, bool value)
|
||||
{
|
||||
Contract.Requires(name != null);
|
||||
|
||||
Native.Z3_params_set_bool(Context.nCtx, NativeObject, name.NativeObject, (value) ? 1 : 0);
|
||||
return this;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds a parameter setting.
|
||||
/// </summary>
|
||||
public void Add(Symbol name, uint value)
|
||||
public Params Add(Symbol name, uint value)
|
||||
{
|
||||
Contract.Requires(name != null);
|
||||
|
||||
Native.Z3_params_set_uint(Context.nCtx, NativeObject, name.NativeObject, value);
|
||||
return this;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds a parameter setting.
|
||||
/// </summary>
|
||||
public void Add(Symbol name, double value)
|
||||
public Params Add(Symbol name, double value)
|
||||
{
|
||||
Contract.Requires(name != null);
|
||||
|
||||
Contract.Requires(name != null);
|
||||
|
||||
Native.Z3_params_set_double(Context.nCtx, NativeObject, name.NativeObject, value);
|
||||
return this;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds a parameter setting.
|
||||
/// </summary>
|
||||
public void Add(Symbol name, string value)
|
||||
public Params Add(Symbol name, string value)
|
||||
{
|
||||
Contract.Requires(value != null);
|
||||
|
||||
Native.Z3_params_set_symbol(Context.nCtx, NativeObject, name.NativeObject, Context.MkSymbol(value).NativeObject);
|
||||
return this;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds a parameter setting.
|
||||
/// </summary>
|
||||
public void Add(Symbol name, Symbol value)
|
||||
public Params Add(Symbol name, Symbol value)
|
||||
{
|
||||
Contract.Requires(name != null);
|
||||
Contract.Requires(value != null);
|
||||
|
||||
Native.Z3_params_set_symbol(Context.nCtx, NativeObject, name.NativeObject, value.NativeObject);
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Adds a parameter setting.
|
||||
/// </summary>
|
||||
public void Add(string name, bool value)
|
||||
public Params Add(string name, bool value)
|
||||
{
|
||||
Native.Z3_params_set_bool(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, (value) ? 1 : 0);
|
||||
return this;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds a parameter setting.
|
||||
/// </summary>
|
||||
public void Add(string name, uint value)
|
||||
public Params Add(string name, uint value)
|
||||
{
|
||||
Native.Z3_params_set_uint(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value);
|
||||
return this;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds a parameter setting.
|
||||
/// </summary>
|
||||
public void Add(string name, double value)
|
||||
public Params Add(string name, double value)
|
||||
{
|
||||
Native.Z3_params_set_double(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value);
|
||||
return this;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds a parameter setting.
|
||||
/// </summary>
|
||||
public void Add(string name, Symbol value)
|
||||
public Params Add(string name, Symbol value)
|
||||
{
|
||||
Contract.Requires(value != null);
|
||||
|
||||
Native.Z3_params_set_symbol(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value.NativeObject);
|
||||
return this;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds a parameter setting.
|
||||
/// </summary>
|
||||
public void Add(string name, string value)
|
||||
public Params Add(string name, string value)
|
||||
{
|
||||
Contract.Requires(name != null);
|
||||
Contract.Requires(value != null);
|
||||
|
||||
Native.Z3_params_set_symbol(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, Context.MkSymbol(value).NativeObject);
|
||||
return this;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
|
@ -57,6 +57,49 @@ namespace Microsoft.Z3
|
|||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Sets parameter on the solver
|
||||
/// </summary>
|
||||
public void Set(string name, bool value) { Parameters = Context.MkParams().Add(name, value); }
|
||||
/// <summary>
|
||||
/// Sets parameter on the solver
|
||||
/// </summary>
|
||||
public void Set(string name, uint value) { Parameters = Context.MkParams().Add(name, value); }
|
||||
/// <summary>
|
||||
/// Sets parameter on the solver
|
||||
/// </summary>
|
||||
public void Set(string name, double value) { Parameters = Context.MkParams().Add(name, value); }
|
||||
/// <summary>
|
||||
/// Sets parameter on the solver
|
||||
/// </summary>
|
||||
public void Set(string name, string value) { Parameters = Context.MkParams().Add(name, value); }
|
||||
/// <summary>
|
||||
/// Sets parameter on the solver
|
||||
/// </summary>
|
||||
public void Set(string name, Symbol value) { Parameters = Context.MkParams().Add(name, value); }
|
||||
/// <summary>
|
||||
/// Sets parameter on the solver
|
||||
/// </summary>
|
||||
public void Set(Symbol name, bool value) { Parameters = Context.MkParams().Add(name, value); }
|
||||
/// <summary>
|
||||
/// Sets parameter on the solver
|
||||
/// </summary>
|
||||
public void Set(Symbol name, uint value) { Parameters = Context.MkParams().Add(name, value); }
|
||||
/// <summary>
|
||||
/// Sets parameter on the solver
|
||||
/// </summary>
|
||||
public void Set(Symbol name, double value) { Parameters = Context.MkParams().Add(name, value); }
|
||||
/// <summary>
|
||||
/// Sets parameter on the solver
|
||||
/// </summary>
|
||||
public void Set(Symbol name, string value) { Parameters = Context.MkParams().Add(name, value); }
|
||||
/// <summary>
|
||||
/// Sets parameter on the solver
|
||||
/// </summary>
|
||||
public void Set(Symbol name, Symbol value) { Parameters = Context.MkParams().Add(name, value); }
|
||||
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Retrieves parameter descriptions for solver.
|
||||
/// </summary>
|
||||
|
@ -140,11 +183,11 @@ namespace Microsoft.Z3
|
|||
/// using the Boolean constants in ps.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// This API is an alternative to <see cref="Check"/> with assumptions for extracting unsat cores.
|
||||
/// This API is an alternative to <see cref="Check(Expr[])"/> with assumptions for extracting unsat cores.
|
||||
/// Both APIs can be used in the same solver. The unsat core will contain a combination
|
||||
/// of the Boolean variables provided using <see cref="AssertAndTrack(BoolExpr[],BoolExpr[])"/>
|
||||
/// and the Boolean literals
|
||||
/// provided using <see cref="Check"/> with assumptions.
|
||||
/// provided using <see cref="Check(Expr[])"/> with assumptions.
|
||||
/// </remarks>
|
||||
public void AssertAndTrack(BoolExpr[] constraints, BoolExpr[] ps)
|
||||
{
|
||||
|
@ -165,11 +208,11 @@ namespace Microsoft.Z3
|
|||
/// using the Boolean constant p.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// This API is an alternative to <see cref="Check"/> with assumptions for extracting unsat cores.
|
||||
/// This API is an alternative to <see cref="Check(Expr[])"/> with assumptions for extracting unsat cores.
|
||||
/// Both APIs can be used in the same solver. The unsat core will contain a combination
|
||||
/// of the Boolean variables provided using <see cref="AssertAndTrack(BoolExpr[],BoolExpr[])"/>
|
||||
/// and the Boolean literals
|
||||
/// provided using <see cref="Check"/> with assumptions.
|
||||
/// provided using <see cref="Check(Expr[])"/> with assumptions.
|
||||
/// </remarks>
|
||||
public void AssertAndTrack(BoolExpr constraint, BoolExpr p)
|
||||
{
|
||||
|
@ -181,6 +224,22 @@ namespace Microsoft.Z3
|
|||
Native.Z3_solver_assert_and_track(Context.nCtx, NativeObject, constraint.NativeObject, p.NativeObject);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Load solver assertions from a file.
|
||||
/// </summary>
|
||||
public void FromFile(string file)
|
||||
{
|
||||
Native.Z3_solver_from_file(Context.nCtx, NativeObject, file);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Load solver assertions from a string.
|
||||
/// </summary>
|
||||
public void FromString(string str)
|
||||
{
|
||||
Native.Z3_solver_from_string(Context.nCtx, NativeObject, str);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The number of assertions in the solver.
|
||||
/// </summary>
|
||||
|
@ -225,6 +284,25 @@ namespace Microsoft.Z3
|
|||
return lboolToStatus(r);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Checks whether the assertions in the solver are consistent or not.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <seealso cref="Model"/>
|
||||
/// <seealso cref="UnsatCore"/>
|
||||
/// <seealso cref="Proof"/>
|
||||
/// </remarks>
|
||||
public Status Check(IEnumerable<BoolExpr> assumptions)
|
||||
{
|
||||
Z3_lbool r;
|
||||
BoolExpr[] asms = assumptions.ToArray();
|
||||
if (asms.Length == 0)
|
||||
r = (Z3_lbool)Native.Z3_solver_check(Context.nCtx, NativeObject);
|
||||
else
|
||||
r = (Z3_lbool)Native.Z3_solver_check_assumptions(Context.nCtx, NativeObject, (uint)asms.Length, AST.ArrayToNative(asms));
|
||||
return lboolToStatus(r);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Retrieve fixed assignments to the set of variables in the form of consequences.
|
||||
/// Each consequence is an implication of the form
|
||||
|
|
|
@ -56,7 +56,7 @@ namespace Microsoft.Z3
|
|||
public bool IsDouble { get { return m_is_double; } }
|
||||
|
||||
/// <summary>
|
||||
/// The string representation of the the entry's value.
|
||||
/// The string representation of the entry's value.
|
||||
/// </summary>
|
||||
public string Value
|
||||
{
|
||||
|
|
|
@ -934,7 +934,7 @@ public class Context implements AutoCloseable {
|
|||
* exposed. It follows the semantics prescribed by the SMT-LIB standard.
|
||||
*
|
||||
* You can take the floor of a real by creating an auxiliary integer Term
|
||||
* {@code k} and and asserting
|
||||
* {@code k} and asserting
|
||||
* {@code MakeInt2Real(k) <= t1 < MkInt2Real(k)+1}. The argument
|
||||
* must be of integer sort.
|
||||
**/
|
||||
|
@ -2234,7 +2234,7 @@ public class Context implements AutoCloseable {
|
|||
}
|
||||
|
||||
/**
|
||||
* Create a Term of a given sort. This function can be use to create
|
||||
* Create a Term of a given sort. This function can be used to create
|
||||
* numerals that fit in a machine integer. It is slightly faster than
|
||||
* {@code MakeNumeral} since it is not necessary to parse a string.
|
||||
*
|
||||
|
@ -2250,7 +2250,7 @@ public class Context implements AutoCloseable {
|
|||
}
|
||||
|
||||
/**
|
||||
* Create a Term of a given sort. This function can be use to create
|
||||
* Create a Term of a given sort. This function can be used to create
|
||||
* numerals that fit in a machine integer. It is slightly faster than
|
||||
* {@code MakeNumeral} since it is not necessary to parse a string.
|
||||
*
|
||||
|
@ -2438,7 +2438,7 @@ public class Context implements AutoCloseable {
|
|||
}
|
||||
|
||||
/**
|
||||
* Creates an existential quantifier using de-Brujin indexed variables.
|
||||
* Creates an existential quantifier using de-Bruijn indexed variables.
|
||||
* @see #mkForall(Sort[],Symbol[],Expr,int,Pattern[],Expr[],Symbol,Symbol)
|
||||
**/
|
||||
public Quantifier mkExists(Sort[] sorts, Symbol[] names, Expr body,
|
||||
|
@ -2540,147 +2540,8 @@ public class Context implements AutoCloseable {
|
|||
AST.arrayToNative(assumptions), formula.getNativeObject());
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the given string using the SMT-LIB parser.
|
||||
* Remarks: The symbol
|
||||
* table of the parser can be initialized using the given sorts and
|
||||
* declarations. The symbols in the arrays {@code sortNames} and
|
||||
* {@code declNames} don't need to match the names of the sorts
|
||||
* and declarations in the arrays {@code sorts} and {@code decls}. This is a useful feature since we can use arbitrary names
|
||||
* to reference sorts and declarations.
|
||||
**/
|
||||
public void parseSMTLIBString(String str, Symbol[] sortNames, Sort[] sorts,
|
||||
Symbol[] declNames, FuncDecl[] decls)
|
||||
{
|
||||
int csn = Symbol.arrayLength(sortNames);
|
||||
int cs = Sort.arrayLength(sorts);
|
||||
int cdn = Symbol.arrayLength(declNames);
|
||||
int cd = AST.arrayLength(decls);
|
||||
if (csn != cs || cdn != cd)
|
||||
throw new Z3Exception("Argument size mismatch");
|
||||
Native.parseSmtlibString(nCtx(), str, AST.arrayLength(sorts),
|
||||
Symbol.arrayToNative(sortNames), AST.arrayToNative(sorts),
|
||||
AST.arrayLength(decls), Symbol.arrayToNative(declNames),
|
||||
AST.arrayToNative(decls));
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the given file using the SMT-LIB parser.
|
||||
* @see #parseSMTLIBString
|
||||
**/
|
||||
public void parseSMTLIBFile(String fileName, Symbol[] sortNames,
|
||||
Sort[] sorts, Symbol[] declNames, FuncDecl[] decls)
|
||||
|
||||
{
|
||||
int csn = Symbol.arrayLength(sortNames);
|
||||
int cs = Sort.arrayLength(sorts);
|
||||
int cdn = Symbol.arrayLength(declNames);
|
||||
int cd = AST.arrayLength(decls);
|
||||
if (csn != cs || cdn != cd)
|
||||
throw new Z3Exception("Argument size mismatch");
|
||||
Native.parseSmtlibFile(nCtx(), fileName, AST.arrayLength(sorts),
|
||||
Symbol.arrayToNative(sortNames), AST.arrayToNative(sorts),
|
||||
AST.arrayLength(decls), Symbol.arrayToNative(declNames),
|
||||
AST.arrayToNative(decls));
|
||||
}
|
||||
|
||||
/**
|
||||
* The number of SMTLIB formulas parsed by the last call to
|
||||
* {@code ParseSMTLIBString} or {@code ParseSMTLIBFile}.
|
||||
**/
|
||||
public int getNumSMTLIBFormulas()
|
||||
{
|
||||
return Native.getSmtlibNumFormulas(nCtx());
|
||||
}
|
||||
|
||||
/**
|
||||
* The formulas parsed by the last call to {@code ParseSMTLIBString} or
|
||||
* {@code ParseSMTLIBFile}.
|
||||
**/
|
||||
public BoolExpr[] getSMTLIBFormulas()
|
||||
{
|
||||
|
||||
int n = getNumSMTLIBFormulas();
|
||||
BoolExpr[] res = new BoolExpr[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = (BoolExpr) Expr.create(this,
|
||||
Native.getSmtlibFormula(nCtx(), i));
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* The number of SMTLIB assumptions parsed by the last call to
|
||||
* {@code ParseSMTLIBString} or {@code ParseSMTLIBFile}.
|
||||
**/
|
||||
public int getNumSMTLIBAssumptions()
|
||||
{
|
||||
return Native.getSmtlibNumAssumptions(nCtx());
|
||||
}
|
||||
|
||||
/**
|
||||
* The assumptions parsed by the last call to {@code ParseSMTLIBString}
|
||||
* or {@code ParseSMTLIBFile}.
|
||||
**/
|
||||
public BoolExpr[] getSMTLIBAssumptions()
|
||||
{
|
||||
|
||||
int n = getNumSMTLIBAssumptions();
|
||||
BoolExpr[] res = new BoolExpr[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = (BoolExpr) Expr.create(this,
|
||||
Native.getSmtlibAssumption(nCtx(), i));
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* The number of SMTLIB declarations parsed by the last call to
|
||||
* {@code ParseSMTLIBString} or {@code ParseSMTLIBFile}.
|
||||
**/
|
||||
public int getNumSMTLIBDecls()
|
||||
{
|
||||
return Native.getSmtlibNumDecls(nCtx());
|
||||
}
|
||||
|
||||
/**
|
||||
* The declarations parsed by the last call to
|
||||
* {@code ParseSMTLIBString} or {@code ParseSMTLIBFile}.
|
||||
**/
|
||||
public FuncDecl[] getSMTLIBDecls()
|
||||
{
|
||||
|
||||
int n = getNumSMTLIBDecls();
|
||||
FuncDecl[] res = new FuncDecl[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = new FuncDecl(this, Native.getSmtlibDecl(nCtx(), i));
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* The number of SMTLIB sorts parsed by the last call to
|
||||
* {@code ParseSMTLIBString} or {@code ParseSMTLIBFile}.
|
||||
**/
|
||||
public int getNumSMTLIBSorts()
|
||||
{
|
||||
return Native.getSmtlibNumSorts(nCtx());
|
||||
}
|
||||
|
||||
/**
|
||||
* The declarations parsed by the last call to
|
||||
* {@code ParseSMTLIBString} or {@code ParseSMTLIBFile}.
|
||||
**/
|
||||
public Sort[] getSMTLIBSorts()
|
||||
{
|
||||
|
||||
int n = getNumSMTLIBSorts();
|
||||
Sort[] res = new Sort[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
res[i] = Sort.create(this, Native.getSmtlibSort(nCtx(), i));
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the given string using the SMT-LIB2 parser.
|
||||
* @see #parseSMTLIBString
|
||||
*
|
||||
* @return A conjunction of assertions in the scope (up to push/pop) at the
|
||||
* end of the string.
|
||||
|
|
|
@ -1421,7 +1421,7 @@ public class Expr extends AST
|
|||
* Remarks: 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.
|
||||
* suppressed. That is, reflexivity proofs are suppressed to save space.
|
||||
*
|
||||
* @throws Z3Exception on error
|
||||
* @return a boolean
|
||||
|
@ -1473,7 +1473,7 @@ public class Expr extends AST
|
|||
}
|
||||
|
||||
/**
|
||||
* Indicates whether the term is a proof by eliminiation of not-or
|
||||
* Indicates whether the term is a proof by elimination of not-or
|
||||
* Remarks: * Given a proof for (not (or l_1 ... l_n)), produces a proof for (not l_i). * T1: (not (or l_1 ... l_n)) [not-or-elim T1]: (not l_i)
|
||||
* @throws Z3Exception on error
|
||||
* @return a boolean
|
||||
|
@ -1605,7 +1605,7 @@ public class Expr extends AST
|
|||
}
|
||||
|
||||
/**
|
||||
* Indicates whether the term is a hypthesis marker.
|
||||
* Indicates whether the term is a hypothesis marker.
|
||||
* Remarks: Mark a
|
||||
* hypothesis in a natural deduction style proof.
|
||||
* @throws Z3Exception on error
|
||||
|
@ -1987,7 +1987,7 @@ public class Expr extends AST
|
|||
* Indicates whether the term is a relation filter
|
||||
* Remarks: 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
|
||||
* a relation. The second argument is a predicate with free de-Bruijn
|
||||
* indices corresponding to the columns of the relation. So the first column
|
||||
* in the relation has index 0.
|
||||
* @throws Z3Exception on error
|
||||
|
@ -2094,7 +2094,7 @@ public class Expr extends AST
|
|||
}
|
||||
|
||||
/**
|
||||
* The de-Burijn index of a bound variable.
|
||||
* The de-Bruijn index of a bound variable.
|
||||
* Remarks: 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
|
||||
|
|
|
@ -239,7 +239,7 @@ public class Model extends Z3Object {
|
|||
|
||||
/**
|
||||
* The uninterpreted sorts that the model has an interpretation for.
|
||||
* Remarks: Z3 also provides an intepretation for uninterpreted sorts used
|
||||
* Remarks: Z3 also provides an interpretation for uninterpreted sorts used
|
||||
* in a formula. The interpretation for a sort is a finite set of distinct
|
||||
* values. We say this finite set is the "universe" of the sort.
|
||||
*
|
||||
|
|
|
@ -1,3 +1,4 @@
|
|||
|
||||
/**
|
||||
Copyright (c) 2012-2014 Microsoft Corporation
|
||||
|
||||
|
@ -120,6 +121,23 @@ public class Solver extends Z3Object {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Load solver assertions from a file.
|
||||
*/
|
||||
public void fromFile(String file)
|
||||
{
|
||||
Native.solverFromFile(getContext().nCtx(), getNativeObject(), file);
|
||||
}
|
||||
|
||||
/**
|
||||
* Load solver assertions from a string.
|
||||
*/
|
||||
public void fromString(String str)
|
||||
{
|
||||
Native.solverFromString(getContext().nCtx(), getNativeObject(), str);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Assert multiple constraints into the solver, and track them (in the
|
||||
* unsat) core
|
||||
|
|
|
@ -65,7 +65,7 @@ public class Statistics extends Z3Object {
|
|||
}
|
||||
|
||||
/**
|
||||
* The string representation of the the entry's value.
|
||||
* The string representation of the entry's value.
|
||||
*
|
||||
* @throws Z3Exception
|
||||
**/
|
||||
|
|
|
@ -1975,56 +1975,6 @@ struct
|
|||
(List.length assumptions) assumptions
|
||||
formula
|
||||
|
||||
let parse_smtlib_string (ctx:context) (str:string) (sort_names:Symbol.symbol list) (sorts:Sort.sort list) (decl_names:Symbol.symbol list) (decls:func_decl list) =
|
||||
let csn = List.length sort_names in
|
||||
let cs = List.length sorts in
|
||||
let cdn = List.length decl_names in
|
||||
let cd = List.length decls in
|
||||
if (csn <> cs || cdn <> cd) then
|
||||
raise (Error "Argument size mismatch")
|
||||
else
|
||||
Z3native.parse_smtlib_string ctx str
|
||||
cs sort_names sorts cd decl_names decls
|
||||
|
||||
let parse_smtlib_file (ctx:context) (file_name:string) (sort_names:Symbol.symbol list) (sorts:Sort.sort list) (decl_names:Symbol.symbol list) (decls:func_decl list) =
|
||||
let csn = (List.length sort_names) in
|
||||
let cs = (List.length sorts) in
|
||||
let cdn = (List.length decl_names) in
|
||||
let cd = (List.length decls) in
|
||||
if (csn <> cs || cdn <> cd) then
|
||||
raise (Error "Argument size mismatch")
|
||||
else
|
||||
Z3native.parse_smtlib_file ctx file_name
|
||||
cs sort_names sorts cd decl_names decls
|
||||
|
||||
let get_num_smtlib_formulas (ctx:context) = Z3native.get_smtlib_num_formulas ctx
|
||||
|
||||
let get_smtlib_formulas (ctx:context) =
|
||||
let n = get_num_smtlib_formulas ctx in
|
||||
let f i = Z3native.get_smtlib_formula ctx i in
|
||||
mk_list f n
|
||||
|
||||
let get_num_smtlib_assumptions (ctx:context) = Z3native.get_smtlib_num_assumptions ctx
|
||||
|
||||
let get_smtlib_assumptions (ctx:context) =
|
||||
let n = get_num_smtlib_assumptions ctx in
|
||||
let f i = Z3native.get_smtlib_assumption ctx i in
|
||||
mk_list f n
|
||||
|
||||
let get_num_smtlib_decls (ctx:context) = Z3native.get_smtlib_num_decls ctx
|
||||
|
||||
let get_smtlib_decls (ctx:context) =
|
||||
let n = get_num_smtlib_decls ctx in
|
||||
let f i = Z3native.get_smtlib_decl ctx i in
|
||||
mk_list f n
|
||||
|
||||
let get_num_smtlib_sorts (ctx:context) = Z3native.get_smtlib_num_sorts ctx
|
||||
|
||||
let get_smtlib_sorts (ctx:context) =
|
||||
let n = get_num_smtlib_sorts ctx in
|
||||
let f i = Z3native.get_smtlib_sort ctx i in
|
||||
mk_list f n
|
||||
|
||||
let parse_smtlib2_string (ctx:context) (str:string) (sort_names:Symbol.symbol list) (sorts:Sort.sort list) (decl_names:Symbol.symbol list) (decls:func_decl list) =
|
||||
let csn = List.length sort_names in
|
||||
let cs = List.length sorts in
|
||||
|
@ -2044,7 +1994,7 @@ struct
|
|||
if csn <> cs || cdn <> cd then
|
||||
raise (Error "Argument size mismatch")
|
||||
else
|
||||
Z3native.parse_smtlib2_string ctx file_name
|
||||
Z3native.parse_smtlib2_file ctx file_name
|
||||
cs sort_names sorts cd decl_names decls
|
||||
end
|
||||
|
||||
|
|
|
@ -536,7 +536,7 @@ sig
|
|||
@return A Term with the given value and sort *)
|
||||
val mk_numeral_string : context -> string -> Sort.sort -> expr
|
||||
|
||||
(** Create a numeral of a given sort. This function can be use to create numerals that fit in a machine integer.
|
||||
(** Create a numeral of a given sort. This function can be used to create numerals that fit in a machine integer.
|
||||
It is slightly faster than [MakeNumeral] since it is not necessary to parse a string.
|
||||
@return A Term with the given value and sort *)
|
||||
val mk_numeral_int : context -> int -> Sort.sort -> expr
|
||||
|
@ -667,7 +667,7 @@ sig
|
|||
end
|
||||
|
||||
|
||||
(** The de-Burijn index of a bound variable.
|
||||
(** The de-Bruijn index of 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
|
||||
|
@ -830,7 +830,7 @@ sig
|
|||
|
||||
(** Maps f on the argument arrays.
|
||||
|
||||
Eeach element of [args] must be of an array sort [[domain_i -> range_i]].
|
||||
Each element of [args] must be of an array sort [[domain_i -> range_i]].
|
||||
The function declaration [f] must have type [ range_1 .. range_n -> range].
|
||||
[v] must have sort range. The sort of the result is [[domain_i -> range]].
|
||||
{!Z3Array.mk_sort}
|
||||
|
@ -962,7 +962,7 @@ sig
|
|||
|
||||
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
|
||||
The second argument is a predicate with free de-Bruijn indices
|
||||
corresponding to the columns of the relation.
|
||||
So the first column in the relation has index 0. *)
|
||||
val is_filter : Expr.expr -> bool
|
||||
|
@ -2085,7 +2085,7 @@ sig
|
|||
(** Indicates whether an expression is a floating-point lt expression *)
|
||||
val is_lt : Expr.expr -> bool
|
||||
|
||||
(** Indicates whether an expression is a floating-point geqexpression *)
|
||||
(** Indicates whether an expression is a floating-point geq expression *)
|
||||
val is_geq : Expr.expr -> bool
|
||||
|
||||
(** Indicates whether an expression is a floating-point gt expression *)
|
||||
|
@ -2233,7 +2233,7 @@ sig
|
|||
(** Conversion of a 2's complement unsigned bit-vector term into a term of FloatingPoint sort. *)
|
||||
val mk_to_fp_unsigned : context -> Expr.expr -> Expr.expr -> Sort.sort -> Expr.expr
|
||||
|
||||
(** C1onversion of a floating-point term into an unsigned bit-vector. *)
|
||||
(** Conversion of a floating-point term into an unsigned bit-vector. *)
|
||||
val mk_to_ubv : context -> Expr.expr -> Expr.expr -> int -> Expr.expr
|
||||
|
||||
(** Conversion of a floating-point term into a signed bit-vector. *)
|
||||
|
@ -2385,7 +2385,7 @@ sig
|
|||
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. *)
|
||||
That is, reflexivity proofs are suppressed to save space. *)
|
||||
val is_monotonicity : Expr.expr -> bool
|
||||
|
||||
(** Indicates whether the term is a quant-intro proof
|
||||
|
@ -2417,7 +2417,7 @@ sig
|
|||
[and-elim T1]: l_i *)
|
||||
val is_and_elimination : Expr.expr -> bool
|
||||
|
||||
(** Indicates whether the term is a proof by eliminiation of not-or
|
||||
(** Indicates whether the term is a proof by elimination of not-or
|
||||
|
||||
Given a proof for (not (or l_1 ... l_n)), produces a proof for (not l_i).
|
||||
T1: (not (or l_1 ... l_n))
|
||||
|
@ -2500,7 +2500,7 @@ sig
|
|||
A proof of (or (not (forall (x) (P x))) (P a)) *)
|
||||
val is_quant_inst : Expr.expr -> bool
|
||||
|
||||
(** Indicates whether the term is a hypthesis marker.
|
||||
(** Indicates whether the term is a hypothesis marker.
|
||||
Mark a hypothesis in a natural deduction style proof. *)
|
||||
val is_hypothesis : Expr.expr -> bool
|
||||
|
||||
|
@ -2882,7 +2882,7 @@ sig
|
|||
|
||||
(** The uninterpreted sorts that the model has an interpretation for.
|
||||
|
||||
Z3 also provides an intepretation for uninterpreted sorts used in a formula.
|
||||
Z3 also provides an interpretation for uninterpreted sorts used in a formula.
|
||||
The interpretation for a sort is a finite set of distinct values. We say this finite set is
|
||||
the "universe" of the sort.
|
||||
{!get_num_sorts}
|
||||
|
@ -3056,7 +3056,7 @@ sig
|
|||
(** Create a tactic that fails if the probe evaluates to false. *)
|
||||
val fail_if : context -> Probe.probe -> tactic
|
||||
|
||||
(** Create a tactic that fails if the goal is not triviall satisfiable (i.e., empty)
|
||||
(** Create a tactic that fails if the goal is not trivially satisfiable (i.e., empty)
|
||||
or trivially unsatisfiable (i.e., contains `false'). *)
|
||||
val fail_if_not_decided : context -> tactic
|
||||
|
||||
|
@ -3105,7 +3105,7 @@ sig
|
|||
(** True if the entry is float-valued. *)
|
||||
val is_float : statistics_entry -> bool
|
||||
|
||||
(** The string representation of the the entry's value. *)
|
||||
(** The string representation of the entry's value. *)
|
||||
val to_string_value : statistics_entry -> string
|
||||
|
||||
(** The string representation of the entry (key and value) *)
|
||||
|
@ -3370,7 +3370,7 @@ sig
|
|||
(** Assert a constraints into the optimize solver. *)
|
||||
val add : optimize -> Expr.expr list -> unit
|
||||
|
||||
(** Asssert a soft constraint.
|
||||
(** Assert a soft constraint.
|
||||
Supply integer weight and string that identifies a group
|
||||
of soft constraints. *)
|
||||
val add_soft : optimize -> Expr.expr -> string -> Symbol.symbol -> handle
|
||||
|
@ -3441,51 +3441,12 @@ sig
|
|||
@return A string representation of the benchmark. *)
|
||||
val benchmark_to_smtstring : context -> string -> string -> string -> string -> Expr.expr list -> Expr.expr -> string
|
||||
|
||||
(** 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 in the third and fifth argument
|
||||
don't need to match the names of the sorts and declarations in the arrays in the fourth
|
||||
and sixth argument. This is a useful feature since we can use arbitrary names to
|
||||
reference sorts and declarations. *)
|
||||
val parse_smtlib_string : context -> string -> Symbol.symbol list -> Sort.sort list -> Symbol.symbol list -> FuncDecl.func_decl list -> unit
|
||||
|
||||
(** Parse the given file using the SMT-LIB parser.
|
||||
{!parse_smtlib_string} *)
|
||||
val parse_smtlib_file : context -> string -> Symbol.symbol list -> Sort.sort list -> Symbol.symbol list -> FuncDecl.func_decl list -> unit
|
||||
|
||||
(** The number of SMTLIB formulas parsed by the last call to [ParseSMTLIBString] or [ParseSMTLIBFile]. *)
|
||||
val get_num_smtlib_formulas : context -> int
|
||||
|
||||
(** The formulas parsed by the last call to [ParseSMTLIBString] or [ParseSMTLIBFile]. *)
|
||||
val get_smtlib_formulas : context -> Expr.expr list
|
||||
|
||||
(** The number of SMTLIB assumptions parsed by the last call to [ParseSMTLIBString] or [ParseSMTLIBFile]. *)
|
||||
val get_num_smtlib_assumptions : context -> int
|
||||
|
||||
(** The assumptions parsed by the last call to [ParseSMTLIBString] or [ParseSMTLIBFile]. *)
|
||||
val get_smtlib_assumptions : context -> Expr.expr list
|
||||
|
||||
(** The number of SMTLIB declarations parsed by the last call to [ParseSMTLIBString] or [ParseSMTLIBFile]. *)
|
||||
val get_num_smtlib_decls : context -> int
|
||||
|
||||
(** The declarations parsed by the last call to [ParseSMTLIBString] or [ParseSMTLIBFile]. *)
|
||||
val get_smtlib_decls : context -> FuncDecl.func_decl list
|
||||
|
||||
(** The number of SMTLIB sorts parsed by the last call to [ParseSMTLIBString] or [ParseSMTLIBFile]. *)
|
||||
val get_num_smtlib_sorts : context -> int
|
||||
|
||||
(** The sort declarations parsed by the last call to [ParseSMTLIBString] or [ParseSMTLIBFile]. *)
|
||||
val get_smtlib_sorts : context -> Sort.sort list
|
||||
|
||||
(** Parse the given string using the SMT-LIB2 parser.
|
||||
|
||||
{!parse_smtlib_string}
|
||||
@return A conjunction of assertions in the scope (up to push/pop) at the end of the string. *)
|
||||
val parse_smtlib2_string : context -> string -> Symbol.symbol list -> Sort.sort list -> Symbol.symbol list -> FuncDecl.func_decl list -> Expr.expr
|
||||
|
||||
(** Parse the given file using the SMT-LIB2 parser.
|
||||
{!parse_smtlib2_string} *)
|
||||
(** Parse the given file using the SMT-LIB2 parser. *)
|
||||
val parse_smtlib2_file : context -> string -> Symbol.symbol list -> Sort.sort list -> Symbol.symbol list -> FuncDecl.func_decl list -> Expr.expr
|
||||
end
|
||||
|
||||
|
|
|
@ -182,7 +182,7 @@ class Context:
|
|||
"""Interrupt a solver performing a satisfiability test, a tactic processing a goal, or simplify functions.
|
||||
|
||||
This method can be invoked from a thread different from the one executing the
|
||||
interruptable procedure.
|
||||
interruptible procedure.
|
||||
"""
|
||||
Z3_interrupt(self.ref())
|
||||
|
||||
|
@ -365,6 +365,12 @@ class AstRef(Z3PPObject):
|
|||
_z3_assert(isinstance(target, Context), "argument must be a Z3 context")
|
||||
return _to_ast_ref(Z3_translate(self.ctx.ref(), self.as_ast(), target.ref()), target)
|
||||
|
||||
def __copy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def __deepcopy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def hash(self):
|
||||
"""Return a hashcode for the `self`.
|
||||
|
||||
|
@ -596,7 +602,7 @@ def _sort(ctx, a):
|
|||
return _to_sort_ref(Z3_get_sort(ctx.ref(), a), ctx)
|
||||
|
||||
def DeclareSort(name, ctx=None):
|
||||
"""Create a new uninterpred sort named `name`.
|
||||
"""Create a new uninterpreted sort named `name`.
|
||||
|
||||
If `ctx=None`, then the new sort is declared in the global Z3Py context.
|
||||
|
||||
|
@ -718,7 +724,7 @@ class FuncDeclRef(AstRef):
|
|||
|
||||
The arguments must be Z3 expressions. This method assumes that
|
||||
the sorts of the elements in `args` match the sorts of the
|
||||
domain. Limited coersion is supported. For example, if
|
||||
domain. Limited coercion is supported. For example, if
|
||||
args[0] is a Python integer, and the function expects a Z3
|
||||
integer, then the argument is automatically converted into a
|
||||
Z3 integer.
|
||||
|
@ -3568,6 +3574,14 @@ def BV2Int(a, is_signed=False):
|
|||
## investigate problem with bv2int
|
||||
return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
|
||||
|
||||
def Int2BV(a, num_bits):
|
||||
"""Return the z3 expression Int2BV(a, num_bits).
|
||||
It is a bit-vector of width num_bits and represents the
|
||||
modulo of a by 2^num_bits
|
||||
"""
|
||||
ctx = a.ctx
|
||||
return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
|
||||
|
||||
def BitVecSort(sz, ctx=None):
|
||||
"""Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
|
||||
|
||||
|
@ -4437,7 +4451,7 @@ class Datatype:
|
|||
if __debug__:
|
||||
_z3_assert(isinstance(name, str), "String expected")
|
||||
_z3_assert(name != "", "Constructor name cannot be empty")
|
||||
return self.declare_core(name, "is_" + name, *args)
|
||||
return self.declare_core(name, "is-" + name, *args)
|
||||
|
||||
def __repr__(self):
|
||||
return "Datatype(%s, %s)" % (self.name, self.constructors)
|
||||
|
@ -4561,7 +4575,7 @@ def CreateDatatypes(*ds):
|
|||
cref = cref()
|
||||
setattr(dref, cref_name, cref)
|
||||
rref = dref.recognizer(j)
|
||||
setattr(dref, rref.name(), rref)
|
||||
setattr(dref, "is_" + cref_name, rref)
|
||||
for k in range(cref_arity):
|
||||
aref = dref.accessor(j, k)
|
||||
setattr(dref, aref.name(), aref)
|
||||
|
@ -4615,16 +4629,16 @@ class DatatypeSortRef(SortRef):
|
|||
>>> List.num_constructors()
|
||||
2
|
||||
>>> List.recognizer(0)
|
||||
is_cons
|
||||
is(cons)
|
||||
>>> List.recognizer(1)
|
||||
is_nil
|
||||
is(nil)
|
||||
>>> simplify(List.is_nil(List.cons(10, List.nil)))
|
||||
False
|
||||
>>> simplify(List.is_cons(List.cons(10, List.nil)))
|
||||
True
|
||||
>>> l = Const('l', List)
|
||||
>>> simplify(List.is_cons(l))
|
||||
is_cons(l)
|
||||
is(cons, l)
|
||||
"""
|
||||
if __debug__:
|
||||
_z3_assert(idx < self.num_constructors(), "Invalid recognizer index")
|
||||
|
@ -5040,6 +5054,12 @@ class Goal(Z3PPObject):
|
|||
_z3_assert(isinstance(target, Context), "target must be a context")
|
||||
return Goal(goal=Z3_goal_translate(self.ctx.ref(), self.goal, target.ref()), ctx=target)
|
||||
|
||||
def __copy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def __deepcopy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def simplify(self, *arguments, **keywords):
|
||||
"""Return a new simplified goal.
|
||||
|
||||
|
@ -5132,9 +5152,18 @@ class AstVector(Z3PPObject):
|
|||
>>> A[1]
|
||||
y
|
||||
"""
|
||||
if i >= self.__len__():
|
||||
raise IndexError
|
||||
return _to_ast_ref(Z3_ast_vector_get(self.ctx.ref(), self.vector, i), self.ctx)
|
||||
|
||||
if isinstance(i, int):
|
||||
if i < 0:
|
||||
i += self.__len__()
|
||||
|
||||
if i >= self.__len__():
|
||||
raise IndexError
|
||||
return _to_ast_ref(Z3_ast_vector_get(self.ctx.ref(), self.vector, i), self.ctx)
|
||||
|
||||
elif isinstance(i, slice):
|
||||
return [_to_ast_ref(Z3_ast_vector_get(self.ctx.ref(), self.vector, ii), self.ctx) for ii in range(*i.indices(self.__len__()))]
|
||||
|
||||
|
||||
def __setitem__(self, i, v):
|
||||
"""Update AST at position `i`.
|
||||
|
@ -5213,6 +5242,12 @@ class AstVector(Z3PPObject):
|
|||
"""
|
||||
return AstVector(Z3_ast_vector_translate(self.ctx.ref(), self.vector, other_ctx.ref()), other_ctx)
|
||||
|
||||
def __copy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def __deepcopy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def __repr__(self):
|
||||
return obj_to_string(self)
|
||||
|
||||
|
@ -5550,6 +5585,17 @@ class FuncInterp(Z3PPObject):
|
|||
raise IndexError
|
||||
return FuncEntry(Z3_func_interp_get_entry(self.ctx.ref(), self.f, idx), self.ctx)
|
||||
|
||||
def translate(self, other_ctx):
|
||||
"""Copy model 'self' to context 'other_ctx'.
|
||||
"""
|
||||
return ModelRef(Z3_model_translate(self.ctx.ref(), self.model, other_ctx.ref()), other_ctx)
|
||||
|
||||
def __copy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def __deepcopy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def as_list(self):
|
||||
"""Return the function interpretation as a Python list.
|
||||
>>> f = Function('f', IntSort(), IntSort())
|
||||
|
@ -5579,9 +5625,6 @@ class ModelRef(Z3PPObject):
|
|||
self.ctx = ctx
|
||||
Z3_model_inc_ref(self.ctx.ref(), self.model)
|
||||
|
||||
def __deepcopy__(self, memo={}):
|
||||
return ModelRef(self.m, self.ctx)
|
||||
|
||||
def __del__(self):
|
||||
if self.ctx.ref() is not None:
|
||||
Z3_model_dec_ref(self.ctx.ref(), self.model)
|
||||
|
@ -5698,7 +5741,7 @@ class ModelRef(Z3PPObject):
|
|||
return None
|
||||
|
||||
def num_sorts(self):
|
||||
"""Return the number of unintepreted sorts that contain an interpretation in the model `self`.
|
||||
"""Return the number of uninterpreted sorts that contain an interpretation in the model `self`.
|
||||
|
||||
>>> A = DeclareSort('A')
|
||||
>>> a, b = Consts('a b', A)
|
||||
|
@ -5713,7 +5756,7 @@ class ModelRef(Z3PPObject):
|
|||
return int(Z3_model_get_num_sorts(self.ctx.ref(), self.model))
|
||||
|
||||
def get_sort(self, idx):
|
||||
"""Return the unintepreted sort at position `idx` < self.num_sorts().
|
||||
"""Return the uninterpreted sort at position `idx` < self.num_sorts().
|
||||
|
||||
>>> A = DeclareSort('A')
|
||||
>>> B = DeclareSort('B')
|
||||
|
@ -5753,7 +5796,7 @@ class ModelRef(Z3PPObject):
|
|||
return [ self.get_sort(i) for i in range(self.num_sorts()) ]
|
||||
|
||||
def get_universe(self, s):
|
||||
"""Return the intepretation for the uninterpreted sort `s` in the model `self`.
|
||||
"""Return the interpretation for the uninterpreted sort `s` in the model `self`.
|
||||
|
||||
>>> A = DeclareSort('A')
|
||||
>>> a, b = Consts('a b', A)
|
||||
|
@ -5773,7 +5816,7 @@ class ModelRef(Z3PPObject):
|
|||
return None
|
||||
|
||||
def __getitem__(self, idx):
|
||||
"""If `idx` is an integer, then the declaration at position `idx` in the model `self` is returned. If `idx` is a declaration, then the actual interpreation is returned.
|
||||
"""If `idx` is an integer, then the declaration at position `idx` in the model `self` is returned. If `idx` is a declaration, then the actual interpretation is returned.
|
||||
|
||||
The elements can be retrieved using position or the actual declaration.
|
||||
|
||||
|
@ -5817,7 +5860,7 @@ class ModelRef(Z3PPObject):
|
|||
return None
|
||||
|
||||
def decls(self):
|
||||
"""Return a list with all symbols that have an interpreation in the model `self`.
|
||||
"""Return a list with all symbols that have an interpretation in the model `self`.
|
||||
>>> f = Function('f', IntSort(), IntSort())
|
||||
>>> x = Int('x')
|
||||
>>> s = Solver()
|
||||
|
@ -5835,6 +5878,20 @@ class ModelRef(Z3PPObject):
|
|||
r.append(FuncDeclRef(Z3_model_get_func_decl(self.ctx.ref(), self.model, i), self.ctx))
|
||||
return r
|
||||
|
||||
def translate(self, target):
|
||||
"""Translate `self` to the context `target`. That is, return a copy of `self` in the context `target`.
|
||||
"""
|
||||
if __debug__:
|
||||
_z3_assert(isinstance(target, Context), "argument must be a Z3 context")
|
||||
model = Z3_model_translate(self.ctx.ref(), self.model, target.ref())
|
||||
return Model(model, target)
|
||||
|
||||
def __copy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def __deepcopy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def is_as_array(n):
|
||||
"""Return true if n is a Z3 expression of the form (_ as-array f)."""
|
||||
return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
|
||||
|
@ -6037,9 +6094,6 @@ class Solver(Z3PPObject):
|
|||
self.solver = solver
|
||||
Z3_solver_inc_ref(self.ctx.ref(), self.solver)
|
||||
|
||||
def __deepcopy__(self, memo={}):
|
||||
return Solver(self.solver, self.ctx)
|
||||
|
||||
def __del__(self):
|
||||
if self.solver is not None and self.ctx.ref() is not None:
|
||||
Z3_solver_dec_ref(self.ctx.ref(), self.solver)
|
||||
|
@ -6324,6 +6378,20 @@ class Solver(Z3PPObject):
|
|||
sz = len(consequences)
|
||||
consequences = [ consequences[i] for i in range(sz) ]
|
||||
return CheckSatResult(r), consequences
|
||||
|
||||
def from_file(self, filename):
|
||||
"""Parse assertions from a file"""
|
||||
try:
|
||||
Z3_solver_from_file(self.ctx.ref(), self.solver, filename)
|
||||
except Z3Exception as e:
|
||||
_handle_parse_error(e, self.ctx)
|
||||
|
||||
def from_string(self, s):
|
||||
"""Parse assertions from a string"""
|
||||
try:
|
||||
Z3_solver_from_string(self.ctx.ref(), self.solver, s)
|
||||
except Z3Exception as e:
|
||||
_handle_parse_error(e, self.ctx)
|
||||
|
||||
def proof(self):
|
||||
"""Return a proof for the last `check()`. Proof construction must be enabled."""
|
||||
|
@ -6399,6 +6467,12 @@ class Solver(Z3PPObject):
|
|||
solver = Z3_solver_translate(self.ctx.ref(), self.solver, target.ref())
|
||||
return Solver(solver, target)
|
||||
|
||||
def __copy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def __deepcopy__(self):
|
||||
return self.translate(self.ctx)
|
||||
|
||||
def sexpr(self):
|
||||
"""Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
|
||||
|
||||
|
@ -6668,11 +6742,17 @@ class Fixedpoint(Z3PPObject):
|
|||
|
||||
def parse_string(self, s):
|
||||
"""Parse rules and queries from a string"""
|
||||
return AstVector(Z3_fixedpoint_from_string(self.ctx.ref(), self.fixedpoint, s), self.ctx)
|
||||
try:
|
||||
return AstVector(Z3_fixedpoint_from_string(self.ctx.ref(), self.fixedpoint, s), self.ctx)
|
||||
except Z3Exception as e:
|
||||
_handle_parse_error(e, self.ctx)
|
||||
|
||||
def parse_file(self, f):
|
||||
"""Parse rules and queries from a file"""
|
||||
return AstVector(Z3_fixedpoint_from_file(self.ctx.ref(), self.fixedpoint, f), self.ctx)
|
||||
try:
|
||||
return AstVector(Z3_fixedpoint_from_file(self.ctx.ref(), self.fixedpoint, f), self.ctx)
|
||||
except Z3Exception as e:
|
||||
_handle_parse_error(e, self.ctx)
|
||||
|
||||
def get_rules(self):
|
||||
"""retrieve rules that have been added to fixedpoint context"""
|
||||
|
@ -6738,8 +6818,8 @@ class FiniteDomainSortRef(SortRef):
|
|||
|
||||
def size(self):
|
||||
"""Return the size of the finite domain sort"""
|
||||
r = (ctype.c_ulonglong * 1)()
|
||||
if Z3_get_finite_domain_sort_size(self.ctx_ref(), self.ast(), r):
|
||||
r = (ctypes.c_ulonglong * 1)()
|
||||
if Z3_get_finite_domain_sort_size(self.ctx_ref(), self.ast, r):
|
||||
return r[0]
|
||||
else:
|
||||
raise Z3Exception("Failed to retrieve finite domain sort size")
|
||||
|
@ -6995,15 +7075,21 @@ class Optimize(Z3PPObject):
|
|||
def upper_values(self, obj):
|
||||
if not isinstance(obj, OptimizeObjective):
|
||||
raise Z3Exception("Expecting objective handle returned by maximize/minimize")
|
||||
return obj.upper_values()
|
||||
return obj.upper_values()
|
||||
|
||||
def from_file(self, filename):
|
||||
"""Parse assertions and objectives from a file"""
|
||||
Z3_optimize_from_file(self.ctx.ref(), self.optimize, filename)
|
||||
try:
|
||||
Z3_optimize_from_file(self.ctx.ref(), self.optimize, filename)
|
||||
except Z3Exception as e:
|
||||
_handle_parse_error(e, self.ctx)
|
||||
|
||||
def from_string(self, s):
|
||||
"""Parse assertions and objectives from a string"""
|
||||
Z3_optimize_from_string(self.ctx.ref(), self.optimize, s)
|
||||
try:
|
||||
Z3_optimize_from_string(self.ctx.ref(), self.optimize, s)
|
||||
except Z3Exception as e:
|
||||
_handle_parse_error(e, self.ctx)
|
||||
|
||||
def assertions(self):
|
||||
"""Return an AST vector containing all added constraints."""
|
||||
|
@ -7361,6 +7447,19 @@ def With(t, *args, **keys):
|
|||
p = args2params(args, keys, t.ctx)
|
||||
return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
|
||||
|
||||
def WithParams(t, p):
|
||||
"""Return a tactic that applies tactic `t` using the given configuration options.
|
||||
|
||||
>>> x, y = Ints('x y')
|
||||
>>> p = ParamsRef()
|
||||
>>> p.set("som", True)
|
||||
>>> t = WithParams(Tactic('simplify'), p)
|
||||
>>> t((x + 1)*(y + 2) == 0)
|
||||
[[2*x + y + x*y == -2]]
|
||||
"""
|
||||
t = _to_tactic(t, None)
|
||||
return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
|
||||
|
||||
def Repeat(t, max=4294967295, ctx=None):
|
||||
"""Return a tactic that keeps applying `t` until the goal is not modified anymore or the maximum number of iterations `max` is reached.
|
||||
|
||||
|
@ -8071,6 +8170,12 @@ def _dict2darray(decls, ctx):
|
|||
i = i + 1
|
||||
return sz, _names, _decls
|
||||
|
||||
def _handle_parse_error(ex, ctx):
|
||||
msg = Z3_get_parser_error(ctx.ref())
|
||||
if msg != "":
|
||||
raise Z3Exception(msg)
|
||||
raise ex
|
||||
|
||||
def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
|
||||
"""Parse a string in SMT 2.0 format using the given sorts and decls.
|
||||
|
||||
|
@ -8089,7 +8194,10 @@ def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
|
|||
ctx = _get_ctx(ctx)
|
||||
ssz, snames, ssorts = _dict2sarray(sorts, ctx)
|
||||
dsz, dnames, ddecls = _dict2darray(decls, ctx)
|
||||
return _to_expr_ref(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
|
||||
try:
|
||||
return _to_expr_ref(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
|
||||
except Z3Exception as e:
|
||||
_handle_parse_error(e, ctx)
|
||||
|
||||
def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
|
||||
"""Parse a file in SMT 2.0 format using the given sorts and decls.
|
||||
|
@ -8099,7 +8207,10 @@ def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
|
|||
ctx = _get_ctx(ctx)
|
||||
ssz, snames, ssorts = _dict2sarray(sorts, ctx)
|
||||
dsz, dnames, ddecls = _dict2darray(decls, ctx)
|
||||
return _to_expr_ref(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
|
||||
try:
|
||||
return _to_expr_ref(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
|
||||
except Z3Exception as e:
|
||||
_handle_parse_error(e, ctx)
|
||||
|
||||
def Interpolant(a,ctx=None):
|
||||
"""Create an interpolation operator.
|
||||
|
@ -8155,7 +8266,7 @@ def tree_interpolant(pat,p=None,ctx=None):
|
|||
solver that determines satisfiability.
|
||||
|
||||
>>> x = Int('x')
|
||||
>>> y = Int('y')
|
||||
>>> y = Int('y')
|
||||
>>> print(tree_interpolant(And(Interpolant(x < 0), Interpolant(y > 2), x == y)))
|
||||
[Not(x >= 0), Not(y <= 2)]
|
||||
|
||||
|
@ -9145,7 +9256,7 @@ def fpMul(rm, a, b, ctx=None):
|
|||
return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
|
||||
|
||||
def fpDiv(rm, a, b, ctx=None):
|
||||
"""Create a Z3 floating-point divison expression.
|
||||
"""Create a Z3 floating-point division expression.
|
||||
|
||||
>>> s = FPSort(8, 24)
|
||||
>>> rm = RNE()
|
||||
|
@ -9172,7 +9283,7 @@ def fpRem(a, b, ctx=None):
|
|||
return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
|
||||
|
||||
def fpMin(a, b, ctx=None):
|
||||
"""Create a Z3 floating-point minimium expression.
|
||||
"""Create a Z3 floating-point minimum expression.
|
||||
|
||||
>>> s = FPSort(8, 24)
|
||||
>>> rm = RNE()
|
||||
|
@ -9740,7 +9851,7 @@ def Full(s):
|
|||
re.all
|
||||
>>> e1 = Full(ReSort(StringSort()))
|
||||
>>> print(e1)
|
||||
re.allchar
|
||||
re.all
|
||||
"""
|
||||
if isinstance(s, ReSortRef):
|
||||
return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
|
||||
|
|
|
@ -485,7 +485,9 @@ class PP:
|
|||
raise StopPPException()
|
||||
|
||||
def pp(self, f, indent):
|
||||
if f.is_string():
|
||||
if isinstance(f, str):
|
||||
sef.pp_string(f, indent)
|
||||
elif f.is_string():
|
||||
self.pp_string(f, indent)
|
||||
elif f.is_indent():
|
||||
self.pp(f.child, min(indent + f.indent, self.max_indent))
|
||||
|
@ -846,10 +848,17 @@ class Formatter:
|
|||
else:
|
||||
return seq1('MultiPattern', [ self.pp_expr(arg, d+1, xs) for arg in a.children() ])
|
||||
|
||||
def pp_is(self, a, d, xs):
|
||||
f = a.params()[0]
|
||||
return self.pp_fdecl(f, a, d, xs)
|
||||
|
||||
def pp_map(self, a, d, xs):
|
||||
f = z3.get_map_func(a)
|
||||
return self.pp_fdecl(f, a, d, xs)
|
||||
|
||||
def pp_fdecl(self, f, a, d, xs):
|
||||
r = []
|
||||
sz = 0
|
||||
f = z3.get_map_func(a)
|
||||
r.append(to_format(f.name()))
|
||||
for child in a.children():
|
||||
r.append(self.pp_expr(child, d+1, xs))
|
||||
|
@ -909,6 +918,8 @@ class Formatter:
|
|||
return self.pp_unary_param(a, d, xs)
|
||||
elif k == Z3_OP_EXTRACT:
|
||||
return self.pp_extract(a, d, xs)
|
||||
elif k == Z3_OP_DT_IS:
|
||||
return self.pp_is(a, d, xs)
|
||||
elif k == Z3_OP_ARRAY_MAP:
|
||||
return self.pp_map(a, d, xs)
|
||||
elif k == Z3_OP_CONST_ARRAY:
|
||||
|
@ -963,6 +974,14 @@ class Formatter:
|
|||
else:
|
||||
return to_format(self.pp_unknown())
|
||||
|
||||
def pp_decl(self, f):
|
||||
k = f.kind()
|
||||
if k == Z3_OP_DT_IS or k == Z3_OP_ARRAY_MAP:
|
||||
g = f.params()[0]
|
||||
r = [ to_format(g.name()) ]
|
||||
return seq1(self.pp_name(f), r)
|
||||
return self.pp_name(f)
|
||||
|
||||
def pp_seq_core(self, f, a, d, xs):
|
||||
self.visited = self.visited + 1
|
||||
if d > self.max_depth or self.visited > self.max_visited:
|
||||
|
@ -1054,7 +1073,7 @@ class Formatter:
|
|||
elif z3.is_sort(a):
|
||||
return self.pp_sort(a)
|
||||
elif z3.is_func_decl(a):
|
||||
return self.pp_name(a)
|
||||
return self.pp_decl(a)
|
||||
elif isinstance(a, z3.Goal) or isinstance(a, z3.AstVector):
|
||||
return self.pp_seq(a, 0, [])
|
||||
elif isinstance(a, z3.Solver):
|
||||
|
|
196
src/api/z3_api.h
196
src/api/z3_api.h
|
@ -270,7 +270,7 @@ typedef enum
|
|||
- Z3_OP_ARRAY_MAP Array map operator.
|
||||
It satisfies map[f](a1,..,a_n)[i] = f(a1[i],...,a_n[i]) for every i.
|
||||
|
||||
- Z3_OP_SET_UNION Set union between two Booelan arrays (two arrays whose range type is Boolean). The function is binary.
|
||||
- Z3_OP_SET_UNION Set union between two Boolean arrays (two arrays whose range type is Boolean). The function is binary.
|
||||
|
||||
- Z3_OP_SET_INTERSECT Set intersection between two Boolean arrays. The function is binary.
|
||||
|
||||
|
@ -406,7 +406,7 @@ typedef enum
|
|||
|
||||
- Z3_OP_BSMUL_NO_UDFL: check that bit-wise signed multiplication does not underflow.
|
||||
Signed multiplication underflows if the operands have opposite signs and the result of multiplication
|
||||
does not fit within the avaialble bits. Z3_mk_bvmul_no_underflow.
|
||||
does not fit within the available bits. Z3_mk_bvmul_no_underflow.
|
||||
|
||||
- Z3_OP_BSDIV_I: Binary signed division.
|
||||
It has the same semantics as Z3_OP_BSDIV, but created in a context where the second operand can be assumed to be non-zero.
|
||||
|
@ -485,7 +485,7 @@ typedef enum
|
|||
[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.
|
||||
That is, reflexivity proofs are suppressed to save space.
|
||||
|
||||
- Z3_OP_PR_QUANT_INTRO: Given a proof for (~ p q), produces a proof for (~ (forall (x) p) (forall (x) q)).
|
||||
|
||||
|
@ -832,7 +832,7 @@ typedef enum
|
|||
|
||||
- Z3_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
|
||||
The second argument is a predicate with free de-Bruijn indices
|
||||
corresponding to the columns of the relation.
|
||||
So the first column in the relation has index 0.
|
||||
|
||||
|
@ -876,6 +876,8 @@ typedef enum
|
|||
|
||||
- Z3_OP_DT_RECOGNISER: datatype recognizer.
|
||||
|
||||
- Z3_OP_DT_IS: datatype recognizer.
|
||||
|
||||
- Z3_OP_DT_ACCESSOR: datatype accessor.
|
||||
|
||||
- Z3_OP_DT_UPDATE_FIELD: datatype field update.
|
||||
|
@ -969,7 +971,7 @@ typedef enum
|
|||
|
||||
- Z3_OP_FPA_TO_FP: Floating-point conversion (various)
|
||||
|
||||
- Z3_OP_FPA_TO_FP_UNSIGNED: Floating-point conversion from unsigend bit-vector
|
||||
- Z3_OP_FPA_TO_FP_UNSIGNED: Floating-point conversion from unsigned bit-vector
|
||||
|
||||
- Z3_OP_FPA_TO_UBV: Floating-point conversion to unsigned bit-vector
|
||||
|
||||
|
@ -984,7 +986,7 @@ typedef enum
|
|||
of non-relevant terms in theory_fpa)
|
||||
|
||||
- Z3_OP_FPA_BV2RM: Conversion of a 3-bit bit-vector term to a
|
||||
floating-point rouding-mode term
|
||||
floating-point rounding-mode term
|
||||
|
||||
The conversion uses the following values:
|
||||
0 = 000 = Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN,
|
||||
|
@ -1220,6 +1222,7 @@ typedef enum {
|
|||
// Datatypes
|
||||
Z3_OP_DT_CONSTRUCTOR=0x800,
|
||||
Z3_OP_DT_RECOGNISER,
|
||||
Z3_OP_DT_IS,
|
||||
Z3_OP_DT_ACCESSOR,
|
||||
Z3_OP_DT_UPDATE_FIELD,
|
||||
|
||||
|
@ -1314,13 +1317,11 @@ typedef enum {
|
|||
|
||||
- Z3_PRINT_SMTLIB_FULL: Print AST nodes in SMTLIB verbose format.
|
||||
- Z3_PRINT_LOW_LEVEL: Print AST nodes using a low-level format.
|
||||
- Z3_PRINT_SMTLIB_COMPLIANT: Print AST nodes in SMTLIB 1.x compliant format.
|
||||
- Z3_PRINT_SMTLIB2_COMPLIANT: Print AST nodes in SMTLIB 2.x compliant format.
|
||||
*/
|
||||
typedef enum {
|
||||
Z3_PRINT_SMTLIB_FULL,
|
||||
Z3_PRINT_LOW_LEVEL,
|
||||
Z3_PRINT_SMTLIB_COMPLIANT,
|
||||
Z3_PRINT_SMTLIB2_COMPLIANT
|
||||
} Z3_ast_print_mode;
|
||||
|
||||
|
@ -1333,7 +1334,7 @@ typedef enum {
|
|||
- Z3_IOB: Index out of bounds.
|
||||
- Z3_INVALID_ARG: Invalid argument was provided.
|
||||
- Z3_PARSER_ERROR: An error occurred when parsing a string or file.
|
||||
- Z3_NO_PARSER: Parser output is not available, that is, user didn't invoke #Z3_parse_smtlib_string or #Z3_parse_smtlib_file.
|
||||
- Z3_NO_PARSER: Parser output is not available, that is, user didn't invoke #Z3_parse_smtlib2_string or #Z3_parse_smtlib2_file.
|
||||
- Z3_INVALID_PATTERN: Invalid pattern was used to build a quantifier.
|
||||
- Z3_MEMOUT_FAIL: A memory allocation failure was encountered.
|
||||
- Z3_FILE_ACCESS_ERRROR: A file could not be accessed.
|
||||
|
@ -1924,7 +1925,7 @@ extern "C" {
|
|||
|
||||
\param c logical context
|
||||
\param name name of the enumeration sort.
|
||||
\param n number of elemenets in enumeration sort.
|
||||
\param n number of elements 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.
|
||||
|
@ -2859,9 +2860,8 @@ extern "C" {
|
|||
/**
|
||||
\brief Create an \c n bit bit-vector from the integer argument \c 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 resulting bit-vector has \c n bits, where the i'th bit (counting
|
||||
from 0 to \c n-1) is 1 if \c (t1 div 2^i) mod 2 is 1.
|
||||
|
||||
The node \c t1 must have integer sort.
|
||||
|
||||
|
@ -2876,9 +2876,6 @@ extern "C" {
|
|||
and in the range \ccode{[0..2^N-1]}, where N are the number of bits in \c t1.
|
||||
If \c is_signed is true, \c t1 is treated as a signed bit-vector.
|
||||
|
||||
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 \c t1 must have a bit-vector sort.
|
||||
|
||||
|
@ -3188,7 +3185,7 @@ extern "C" {
|
|||
|
||||
\param c logical context.
|
||||
\param num numerator of rational.
|
||||
\param den denomerator of rational.
|
||||
\param den denominator of rational.
|
||||
|
||||
\pre den != 0
|
||||
|
||||
|
@ -3203,7 +3200,7 @@ extern "C" {
|
|||
/**
|
||||
\brief 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.
|
||||
This function can be used to create numerals that fit in a machine integer.
|
||||
It is slightly faster than #Z3_mk_numeral since it is not necessary to parse a string.
|
||||
|
||||
\sa Z3_mk_numeral
|
||||
|
@ -3215,7 +3212,7 @@ extern "C" {
|
|||
/**
|
||||
\brief 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 unsinged integer.
|
||||
This function can be used to create numerals that fit in a machine unsigned integer.
|
||||
It is slightly faster than #Z3_mk_numeral since it is not necessary to parse a string.
|
||||
|
||||
\sa Z3_mk_numeral
|
||||
|
@ -3227,7 +3224,7 @@ extern "C" {
|
|||
/**
|
||||
\brief 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 __int64 integer.
|
||||
This function can be used to create numerals that fit in a machine __int64 integer.
|
||||
It is slightly faster than #Z3_mk_numeral since it is not necessary to parse a string.
|
||||
|
||||
\sa Z3_mk_numeral
|
||||
|
@ -3239,7 +3236,7 @@ extern "C" {
|
|||
/**
|
||||
\brief 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 __uint64 integer.
|
||||
This function can be used to create numerals that fit in a machine __uint64 integer.
|
||||
It is slightly faster than #Z3_mk_numeral since it is not necessary to parse a string.
|
||||
|
||||
\sa Z3_mk_numeral
|
||||
|
@ -3495,8 +3492,8 @@ extern "C" {
|
|||
Z3_ast Z3_API Z3_mk_re_range(Z3_context c, Z3_ast lo, Z3_ast hi);
|
||||
|
||||
/**
|
||||
\brief Create a regular expression loop. The supplied regular expression \c r is repated
|
||||
between \c lo and \c hi times. The \c lo should be below \c hi with one exection: when
|
||||
\brief Create a regular expression loop. The supplied regular expression \c r is repeated
|
||||
between \c lo and \c hi times. The \c lo should be below \c hi with one exception: when
|
||||
supplying the value \c hi as 0, the meaning is to repeat the argument \c r at least
|
||||
\c lo number of times, and with an unbounded upper bound.
|
||||
|
||||
|
@ -4250,7 +4247,7 @@ extern "C" {
|
|||
Z3_sort Z3_API Z3_get_decl_sort_parameter(Z3_context c, Z3_func_decl d, unsigned idx);
|
||||
|
||||
/**
|
||||
\brief Return the expresson value associated with an expression parameter.
|
||||
\brief Return the expression value associated with an expression parameter.
|
||||
|
||||
\pre Z3_get_decl_parameter_kind(c, d, idx) == Z3_PARAMETER_AST
|
||||
|
||||
|
@ -4259,7 +4256,7 @@ extern "C" {
|
|||
Z3_ast Z3_API Z3_get_decl_ast_parameter(Z3_context c, Z3_func_decl d, unsigned idx);
|
||||
|
||||
/**
|
||||
\brief Return the expresson value associated with an expression parameter.
|
||||
\brief Return the expression value associated with an expression parameter.
|
||||
|
||||
\pre Z3_get_decl_parameter_kind(c, d, idx) == Z3_PARAMETER_FUNC_DECL
|
||||
|
||||
|
@ -4301,7 +4298,7 @@ extern "C" {
|
|||
/**
|
||||
\brief Return the i-th argument of the given application.
|
||||
|
||||
\pre i < Z3_get_num_args(c, a)
|
||||
\pre i < Z3_get_app_num_args(c, a)
|
||||
|
||||
def_API('Z3_get_app_arg', AST, (_in(CONTEXT), _in(APP), _in(UINT)))
|
||||
*/
|
||||
|
@ -4329,7 +4326,7 @@ extern "C" {
|
|||
|
||||
/**
|
||||
\brief Return a hash code for the given AST.
|
||||
The hash code is structural. You can use Z3_get_ast_id interchangably with
|
||||
The hash code is structural. You can use Z3_get_ast_id interchangeably with
|
||||
this function.
|
||||
|
||||
def_API('Z3_get_ast_hash', UINT, (_in(CONTEXT), _in(AST)))
|
||||
|
@ -4558,7 +4555,7 @@ extern "C" {
|
|||
Z3_ast Z3_API Z3_get_pattern(Z3_context c, Z3_pattern p, unsigned idx);
|
||||
|
||||
/**
|
||||
\brief Return index of de-Brujin bound variable.
|
||||
\brief Return index of de-Bruijn bound variable.
|
||||
|
||||
\pre Z3_get_ast_kind(a) == Z3_VAR_AST
|
||||
|
||||
|
@ -4661,7 +4658,7 @@ extern "C" {
|
|||
|
||||
Provides an interface to the AST simplifier used by Z3.
|
||||
It returns an AST object which is equal to the argument.
|
||||
The returned AST is simplified using algebraic simplificaiton rules,
|
||||
The returned AST is simplified using algebraic simplification rules,
|
||||
such as constant propagation (propagating true/false over logical connectives).
|
||||
|
||||
def_API('Z3_simplify', AST, (_in(CONTEXT), _in(AST)))
|
||||
|
@ -4863,9 +4860,9 @@ extern "C" {
|
|||
Z3_func_decl Z3_API Z3_model_get_func_decl(Z3_context c, Z3_model m, unsigned i);
|
||||
|
||||
/**
|
||||
\brief Return the number of uninterpreted sorts that \c m assigs an interpretation to.
|
||||
\brief Return the number of uninterpreted sorts that \c m assigns an interpretation to.
|
||||
|
||||
Z3 also provides an intepretation for uninterpreted sorts used in a formua.
|
||||
Z3 also provides an interpretation for uninterpreted sorts used in a formula.
|
||||
The interpretation for a sort \c s is a finite set of distinct values. We say this finite set is
|
||||
the "universe" of \c s.
|
||||
|
||||
|
@ -4898,6 +4895,13 @@ extern "C" {
|
|||
*/
|
||||
Z3_ast_vector Z3_API Z3_model_get_sort_universe(Z3_context c, Z3_model m, Z3_sort s);
|
||||
|
||||
/**
|
||||
\brief translate model from context c to context \c dst.
|
||||
|
||||
def_API('Z3_model_translate', MODEL, (_in(CONTEXT), _in(MODEL), _in(CONTEXT)))
|
||||
*/
|
||||
Z3_model Z3_API Z3_model_translate(Z3_context c, Z3_model m, Z3_context dst);
|
||||
|
||||
/**
|
||||
\brief The \ccode{(_ as-array f)} AST node is a construct for assigning interpretations for arrays in Z3.
|
||||
It is the array such that forall indices \c i we have that \ccode{(select (_ as-array f) i)} is equal to \ccode{(f i)}.
|
||||
|
@ -4966,7 +4970,7 @@ extern "C" {
|
|||
unsigned Z3_API Z3_func_interp_get_num_entries(Z3_context c, Z3_func_interp f);
|
||||
|
||||
/**
|
||||
\brief Return a "point" of the given function intepretation. It represents the
|
||||
\brief Return a "point" of the given function interpretation. It represents the
|
||||
value of \c f in a particular point.
|
||||
|
||||
\pre i < Z3_func_interp_get_num_entries(c, f)
|
||||
|
@ -5008,7 +5012,7 @@ extern "C" {
|
|||
\brief add a function entry to a function interpretation.
|
||||
|
||||
\param c logical context
|
||||
\param fi a function interpregation to be updated.
|
||||
\param fi a function interpretation to be updated.
|
||||
\param args list of arguments. They should be constant values (such as integers) and be of the same types as the domain of the function.
|
||||
\param value value of the function when the parameters match args.
|
||||
|
||||
|
@ -5116,7 +5120,7 @@ extern "C" {
|
|||
To print shared common subexpressions only once,
|
||||
use the Z3_PRINT_LOW_LEVEL mode.
|
||||
To print in way that conforms to SMT-LIB standards and uses let
|
||||
expressions to share common sub-expressions use Z3_PRINT_SMTLIB_COMPLIANT.
|
||||
expressions to share common sub-expressions use Z3_PRINT_SMTLIB2_COMPLIANT.
|
||||
|
||||
\sa Z3_ast_to_string
|
||||
\sa Z3_pattern_to_string
|
||||
|
@ -5228,115 +5232,13 @@ extern "C" {
|
|||
Z3_symbol const decl_names[],
|
||||
Z3_func_decl const decls[]);
|
||||
|
||||
/**
|
||||
\brief 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 \c sort_names and \c decl_names don't need to match the names
|
||||
of the sorts and declarations in the arrays \c sorts and \c 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 \c str can be extracted using the functions:
|
||||
#Z3_get_smtlib_num_formulas, #Z3_get_smtlib_formula, #Z3_get_smtlib_num_assumptions, #Z3_get_smtlib_assumption,
|
||||
#Z3_get_smtlib_num_decls, and #Z3_get_smtlib_decl.
|
||||
|
||||
def_API('Z3_parse_smtlib_string', VOID, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _in(UINT), _in_array(5, SYMBOL), _in_array(5, FUNC_DECL)))
|
||||
*/
|
||||
void Z3_API Z3_parse_smtlib_string(Z3_context c,
|
||||
Z3_string str,
|
||||
unsigned num_sorts,
|
||||
Z3_symbol const sort_names[],
|
||||
Z3_sort const sorts[],
|
||||
unsigned num_decls,
|
||||
Z3_symbol const decl_names[],
|
||||
Z3_func_decl const decls[]
|
||||
);
|
||||
|
||||
/**
|
||||
\brief Similar to #Z3_parse_smtlib_string, but reads the benchmark from a file.
|
||||
|
||||
def_API('Z3_parse_smtlib_file', VOID, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _in(UINT), _in_array(5, SYMBOL), _in_array(5, FUNC_DECL)))
|
||||
*/
|
||||
void Z3_API Z3_parse_smtlib_file(Z3_context c,
|
||||
Z3_string file_name,
|
||||
unsigned num_sorts,
|
||||
Z3_symbol const sort_names[],
|
||||
Z3_sort const sorts[],
|
||||
unsigned num_decls,
|
||||
Z3_symbol const decl_names[],
|
||||
Z3_func_decl const decls[]
|
||||
);
|
||||
|
||||
/**
|
||||
\brief Return the number of SMTLIB formulas parsed by the last call to #Z3_parse_smtlib_string or #Z3_parse_smtlib_file.
|
||||
|
||||
def_API('Z3_get_smtlib_num_formulas', UINT, (_in(CONTEXT), ))
|
||||
*/
|
||||
unsigned Z3_API Z3_get_smtlib_num_formulas(Z3_context c);
|
||||
|
||||
/**
|
||||
\brief Return the i-th formula parsed by the last call to #Z3_parse_smtlib_string or #Z3_parse_smtlib_file.
|
||||
|
||||
\pre i < Z3_get_smtlib_num_formulas(c)
|
||||
|
||||
def_API('Z3_get_smtlib_formula', AST, (_in(CONTEXT), _in(UINT)))
|
||||
*/
|
||||
Z3_ast Z3_API Z3_get_smtlib_formula(Z3_context c, unsigned i);
|
||||
|
||||
/**
|
||||
\brief Return the number of SMTLIB assumptions parsed by #Z3_parse_smtlib_string or #Z3_parse_smtlib_file.
|
||||
|
||||
def_API('Z3_get_smtlib_num_assumptions', UINT, (_in(CONTEXT), ))
|
||||
*/
|
||||
unsigned Z3_API Z3_get_smtlib_num_assumptions(Z3_context c);
|
||||
|
||||
/**
|
||||
\brief Return the i-th assumption parsed by the last call to #Z3_parse_smtlib_string or #Z3_parse_smtlib_file.
|
||||
|
||||
\pre i < Z3_get_smtlib_num_assumptions(c)
|
||||
|
||||
def_API('Z3_get_smtlib_assumption', AST, (_in(CONTEXT), _in(UINT)))
|
||||
*/
|
||||
Z3_ast Z3_API Z3_get_smtlib_assumption(Z3_context c, unsigned i);
|
||||
|
||||
/**
|
||||
\brief Return the number of declarations parsed by #Z3_parse_smtlib_string or #Z3_parse_smtlib_file.
|
||||
|
||||
def_API('Z3_get_smtlib_num_decls', UINT, (_in(CONTEXT), ))
|
||||
*/
|
||||
unsigned Z3_API Z3_get_smtlib_num_decls(Z3_context c);
|
||||
|
||||
/**
|
||||
\brief Return the i-th declaration parsed by the last call to #Z3_parse_smtlib_string or #Z3_parse_smtlib_file.
|
||||
|
||||
\pre i < Z3_get_smtlib_num_decls(c)
|
||||
|
||||
def_API('Z3_get_smtlib_decl', FUNC_DECL, (_in(CONTEXT), _in(UINT)))
|
||||
*/
|
||||
Z3_func_decl Z3_API Z3_get_smtlib_decl(Z3_context c, unsigned i);
|
||||
|
||||
/**
|
||||
\brief Return the number of sorts parsed by #Z3_parse_smtlib_string or #Z3_parse_smtlib_file.
|
||||
|
||||
def_API('Z3_get_smtlib_num_sorts', UINT, (_in(CONTEXT), ))
|
||||
*/
|
||||
unsigned Z3_API Z3_get_smtlib_num_sorts(Z3_context c);
|
||||
|
||||
/**
|
||||
\brief Return the i-th sort parsed by the last call to #Z3_parse_smtlib_string or #Z3_parse_smtlib_file.
|
||||
|
||||
\pre i < Z3_get_smtlib_num_sorts(c)
|
||||
|
||||
def_API('Z3_get_smtlib_sort', SORT, (_in(CONTEXT), _in(UINT)))
|
||||
*/
|
||||
Z3_sort Z3_API Z3_get_smtlib_sort(Z3_context c, unsigned i);
|
||||
|
||||
/**
|
||||
\brief Retrieve that last error message information generated from parsing.
|
||||
|
||||
def_API('Z3_get_smtlib_error', STRING, (_in(CONTEXT), ))
|
||||
def_API('Z3_get_parser_error', STRING, (_in(CONTEXT), ))
|
||||
*/
|
||||
Z3_string Z3_API Z3_get_smtlib_error(Z3_context c);
|
||||
Z3_string Z3_API Z3_get_parser_error(Z3_context c);
|
||||
/*@}*/
|
||||
|
||||
/** @name Error Handling */
|
||||
|
@ -5563,7 +5465,7 @@ extern "C" {
|
|||
Z3_bool Z3_API Z3_goal_is_decided_unsat(Z3_context c, Z3_goal g);
|
||||
|
||||
/**
|
||||
\brief Copy a goal \c g from the context \c source to a the context \c target.
|
||||
\brief Copy a goal \c g from the context \c source to the context \c target.
|
||||
|
||||
def_API('Z3_goal_translate', GOAL, (_in(CONTEXT), _in(GOAL), _in(CONTEXT)))
|
||||
*/
|
||||
|
@ -6029,7 +5931,7 @@ extern "C" {
|
|||
Z3_solver Z3_API Z3_mk_solver_from_tactic(Z3_context c, Z3_tactic t);
|
||||
|
||||
/**
|
||||
\brief Copy a solver \c s from the context \c source to a the context \c target.
|
||||
\brief Copy a solver \c s from the context \c source to the context \c target.
|
||||
|
||||
def_API('Z3_solver_translate', SOLVER, (_in(CONTEXT), _in(SOLVER), _in(CONTEXT)))
|
||||
*/
|
||||
|
@ -6142,6 +6044,20 @@ extern "C" {
|
|||
*/
|
||||
Z3_ast_vector Z3_API Z3_solver_get_assertions(Z3_context c, Z3_solver s);
|
||||
|
||||
/**
|
||||
\brief load solver assertions from a file.
|
||||
|
||||
def_API('Z3_solver_from_file', VOID, (_in(CONTEXT), _in(SOLVER), _in(STRING)))
|
||||
*/
|
||||
void Z3_API Z3_solver_from_file(Z3_context c, Z3_solver s, Z3_string file_name);
|
||||
|
||||
/**
|
||||
\brief load solver assertions from a string.
|
||||
|
||||
def_API('Z3_solver_from_string', VOID, (_in(CONTEXT), _in(SOLVER), _in(STRING)))
|
||||
*/
|
||||
void Z3_API Z3_solver_from_string(Z3_context c, Z3_solver s, Z3_string file_name);
|
||||
|
||||
/**
|
||||
\brief Check whether the assertions in a given solver are consistent or not.
|
||||
|
||||
|
|
|
@ -363,7 +363,7 @@ extern "C" {
|
|||
void Z3_API Z3_fixedpoint_set_reduce_assign_callback(
|
||||
Z3_context c ,Z3_fixedpoint d, Z3_fixedpoint_reduce_assign_callback_fptr cb);
|
||||
|
||||
/** \brief Register a callback for buildling terms based on the relational operators. */
|
||||
/** \brief Register a callback for building terms based on the relational operators. */
|
||||
void Z3_API Z3_fixedpoint_set_reduce_app_callback(
|
||||
Z3_context c, Z3_fixedpoint d, Z3_fixedpoint_reduce_app_callback_fptr cb);
|
||||
|
||||
|
|
|
@ -433,7 +433,7 @@ extern "C" {
|
|||
\param c logical context
|
||||
\param rm term of RoundingMode sort
|
||||
\param t1 term of FloatingPoint sort
|
||||
\param t2 term of FloatingPoint sor
|
||||
\param t2 term of FloatingPoint sort
|
||||
\param t3 term of FloatingPoint sort
|
||||
|
||||
The result is round((t1 * t2) + t3)
|
||||
|
|
|
@ -430,10 +430,10 @@ struct z3_replayer::imp {
|
|||
next(); skip_blank(); read_ptr();
|
||||
TRACE("z3_replayer", tout << "[" << m_line << "] " << "P " << m_ptr << "\n";);
|
||||
if (m_ptr == 0) {
|
||||
m_args.push_back(0);
|
||||
m_args.push_back(nullptr);
|
||||
}
|
||||
else {
|
||||
void * obj = 0;
|
||||
void * obj = nullptr;
|
||||
if (!m_heap.find(m_ptr, obj))
|
||||
throw z3_replayer_exception("invalid pointer");
|
||||
m_args.push_back(value(obj));
|
||||
|
@ -453,7 +453,7 @@ struct z3_replayer::imp {
|
|||
// push null symbol
|
||||
next();
|
||||
TRACE("z3_replayer", tout << "[" << m_line << "] " << "N\n";);
|
||||
m_args.push_back(value(SYMBOL, static_cast<char const *>(0)));
|
||||
m_args.push_back(value(SYMBOL, static_cast<char const *>(nullptr)));
|
||||
break;
|
||||
case '$': {
|
||||
// push symbol
|
||||
|
@ -689,7 +689,7 @@ struct z3_replayer::imp {
|
|||
}
|
||||
|
||||
void reset() {
|
||||
m_result = 0;
|
||||
m_result = nullptr;
|
||||
m_args.reset();
|
||||
m_obj_arrays.reset();
|
||||
m_sym_arrays.reset();
|
||||
|
|
|
@ -187,8 +187,8 @@ void act_cache::insert(expr * k, expr * v) {
|
|||
*/
|
||||
expr * act_cache::find(expr * k) {
|
||||
map::key_value * entry = m_table.find_core(k);
|
||||
if (entry == 0)
|
||||
return 0;
|
||||
if (entry == nullptr)
|
||||
return nullptr;
|
||||
if (GET_TAG(entry->m_value) == 0) {
|
||||
entry->m_value = TAG(expr*, entry->m_value, 1);
|
||||
SASSERT(GET_TAG(entry->m_value) == 1);
|
||||
|
|
|
@ -65,7 +65,7 @@ struct arith_decl_plugin::algebraic_numbers_wrapper {
|
|||
};
|
||||
|
||||
arith_decl_plugin::algebraic_numbers_wrapper & arith_decl_plugin::aw() const {
|
||||
if (m_aw == 0)
|
||||
if (m_aw == nullptr)
|
||||
const_cast<arith_decl_plugin*>(this)->m_aw = alloc(algebraic_numbers_wrapper, m_manager->limit());
|
||||
return *m_aw;
|
||||
}
|
||||
|
@ -100,7 +100,7 @@ app * arith_decl_plugin::mk_numeral(sexpr const * p, unsigned i) {
|
|||
|
||||
void arith_decl_plugin::del(parameter const & p) {
|
||||
SASSERT(p.is_external());
|
||||
if (m_aw != 0) {
|
||||
if (m_aw != nullptr) {
|
||||
aw().recycle_id(p.get_ext_id());
|
||||
}
|
||||
}
|
||||
|
@ -222,56 +222,56 @@ void arith_decl_plugin::set_manager(ast_manager * m, family_id id) {
|
|||
}
|
||||
|
||||
arith_decl_plugin::arith_decl_plugin():
|
||||
m_aw(0),
|
||||
m_aw(nullptr),
|
||||
m_intv_sym("Int"),
|
||||
m_realv_sym("Real"),
|
||||
m_rootv_sym("RootObject"),
|
||||
m_real_decl(0),
|
||||
m_int_decl(0),
|
||||
m_r_le_decl(0),
|
||||
m_r_ge_decl(0),
|
||||
m_r_lt_decl(0),
|
||||
m_r_gt_decl(0),
|
||||
m_r_add_decl(0),
|
||||
m_r_sub_decl(0),
|
||||
m_r_uminus_decl(0),
|
||||
m_r_mul_decl(0),
|
||||
m_r_div_decl(0),
|
||||
m_i_le_decl(0),
|
||||
m_i_ge_decl(0),
|
||||
m_i_lt_decl(0),
|
||||
m_i_gt_decl(0),
|
||||
m_i_add_decl(0),
|
||||
m_i_sub_decl(0),
|
||||
m_i_uminus_decl(0),
|
||||
m_i_mul_decl(0),
|
||||
m_i_div_decl(0),
|
||||
m_i_mod_decl(0),
|
||||
m_i_rem_decl(0),
|
||||
m_to_real_decl(0),
|
||||
m_to_int_decl(0),
|
||||
m_is_int_decl(0),
|
||||
m_r_power_decl(0),
|
||||
m_i_power_decl(0),
|
||||
m_r_abs_decl(0),
|
||||
m_i_abs_decl(0),
|
||||
m_sin_decl(0),
|
||||
m_cos_decl(0),
|
||||
m_tan_decl(0),
|
||||
m_asin_decl(0),
|
||||
m_acos_decl(0),
|
||||
m_atan_decl(0),
|
||||
m_sinh_decl(0),
|
||||
m_cosh_decl(0),
|
||||
m_tanh_decl(0),
|
||||
m_asinh_decl(0),
|
||||
m_acosh_decl(0),
|
||||
m_atanh_decl(0),
|
||||
m_pi(0),
|
||||
m_e(0),
|
||||
m_neg_root_decl(0),
|
||||
m_u_asin_decl(0),
|
||||
m_u_acos_decl(0),
|
||||
m_real_decl(nullptr),
|
||||
m_int_decl(nullptr),
|
||||
m_r_le_decl(nullptr),
|
||||
m_r_ge_decl(nullptr),
|
||||
m_r_lt_decl(nullptr),
|
||||
m_r_gt_decl(nullptr),
|
||||
m_r_add_decl(nullptr),
|
||||
m_r_sub_decl(nullptr),
|
||||
m_r_uminus_decl(nullptr),
|
||||
m_r_mul_decl(nullptr),
|
||||
m_r_div_decl(nullptr),
|
||||
m_i_le_decl(nullptr),
|
||||
m_i_ge_decl(nullptr),
|
||||
m_i_lt_decl(nullptr),
|
||||
m_i_gt_decl(nullptr),
|
||||
m_i_add_decl(nullptr),
|
||||
m_i_sub_decl(nullptr),
|
||||
m_i_uminus_decl(nullptr),
|
||||
m_i_mul_decl(nullptr),
|
||||
m_i_div_decl(nullptr),
|
||||
m_i_mod_decl(nullptr),
|
||||
m_i_rem_decl(nullptr),
|
||||
m_to_real_decl(nullptr),
|
||||
m_to_int_decl(nullptr),
|
||||
m_is_int_decl(nullptr),
|
||||
m_r_power_decl(nullptr),
|
||||
m_i_power_decl(nullptr),
|
||||
m_r_abs_decl(nullptr),
|
||||
m_i_abs_decl(nullptr),
|
||||
m_sin_decl(nullptr),
|
||||
m_cos_decl(nullptr),
|
||||
m_tan_decl(nullptr),
|
||||
m_asin_decl(nullptr),
|
||||
m_acos_decl(nullptr),
|
||||
m_atan_decl(nullptr),
|
||||
m_sinh_decl(nullptr),
|
||||
m_cosh_decl(nullptr),
|
||||
m_tanh_decl(nullptr),
|
||||
m_asinh_decl(nullptr),
|
||||
m_acosh_decl(nullptr),
|
||||
m_atanh_decl(nullptr),
|
||||
m_pi(nullptr),
|
||||
m_e(nullptr),
|
||||
m_neg_root_decl(nullptr),
|
||||
m_u_asin_decl(nullptr),
|
||||
m_u_acos_decl(nullptr),
|
||||
m_convert_int_numerals_to_real(false) {
|
||||
}
|
||||
|
||||
|
@ -335,7 +335,7 @@ sort * arith_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, paramete
|
|||
switch (k) {
|
||||
case REAL_SORT: return m_real_decl;
|
||||
case INT_SORT: return m_int_decl;
|
||||
default: return 0;
|
||||
default: return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -380,7 +380,7 @@ inline func_decl * arith_decl_plugin::mk_func_decl(decl_kind k, bool is_real) {
|
|||
//case OP_MOD_0: return m_mod_0_decl;
|
||||
case OP_U_ASIN: return m_u_asin_decl;
|
||||
case OP_U_ACOS: return m_u_acos_decl;
|
||||
default: return 0;
|
||||
default: return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -408,7 +408,7 @@ app * arith_decl_plugin::mk_numeral(rational const & val, bool is_int) {
|
|||
if (u_val < MAX_SMALL_NUM_TO_CACHE) {
|
||||
if (is_int && !m_convert_int_numerals_to_real) {
|
||||
app * r = m_small_ints.get(u_val, 0);
|
||||
if (r == 0) {
|
||||
if (r == nullptr) {
|
||||
parameter p[2] = { parameter(val), parameter(1) };
|
||||
r = m_manager->mk_const(m_manager->mk_const_decl(m_intv_sym, m_int_decl, func_decl_info(m_family_id, OP_NUM, 2, p)));
|
||||
m_manager->inc_ref(r);
|
||||
|
@ -418,7 +418,7 @@ app * arith_decl_plugin::mk_numeral(rational const & val, bool is_int) {
|
|||
}
|
||||
else {
|
||||
app * r = m_small_reals.get(u_val, 0);
|
||||
if (r == 0) {
|
||||
if (r == nullptr) {
|
||||
parameter p[2] = { parameter(val), parameter(0) };
|
||||
r = m_manager->mk_const(m_manager->mk_const_decl(m_realv_sym, m_real_decl, func_decl_info(m_family_id, OP_NUM, 2, p)));
|
||||
m_manager->inc_ref(r);
|
||||
|
@ -440,7 +440,7 @@ app * arith_decl_plugin::mk_numeral(rational const & val, bool is_int) {
|
|||
func_decl * arith_decl_plugin::mk_num_decl(unsigned num_parameters, parameter const * parameters, unsigned arity) {
|
||||
if (!(num_parameters == 2 && arity == 0 && parameters[0].is_rational() && parameters[1].is_int())) {
|
||||
m_manager->raise_exception("invalid numeral declaration");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (parameters[1].get_int() != 0)
|
||||
return m_manager->mk_const_decl(m_intv_sym, m_int_decl, func_decl_info(m_family_id, OP_NUM, num_parameters, parameters));
|
||||
|
@ -480,7 +480,7 @@ func_decl * arith_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
return mk_num_decl(num_parameters, parameters, arity);
|
||||
if (arity == 0 && !is_const_op(k)) {
|
||||
m_manager->raise_exception("no arguments supplied to arithmetical operator");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (m_manager->int_real_coercions() && use_coercion(k)) {
|
||||
return mk_func_decl(fix_kind(k, arity), has_real_arg(arity, domain, m_real_decl));
|
||||
|
@ -497,7 +497,7 @@ func_decl * arith_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
return mk_num_decl(num_parameters, parameters, num_args);
|
||||
if (num_args == 0 && !is_const_op(k)) {
|
||||
m_manager->raise_exception("no arguments supplied to arithmetical operator");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (m_manager->int_real_coercions() && use_coercion(k)) {
|
||||
return mk_func_decl(fix_kind(k, num_args), has_real_arg(m_manager, num_args, args, m_real_decl));
|
||||
|
@ -641,7 +641,7 @@ bool arith_recognizers::is_numeral(expr const * n, rational & val, bool & is_int
|
|||
arith_util::arith_util(ast_manager & m):
|
||||
arith_recognizers(m.mk_family_id("arith")),
|
||||
m_manager(m),
|
||||
m_plugin(0) {
|
||||
m_plugin(nullptr) {
|
||||
}
|
||||
|
||||
void arith_util::init_plugin() {
|
||||
|
|
|
@ -145,7 +145,7 @@ protected:
|
|||
bool m_convert_int_numerals_to_real;
|
||||
|
||||
func_decl * mk_func_decl(decl_kind k, bool is_real);
|
||||
virtual void set_manager(ast_manager * m, family_id id);
|
||||
void set_manager(ast_manager * m, family_id id) override;
|
||||
decl_kind fix_kind(decl_kind k, unsigned arity);
|
||||
void check_arity(unsigned arity, unsigned expected_arity);
|
||||
func_decl * mk_num_decl(unsigned num_parameters, parameter const * parameters, unsigned arity);
|
||||
|
@ -153,38 +153,38 @@ protected:
|
|||
public:
|
||||
arith_decl_plugin();
|
||||
|
||||
virtual ~arith_decl_plugin();
|
||||
virtual void finalize();
|
||||
~arith_decl_plugin() override;
|
||||
void finalize() override;
|
||||
|
||||
algebraic_numbers::manager & am() const;
|
||||
algebraic_numbers_wrapper & aw() const;
|
||||
|
||||
virtual void del(parameter const & p);
|
||||
virtual parameter translate(parameter const & p, decl_plugin & target);
|
||||
void del(parameter const & p) override;
|
||||
parameter translate(parameter const & p, decl_plugin & target) override;
|
||||
|
||||
virtual decl_plugin * mk_fresh() {
|
||||
decl_plugin * mk_fresh() override {
|
||||
return alloc(arith_decl_plugin);
|
||||
}
|
||||
|
||||
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
|
||||
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
|
||||
|
||||
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range);
|
||||
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range) override;
|
||||
|
||||
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned num_args, expr * const * args, sort * range);
|
||||
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned num_args, expr * const * args, sort * range) override;
|
||||
|
||||
virtual bool is_value(app * e) const;
|
||||
bool is_value(app * e) const override;
|
||||
|
||||
virtual bool is_unique_value(app * e) const;
|
||||
bool is_unique_value(app * e) const override;
|
||||
|
||||
virtual bool are_equal(app * a, app * b) const;
|
||||
bool are_equal(app * a, app * b) const override;
|
||||
|
||||
virtual bool are_distinct(app * a, app * b) const;
|
||||
bool are_distinct(app * a, app * b) const override;
|
||||
|
||||
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
|
||||
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
|
||||
|
||||
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
|
||||
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
|
||||
|
||||
app * mk_numeral(rational const & n, bool is_int);
|
||||
|
||||
|
@ -197,9 +197,9 @@ public:
|
|||
|
||||
app * mk_e() const { return m_e; }
|
||||
|
||||
virtual expr * get_some_value(sort * s);
|
||||
expr * get_some_value(sort * s) override;
|
||||
|
||||
virtual bool is_considered_uninterpreted(func_decl * f) {
|
||||
bool is_considered_uninterpreted(func_decl * f) override {
|
||||
if (f->get_family_id() != get_family_id())
|
||||
return false;
|
||||
switch (f->get_decl_kind())
|
||||
|
@ -370,7 +370,7 @@ public:
|
|||
app * mk_lt(expr * arg1, expr * arg2) const { return m_manager.mk_app(m_afid, OP_LT, arg1, arg2); }
|
||||
app * mk_gt(expr * arg1, expr * arg2) const { return m_manager.mk_app(m_afid, OP_GT, arg1, arg2); }
|
||||
|
||||
app * mk_add(unsigned num_args, expr * const * args) const { return m_manager.mk_app(m_afid, OP_ADD, num_args, args); }
|
||||
app * mk_add(unsigned num_args, expr * const * args) const { return num_args == 1 && is_app(args[0]) ? to_app(args[0]) : m_manager.mk_app(m_afid, OP_ADD, num_args, args); }
|
||||
app * mk_add(expr * arg1, expr * arg2) const { return m_manager.mk_app(m_afid, OP_ADD, arg1, arg2); }
|
||||
app * mk_add(expr * arg1, expr * arg2, expr* arg3) const { return m_manager.mk_app(m_afid, OP_ADD, arg1, arg2, arg3); }
|
||||
|
||||
|
@ -378,7 +378,7 @@ public:
|
|||
app * mk_sub(unsigned num_args, expr * const * args) const { return m_manager.mk_app(m_afid, OP_SUB, num_args, args); }
|
||||
app * mk_mul(expr * arg1, expr * arg2) const { return m_manager.mk_app(m_afid, OP_MUL, arg1, arg2); }
|
||||
app * mk_mul(expr * arg1, expr * arg2, expr* arg3) const { return m_manager.mk_app(m_afid, OP_MUL, arg1, arg2, arg3); }
|
||||
app * mk_mul(unsigned num_args, expr * const * args) const { return m_manager.mk_app(m_afid, OP_MUL, num_args, args); }
|
||||
app * mk_mul(unsigned num_args, expr * const * args) const { return num_args == 1 && is_app(args[0]) ? to_app(args[0]) : m_manager.mk_app(m_afid, OP_MUL, num_args, args); }
|
||||
app * mk_uminus(expr * arg) const { return m_manager.mk_app(m_afid, OP_UMINUS, arg); }
|
||||
app * mk_div(expr * arg1, expr * arg2) { return m_manager.mk_app(m_afid, OP_DIV, arg1, arg2); }
|
||||
app * mk_idiv(expr * arg1, expr * arg2) { return m_manager.mk_app(m_afid, OP_IDIV, arg1, arg2); }
|
||||
|
|
|
@ -44,7 +44,7 @@ sort * array_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, paramete
|
|||
if (k == _SET_SORT) {
|
||||
if (num_parameters != 1) {
|
||||
m_manager->raise_exception("invalid array sort definition, invalid number of parameters");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
parameter params[2] = { parameters[0], parameter(m_manager->mk_bool_sort()) };
|
||||
return mk_sort(ARRAY_SORT, 2, params);
|
||||
|
@ -52,13 +52,13 @@ sort * array_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, paramete
|
|||
SASSERT(k == ARRAY_SORT);
|
||||
if (num_parameters < 2) {
|
||||
m_manager->raise_exception("invalid array sort definition, invalid number of parameters");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < num_parameters; i++) {
|
||||
if (!parameters[i].is_ast() || !is_sort(parameters[i].get_ast())) {
|
||||
m_manager->raise_exception("invalid array sort definition, parameter is not a sort");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
sort * range = to_sort(parameters[num_parameters - 1].get_ast());
|
||||
|
@ -120,15 +120,15 @@ bool array_decl_plugin::is_array_sort(sort* s) const {
|
|||
func_decl * array_decl_plugin::mk_const(sort * s, unsigned arity, sort * const * domain) {
|
||||
if (arity != 1) {
|
||||
m_manager->raise_exception("invalid const array definition, invalid domain size");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (!is_array_sort(s)) {
|
||||
m_manager->raise_exception("invalid const array definition, parameter is not an array sort");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (!m_manager->compatible_sorts(get_array_range(s), domain[0])) {
|
||||
m_manager->raise_exception("invalid const array definition, sort mismatch between array range and argument");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
parameter param(s);
|
||||
func_decl_info info(m_family_id, OP_CONST_ARRAY, 1, ¶m);
|
||||
|
@ -142,11 +142,11 @@ func_decl * array_decl_plugin::mk_map(func_decl* f, unsigned arity, sort* const*
|
|||
buffer << "map expects to take as many arguments as the function being mapped, "
|
||||
<< "it was given " << arity << " but expects " << f->get_arity();
|
||||
m_manager->raise_exception(buffer.str().c_str());
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (arity == 0) {
|
||||
m_manager->raise_exception("don't use map on constants");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
//
|
||||
// check that each domain[i] is an array sort
|
||||
|
@ -159,14 +159,14 @@ func_decl * array_decl_plugin::mk_map(func_decl* f, unsigned arity, sort* const*
|
|||
std::ostringstream buffer;
|
||||
buffer << "map expects an array sort as argument at position " << i;
|
||||
m_manager->raise_exception(buffer.str().c_str());
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (get_array_arity(domain[i]) != dom_arity) {
|
||||
std::ostringstream buffer;
|
||||
buffer << "map expects all arguments to have the same array domain, "
|
||||
<< "this is not the case for argument " << i;
|
||||
m_manager->raise_exception(buffer.str().c_str());
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
for (unsigned j = 0; j < dom_arity; ++j) {
|
||||
if (get_array_domain(domain[i],j) != get_array_domain(domain[0],j)) {
|
||||
|
@ -174,7 +174,7 @@ func_decl * array_decl_plugin::mk_map(func_decl* f, unsigned arity, sort* const*
|
|||
buffer << "map expects all arguments to have the same array domain, "
|
||||
<< "this is not the case for argument " << i;
|
||||
m_manager->raise_exception(buffer.str().c_str());
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
if (get_array_range(domain[i]) != f->get_domain(i)) {
|
||||
|
@ -182,7 +182,7 @@ func_decl * array_decl_plugin::mk_map(func_decl* f, unsigned arity, sort* const*
|
|||
buffer << "map expects the argument at position " << i
|
||||
<< " to have the array range the same as the function";
|
||||
m_manager->raise_exception(buffer.str().c_str());
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
vector<parameter> parameters;
|
||||
|
@ -211,19 +211,19 @@ func_decl * array_decl_plugin::mk_map(func_decl* f, unsigned arity, sort* const*
|
|||
func_decl * array_decl_plugin::mk_default(unsigned domain_size, sort * const * domain) {
|
||||
if (domain_size != 1) {
|
||||
m_manager->raise_exception("invalid default array definition, invalid domain size");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
// check that domain[0] is an array sort.
|
||||
unsigned num_parameters = domain[0]->get_num_parameters();
|
||||
|
||||
if (num_parameters <= 1) {
|
||||
m_manager->raise_exception("parameter mismatch. There should be more than one parameter to defaults");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
parameter param(domain[0]->get_parameter(num_parameters-1));
|
||||
if (!param.is_ast() || !is_sort(param.get_ast())) {
|
||||
m_manager->raise_exception("last parameter should be a sort");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
sort * s = to_sort(param.get_ast());
|
||||
|
||||
|
@ -235,7 +235,7 @@ func_decl * array_decl_plugin::mk_default(unsigned domain_size, sort * const * d
|
|||
func_decl* array_decl_plugin::mk_select(unsigned arity, sort * const * domain) {
|
||||
if (arity <= 1) {
|
||||
m_manager->raise_exception("select takes at least two arguments");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
sort * s = domain[0];
|
||||
unsigned num_parameters = s->get_num_parameters();
|
||||
|
@ -245,7 +245,7 @@ func_decl* array_decl_plugin::mk_select(unsigned arity, sort * const * domain) {
|
|||
std::stringstream strm;
|
||||
strm << "select requires " << num_parameters << " arguments, but was provided with " << arity << " arguments";
|
||||
m_manager->raise_exception(strm.str().c_str());
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
ptr_buffer<sort> new_domain; // we need this because of coercions.
|
||||
new_domain.push_back(s);
|
||||
|
@ -255,7 +255,7 @@ func_decl* array_decl_plugin::mk_select(unsigned arity, sort * const * domain) {
|
|||
!m_manager->compatible_sorts(domain[i+1], to_sort(parameters[i].get_ast()))) {
|
||||
m_manager->raise_exception("domain sort and parameter do not match");
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
new_domain.push_back(to_sort(parameters[i].get_ast()));
|
||||
}
|
||||
|
@ -267,7 +267,7 @@ func_decl* array_decl_plugin::mk_select(unsigned arity, sort * const * domain) {
|
|||
func_decl * array_decl_plugin::mk_store(unsigned arity, sort * const * domain) {
|
||||
if (arity < 3) {
|
||||
m_manager->raise_exception("store takes at least 3 arguments");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
sort * s = domain[0];
|
||||
unsigned num_parameters = s->get_num_parameters();
|
||||
|
@ -275,7 +275,7 @@ func_decl * array_decl_plugin::mk_store(unsigned arity, sort * const * domain) {
|
|||
if (!is_array_sort(s)) {
|
||||
m_manager->raise_exception("store expects the first argument sort to be an array");
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (arity != num_parameters+1) {
|
||||
std::ostringstream buffer;
|
||||
|
@ -283,19 +283,19 @@ func_decl * array_decl_plugin::mk_store(unsigned arity, sort * const * domain) {
|
|||
<< ", instead it was passed " << (arity - 1) << "arguments";
|
||||
m_manager->raise_exception(buffer.str().c_str());
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
ptr_buffer<sort> new_domain; // we need this because of coercions.
|
||||
new_domain.push_back(s);
|
||||
for (unsigned i = 0; i < num_parameters; ++i) {
|
||||
if (!parameters[i].is_ast() || !is_sort(parameters[i].get_ast())) {
|
||||
m_manager->raise_exception("expecting sort parameter");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (!m_manager->compatible_sorts(to_sort(parameters[i].get_ast()), domain[i+1])) {
|
||||
m_manager->raise_exception("domain sort and parameter do not match");
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
new_domain.push_back(to_sort(parameters[i].get_ast()));
|
||||
}
|
||||
|
@ -307,13 +307,13 @@ func_decl * array_decl_plugin::mk_store(unsigned arity, sort * const * domain) {
|
|||
func_decl * array_decl_plugin::mk_array_ext(unsigned arity, sort * const * domain, unsigned i) {
|
||||
if (arity != 2 || domain[0] != domain[1]) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
sort * s = domain[0];
|
||||
unsigned num_parameters = s->get_num_parameters();
|
||||
if (num_parameters == 0 || i >= num_parameters - 1) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
sort * r = to_sort(s->get_parameter(i).get_ast());
|
||||
parameter param(i);
|
||||
|
@ -362,11 +362,11 @@ func_decl * array_decl_plugin::mk_set_union(unsigned arity, sort * const * domai
|
|||
|
||||
if (arity == 0) {
|
||||
m_manager->raise_exception("union takes at least one argument");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
sort * s = domain[0];
|
||||
if (!check_set_arguments(arity, domain)) {
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
parameter param(s);
|
||||
func_decl_info info(m_family_id, OP_SET_UNION, 1, ¶m);
|
||||
|
@ -381,10 +381,10 @@ func_decl * array_decl_plugin::mk_set_intersect(unsigned arity, sort * const * d
|
|||
|
||||
if (arity == 0) {
|
||||
m_manager->raise_exception("intersection takes at least one argument");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (!check_set_arguments(arity, domain)) {
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
func_decl_info info(m_family_id, OP_SET_INTERSECT);
|
||||
info.set_associative();
|
||||
|
@ -397,10 +397,10 @@ func_decl * array_decl_plugin::mk_set_intersect(unsigned arity, sort * const * d
|
|||
func_decl * array_decl_plugin::mk_set_difference(unsigned arity, sort * const * domain) {
|
||||
if (arity != 2) {
|
||||
m_manager->raise_exception("set difference takes precisely two arguments");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (!check_set_arguments(arity, domain)) {
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
return m_manager->mk_func_decl(m_set_difference_sym, arity, domain, domain[0],
|
||||
func_decl_info(m_family_id, OP_SET_DIFFERENCE));
|
||||
|
@ -409,10 +409,10 @@ func_decl * array_decl_plugin::mk_set_difference(unsigned arity, sort * const *
|
|||
func_decl * array_decl_plugin::mk_set_complement(unsigned arity, sort * const * domain) {
|
||||
if (arity != 1) {
|
||||
m_manager->raise_exception("set complement takes one argument");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (!check_set_arguments(arity, domain)) {
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
return m_manager->mk_func_decl(m_set_complement_sym, arity, domain, domain[0],
|
||||
func_decl_info(m_family_id, OP_SET_COMPLEMENT));
|
||||
|
@ -421,10 +421,10 @@ func_decl * array_decl_plugin::mk_set_complement(unsigned arity, sort * const *
|
|||
func_decl * array_decl_plugin::mk_set_subset(unsigned arity, sort * const * domain) {
|
||||
if (arity != 2) {
|
||||
m_manager->raise_exception("subset takes two arguments");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
if (!check_set_arguments(arity, domain)) {
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
sort * bool_sort = m_manager->mk_bool_sort();
|
||||
return m_manager->mk_func_decl(m_set_subset_sym, arity, domain, bool_sort,
|
||||
|
@ -456,20 +456,20 @@ func_decl * array_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
sort * s = to_sort(parameters[0].get_ast());
|
||||
return mk_const(s, arity, domain);
|
||||
}
|
||||
else if (range != 0) {
|
||||
else if (range != nullptr) {
|
||||
return mk_const(range, arity, domain);
|
||||
}
|
||||
else {
|
||||
m_manager->raise_exception("array operation requires one sort parameter (the array sort)");
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
case OP_ARRAY_MAP: {
|
||||
if (num_parameters != 1 || !parameters[0].is_ast() || !is_func_decl(parameters[0].get_ast())) {
|
||||
m_manager->raise_exception("array operation requires one function declaration parameter (the function to be mapped)");
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
func_decl * f = to_func_decl(parameters[0].get_ast());
|
||||
return mk_map(f, arity, domain);
|
||||
|
@ -480,7 +480,7 @@ func_decl * array_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
}
|
||||
if (num_parameters != 1 || !parameters[0].is_int()) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
return mk_array_ext(arity, domain, parameters[0].get_int());
|
||||
case OP_ARRAY_DEFAULT:
|
||||
|
@ -506,12 +506,12 @@ func_decl * array_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
tout << "as-array-bug: " << to_func_decl(parameters[0].get_ast())->get_name() << " " << to_func_decl(parameters[0].get_ast())->get_arity() << std::endl;);
|
||||
m_manager->raise_exception("as-array takes one parameter, a function declaration with arity greater than zero");
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
func_decl * f = to_func_decl(parameters[0].get_ast());
|
||||
return mk_as_array(f);
|
||||
}
|
||||
default: return 0;
|
||||
default: return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -98,9 +98,9 @@ class array_decl_plugin : public decl_plugin {
|
|||
bool is_array_sort(sort* s) const;
|
||||
public:
|
||||
array_decl_plugin();
|
||||
virtual ~array_decl_plugin() {}
|
||||
~array_decl_plugin() override {}
|
||||
|
||||
virtual decl_plugin * mk_fresh() {
|
||||
decl_plugin * mk_fresh() override {
|
||||
return alloc(array_decl_plugin);
|
||||
}
|
||||
|
||||
|
@ -111,23 +111,23 @@ class array_decl_plugin : public decl_plugin {
|
|||
// parameters[n-1] - nth dimension
|
||||
// parameters[n] - range
|
||||
//
|
||||
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
|
||||
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
|
||||
|
||||
//
|
||||
// Contract for func_decl:
|
||||
// parameters[0] - array sort
|
||||
// Contract for others:
|
||||
// no parameters
|
||||
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range);
|
||||
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range) override;
|
||||
|
||||
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
|
||||
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
|
||||
|
||||
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
|
||||
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
|
||||
|
||||
virtual expr * get_some_value(sort * s);
|
||||
expr * get_some_value(sort * s) override;
|
||||
|
||||
virtual bool is_fully_interp(sort * s) const;
|
||||
bool is_fully_interp(sort * s) const override;
|
||||
};
|
||||
|
||||
class array_recognizers {
|
||||
|
@ -161,11 +161,11 @@ public:
|
|||
bool is_as_array_tree(expr * n);
|
||||
|
||||
app * mk_store(unsigned num_args, expr * const * args) {
|
||||
return m_manager.mk_app(m_fid, OP_STORE, 0, 0, num_args, args);
|
||||
return m_manager.mk_app(m_fid, OP_STORE, 0, nullptr, num_args, args);
|
||||
}
|
||||
|
||||
app * mk_select(unsigned num_args, expr * const * args) {
|
||||
return m_manager.mk_app(m_fid, OP_SELECT, 0, 0, num_args, args);
|
||||
return m_manager.mk_app(m_fid, OP_SELECT, 0, nullptr, num_args, args);
|
||||
}
|
||||
|
||||
app * mk_map(func_decl * f, unsigned num_args, expr * const * args) {
|
||||
|
@ -191,7 +191,7 @@ public:
|
|||
|
||||
app * mk_as_array(func_decl * f) {
|
||||
parameter param(f);
|
||||
return m_manager.mk_app(m_fid, OP_AS_ARRAY, 1, ¶m, 0, 0, 0);
|
||||
return m_manager.mk_app(m_fid, OP_AS_ARRAY, 1, ¶m, 0, nullptr, nullptr);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
296
src/ast/ast.cpp
296
src/ast/ast.cpp
|
@ -405,7 +405,7 @@ sort * get_sort(expr const * n) {
|
|||
break;
|
||||
default:
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -434,18 +434,18 @@ bool compare_nodes(ast const * n1, ast const * n2) {
|
|||
}
|
||||
switch (n1->get_kind()) {
|
||||
case AST_SORT:
|
||||
if ((to_sort(n1)->get_info() == 0) != (to_sort(n2)->get_info() == 0)) {
|
||||
if ((to_sort(n1)->get_info() == nullptr) != (to_sort(n2)->get_info() == nullptr)) {
|
||||
return false;
|
||||
}
|
||||
if (to_sort(n1)->get_info() != 0 && !(*to_sort(n1)->get_info() == *to_sort(n2)->get_info())) {
|
||||
if (to_sort(n1)->get_info() != nullptr && !(*to_sort(n1)->get_info() == *to_sort(n2)->get_info())) {
|
||||
return false;
|
||||
}
|
||||
return to_sort(n1)->get_name() == to_sort(n2)->get_name();
|
||||
case AST_FUNC_DECL:
|
||||
if ((to_func_decl(n1)->get_info() == 0) != (to_func_decl(n2)->get_info() == 0)) {
|
||||
if ((to_func_decl(n1)->get_info() == nullptr) != (to_func_decl(n2)->get_info() == nullptr)) {
|
||||
return false;
|
||||
}
|
||||
if (to_func_decl(n1)->get_info() != 0 && !(*to_func_decl(n1)->get_info() == *to_func_decl(n2)->get_info())) {
|
||||
if (to_func_decl(n1)->get_info() != nullptr && !(*to_func_decl(n1)->get_info() == *to_func_decl(n2)->get_info())) {
|
||||
return false;
|
||||
}
|
||||
return
|
||||
|
@ -549,13 +549,13 @@ unsigned get_node_hash(ast const * n) {
|
|||
|
||||
switch (n->get_kind()) {
|
||||
case AST_SORT:
|
||||
if (to_sort(n)->get_info() == 0)
|
||||
if (to_sort(n)->get_info() == nullptr)
|
||||
return to_sort(n)->get_name().hash();
|
||||
else
|
||||
return combine_hash(to_sort(n)->get_name().hash(), to_sort(n)->get_info()->hash());
|
||||
case AST_FUNC_DECL:
|
||||
return ast_array_hash(to_func_decl(n)->get_domain(), to_func_decl(n)->get_arity(),
|
||||
to_func_decl(n)->get_info() == 0 ?
|
||||
to_func_decl(n)->get_info() == nullptr ?
|
||||
to_func_decl(n)->get_name().hash() : combine_hash(to_func_decl(n)->get_name().hash(), to_func_decl(n)->get_info()->hash()));
|
||||
case AST_APP:
|
||||
return ast_array_hash(to_app(n)->get_args(),
|
||||
|
@ -587,13 +587,13 @@ void ast_table::erase(ast * n) {
|
|||
unsigned idx = h & mask;
|
||||
cell * c = m_table + idx;
|
||||
SASSERT(!c->is_free());
|
||||
cell * prev = 0;
|
||||
cell * prev = nullptr;
|
||||
while (true) {
|
||||
if (c->m_data == n) {
|
||||
m_size--;
|
||||
if (prev == 0) {
|
||||
if (prev == nullptr) {
|
||||
cell * next = c->m_next;
|
||||
if (next == 0) {
|
||||
if (next == nullptr) {
|
||||
m_used_slots--;
|
||||
c->mark_free();
|
||||
SASSERT(c->is_free());
|
||||
|
@ -638,49 +638,49 @@ func_decl * decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, para
|
|||
// -----------------------------------
|
||||
|
||||
basic_decl_plugin::basic_decl_plugin():
|
||||
m_bool_sort(0),
|
||||
m_true_decl(0),
|
||||
m_false_decl(0),
|
||||
m_and_decl(0),
|
||||
m_or_decl(0),
|
||||
m_iff_decl(0),
|
||||
m_xor_decl(0),
|
||||
m_not_decl(0),
|
||||
m_interp_decl(0),
|
||||
m_implies_decl(0),
|
||||
m_bool_sort(nullptr),
|
||||
m_true_decl(nullptr),
|
||||
m_false_decl(nullptr),
|
||||
m_and_decl(nullptr),
|
||||
m_or_decl(nullptr),
|
||||
m_iff_decl(nullptr),
|
||||
m_xor_decl(nullptr),
|
||||
m_not_decl(nullptr),
|
||||
m_interp_decl(nullptr),
|
||||
m_implies_decl(nullptr),
|
||||
|
||||
m_proof_sort(0),
|
||||
m_undef_decl(0),
|
||||
m_true_pr_decl(0),
|
||||
m_asserted_decl(0),
|
||||
m_goal_decl(0),
|
||||
m_modus_ponens_decl(0),
|
||||
m_reflexivity_decl(0),
|
||||
m_symmetry_decl(0),
|
||||
m_transitivity_decl(0),
|
||||
m_quant_intro_decl(0),
|
||||
m_and_elim_decl(0),
|
||||
m_not_or_elim_decl(0),
|
||||
m_rewrite_decl(0),
|
||||
m_pull_quant_decl(0),
|
||||
m_pull_quant_star_decl(0),
|
||||
m_push_quant_decl(0),
|
||||
m_elim_unused_vars_decl(0),
|
||||
m_der_decl(0),
|
||||
m_quant_inst_decl(0),
|
||||
m_proof_sort(nullptr),
|
||||
m_undef_decl(nullptr),
|
||||
m_true_pr_decl(nullptr),
|
||||
m_asserted_decl(nullptr),
|
||||
m_goal_decl(nullptr),
|
||||
m_modus_ponens_decl(nullptr),
|
||||
m_reflexivity_decl(nullptr),
|
||||
m_symmetry_decl(nullptr),
|
||||
m_transitivity_decl(nullptr),
|
||||
m_quant_intro_decl(nullptr),
|
||||
m_and_elim_decl(nullptr),
|
||||
m_not_or_elim_decl(nullptr),
|
||||
m_rewrite_decl(nullptr),
|
||||
m_pull_quant_decl(nullptr),
|
||||
m_pull_quant_star_decl(nullptr),
|
||||
m_push_quant_decl(nullptr),
|
||||
m_elim_unused_vars_decl(nullptr),
|
||||
m_der_decl(nullptr),
|
||||
m_quant_inst_decl(nullptr),
|
||||
|
||||
m_hypothesis_decl(0),
|
||||
m_iff_true_decl(0),
|
||||
m_iff_false_decl(0),
|
||||
m_commutativity_decl(0),
|
||||
m_def_axiom_decl(0),
|
||||
m_lemma_decl(0),
|
||||
m_hypothesis_decl(nullptr),
|
||||
m_iff_true_decl(nullptr),
|
||||
m_iff_false_decl(nullptr),
|
||||
m_commutativity_decl(nullptr),
|
||||
m_def_axiom_decl(nullptr),
|
||||
m_lemma_decl(nullptr),
|
||||
|
||||
m_def_intro_decl(0),
|
||||
m_iff_oeq_decl(0),
|
||||
m_skolemize_decl(0),
|
||||
m_mp_oeq_decl(0),
|
||||
m_hyper_res_decl0(0) {
|
||||
m_def_intro_decl(nullptr),
|
||||
m_iff_oeq_decl(nullptr),
|
||||
m_skolemize_decl(nullptr),
|
||||
m_mp_oeq_decl(nullptr),
|
||||
m_hyper_res_decl0(nullptr) {
|
||||
}
|
||||
|
||||
bool basic_decl_plugin::check_proof_sorts(basic_op_kind k, unsigned arity, sort * const * domain) const {
|
||||
|
@ -790,7 +790,7 @@ func_decl * basic_decl_plugin::mk_proof_decl(basic_op_kind k, unsigned num_param
|
|||
}
|
||||
default:
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -852,7 +852,7 @@ func_decl * basic_decl_plugin::mk_proof_decl(basic_op_kind k, unsigned num_paren
|
|||
case PR_HYPER_RESOLVE: return mk_proof_decl("hyper-res", k, num_parents, m_hyper_res_decl0);
|
||||
default:
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1067,10 +1067,10 @@ func_decl * basic_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
case OP_IFF: return m_iff_decl;
|
||||
case OP_IMPLIES: return m_implies_decl;
|
||||
case OP_XOR: return m_xor_decl;
|
||||
case OP_ITE: return arity == 3 ? mk_ite_decl(join(domain[1], domain[2])) : 0;
|
||||
case OP_ITE: return arity == 3 ? mk_ite_decl(join(domain[1], domain[2])) : nullptr;
|
||||
// eq and oeq must have at least two arguments, they can have more since they are chainable
|
||||
case OP_EQ: return arity >= 2 ? mk_eq_decl_core("=", OP_EQ, join(arity, domain), m_eq_decls) : 0;
|
||||
case OP_OEQ: return arity >= 2 ? mk_eq_decl_core("~", OP_OEQ, join(arity, domain), m_oeq_decls) : 0;
|
||||
case OP_EQ: return arity >= 2 ? mk_eq_decl_core("=", OP_EQ, join(arity, domain), m_eq_decls) : nullptr;
|
||||
case OP_OEQ: return arity >= 2 ? mk_eq_decl_core("~", OP_OEQ, join(arity, domain), m_oeq_decls) : nullptr;
|
||||
case OP_DISTINCT: {
|
||||
func_decl_info info(m_family_id, OP_DISTINCT);
|
||||
info.set_pairwise();
|
||||
|
@ -1110,10 +1110,10 @@ func_decl * basic_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
case OP_IFF: return m_iff_decl;
|
||||
case OP_IMPLIES: return m_implies_decl;
|
||||
case OP_XOR: return m_xor_decl;
|
||||
case OP_ITE: return num_args == 3 ? mk_ite_decl(join(m_manager->get_sort(args[1]), m_manager->get_sort(args[2]))): 0;
|
||||
case OP_ITE: return num_args == 3 ? mk_ite_decl(join(m_manager->get_sort(args[1]), m_manager->get_sort(args[2]))): nullptr;
|
||||
// eq and oeq must have at least two arguments, they can have more since they are chainable
|
||||
case OP_EQ: return num_args >= 2 ? mk_eq_decl_core("=", OP_EQ, join(num_args, args), m_eq_decls) : 0;
|
||||
case OP_OEQ: return num_args >= 2 ? mk_eq_decl_core("~", OP_OEQ, join(num_args, args), m_oeq_decls) : 0;
|
||||
case OP_EQ: return num_args >= 2 ? mk_eq_decl_core("=", OP_EQ, join(num_args, args), m_eq_decls) : nullptr;
|
||||
case OP_OEQ: return num_args >= 2 ? mk_eq_decl_core("~", OP_OEQ, join(num_args, args), m_oeq_decls) : nullptr;
|
||||
case OP_DISTINCT:
|
||||
return decl_plugin::mk_func_decl(k, num_parameters, parameters, num_args, args, range);
|
||||
default:
|
||||
|
@ -1134,7 +1134,7 @@ func_decl * basic_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
expr * basic_decl_plugin::get_some_value(sort * s) {
|
||||
if (s == m_bool_sort)
|
||||
return m_manager->mk_false();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool basic_recognizers::is_ite(expr const * n, expr * & t1, expr * & t2, expr * & t3) const {
|
||||
|
@ -1168,7 +1168,7 @@ void label_decl_plugin::set_manager(ast_manager * m, family_id id) {
|
|||
|
||||
sort * label_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * label_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
|
@ -1176,12 +1176,12 @@ func_decl * label_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
if (k == OP_LABEL) {
|
||||
if (arity != 1 || num_parameters < 2 || !parameters[0].is_int() || !parameters[1].is_symbol() || !m_manager->is_bool(domain[0])) {
|
||||
m_manager->raise_exception("invalid label declaration");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
for (unsigned i = 2; i < num_parameters; i++) {
|
||||
if (!parameters[i].is_symbol()) {
|
||||
m_manager->raise_exception("invalid label declaration");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
return m_manager->mk_func_decl(parameters[0].get_int() ? m_lblpos : m_lblneg, arity, domain, domain[0],
|
||||
|
@ -1191,15 +1191,15 @@ func_decl * label_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
SASSERT(k == OP_LABEL_LIT);
|
||||
if (arity != 0) {
|
||||
m_manager->raise_exception("invalid label literal declaration");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
for (unsigned i = 0; i < num_parameters; i++) {
|
||||
if (!parameters[i].is_symbol()) {
|
||||
m_manager->raise_exception("invalid label literal declaration");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
return m_manager->mk_func_decl(m_lbllit, 0, static_cast<sort * const *>(0), m_manager->mk_bool_sort(),
|
||||
return m_manager->mk_func_decl(m_lbllit, 0, static_cast<sort * const *>(nullptr), m_manager->mk_bool_sort(),
|
||||
func_decl_info(m_family_id, OP_LABEL_LIT, num_parameters, parameters));
|
||||
}
|
||||
}
|
||||
|
@ -1212,7 +1212,7 @@ func_decl * label_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
|
|||
|
||||
sort * pattern_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * pattern_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
|
@ -1230,7 +1230,7 @@ func_decl * pattern_decl_plugin::mk_func_decl(decl_kind k, unsigned num_paramete
|
|||
|
||||
sort * model_value_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * model_value_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
|
@ -1239,7 +1239,7 @@ func_decl * model_value_decl_plugin::mk_func_decl(decl_kind k, unsigned num_para
|
|||
if (arity != 0 || num_parameters != 2 || !parameters[0].is_int() || !parameters[1].is_ast() || !is_sort(parameters[1].get_ast())) {
|
||||
UNREACHABLE();
|
||||
m_manager->raise_exception("invalid model value");
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
int idx = parameters[0].get_int();
|
||||
sort * s = to_sort(parameters[1].get_ast());
|
||||
|
@ -1247,7 +1247,7 @@ func_decl * model_value_decl_plugin::mk_func_decl(decl_kind k, unsigned num_para
|
|||
buffer << s->get_name().bare_str() << "!val!" << idx;
|
||||
func_decl_info info(m_family_id, k, num_parameters, parameters);
|
||||
info.m_private_parameters = true;
|
||||
return m_manager->mk_func_decl(symbol(buffer.c_str()), 0, static_cast<sort * const *>(0), s, info);
|
||||
return m_manager->mk_func_decl(symbol(buffer.c_str()), 0, static_cast<sort * const *>(nullptr), s, info);
|
||||
}
|
||||
|
||||
bool model_value_decl_plugin::is_value(app* n) const {
|
||||
|
@ -1274,7 +1274,7 @@ sort * user_sort_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter
|
|||
func_decl * user_sort_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range) {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
decl_kind user_sort_plugin::register_name(symbol s) {
|
||||
|
@ -1289,7 +1289,7 @@ decl_kind user_sort_plugin::register_name(symbol s) {
|
|||
|
||||
decl_plugin * user_sort_plugin::mk_fresh() {
|
||||
user_sort_plugin * p = alloc(user_sort_plugin);
|
||||
for (symbol const& s : m_sort_names)
|
||||
for (symbol const& s : m_sort_names)
|
||||
p->register_name(s);
|
||||
return p;
|
||||
}
|
||||
|
@ -1307,7 +1307,7 @@ ast_manager::ast_manager(proof_gen_mode m, char const * trace_file, bool is_form
|
|||
m_expr_dependency_manager(*this, m_alloc),
|
||||
m_expr_dependency_array_manager(*this, m_alloc),
|
||||
m_proof_mode(m),
|
||||
m_trace_stream(0),
|
||||
m_trace_stream(nullptr),
|
||||
m_trace_stream_owner(false),
|
||||
m_rec_fun(":rec-fun") {
|
||||
|
||||
|
@ -1319,7 +1319,7 @@ ast_manager::ast_manager(proof_gen_mode m, char const * trace_file, bool is_form
|
|||
if (!is_format_manager)
|
||||
m_format_manager = alloc(ast_manager, PGM_DISABLED, m_trace_stream, true);
|
||||
else
|
||||
m_format_manager = 0;
|
||||
m_format_manager = nullptr;
|
||||
init();
|
||||
}
|
||||
|
||||
|
@ -1336,7 +1336,7 @@ ast_manager::ast_manager(proof_gen_mode m, std::fstream * trace_stream, bool is_
|
|||
if (!is_format_manager)
|
||||
m_format_manager = alloc(ast_manager, PGM_DISABLED, trace_stream, true);
|
||||
else
|
||||
m_format_manager = 0;
|
||||
m_format_manager = nullptr;
|
||||
init();
|
||||
}
|
||||
|
||||
|
@ -1361,7 +1361,7 @@ void ast_manager::init() {
|
|||
m_fresh_id = 0;
|
||||
m_expr_id_gen.reset(0);
|
||||
m_decl_id_gen.reset(c_first_decl_id);
|
||||
m_some_value_proc = 0;
|
||||
m_some_value_proc = nullptr;
|
||||
m_basic_family_id = mk_family_id("basic");
|
||||
m_label_family_id = mk_family_id("label");
|
||||
m_pattern_family_id = mk_family_id("pattern");
|
||||
|
@ -1415,7 +1415,7 @@ ast_manager::~ast_manager() {
|
|||
p->finalize();
|
||||
}
|
||||
for (decl_plugin* p : m_plugins) {
|
||||
if (p)
|
||||
if (p)
|
||||
dealloc(p);
|
||||
}
|
||||
m_plugins.reset();
|
||||
|
@ -1427,14 +1427,14 @@ ast_manager::~ast_manager() {
|
|||
switch (n->get_kind()) {
|
||||
case AST_SORT: {
|
||||
sort_info* info = to_sort(n)->get_info();
|
||||
if (info != 0) {
|
||||
if (info != nullptr) {
|
||||
mark_array_ref(mark, info->get_num_parameters(), info->get_parameters());
|
||||
}
|
||||
break;
|
||||
}
|
||||
case AST_FUNC_DECL: {
|
||||
func_decl_info* info = to_func_decl(n)->get_info();
|
||||
if (info != 0) {
|
||||
if (info != nullptr) {
|
||||
mark_array_ref(mark, info->get_num_parameters(), info->get_parameters());
|
||||
}
|
||||
mark_array_ref(mark, to_func_decl(n)->get_arity(), to_func_decl(n)->get_domain());
|
||||
|
@ -1454,13 +1454,13 @@ ast_manager::~ast_manager() {
|
|||
mark_array_ref(mark, to_quantifier(n)->get_num_patterns(), to_quantifier(n)->get_patterns());
|
||||
mark_array_ref(mark, to_quantifier(n)->get_num_no_patterns(), to_quantifier(n)->get_no_patterns());
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (ast * n : m_ast_table) {
|
||||
if (!mark.is_marked(n)) {
|
||||
roots.push_back(n);
|
||||
}
|
||||
}
|
||||
}
|
||||
SASSERT(!roots.empty());
|
||||
for (unsigned i = 0; i < roots.size(); ++i) {
|
||||
ast* a = roots[i];
|
||||
|
@ -1476,14 +1476,14 @@ ast_manager::~ast_manager() {
|
|||
delete_node(a);
|
||||
}
|
||||
}
|
||||
if (m_format_manager != 0)
|
||||
if (m_format_manager != nullptr)
|
||||
dealloc(m_format_manager);
|
||||
if (m_trace_stream_owner) {
|
||||
std::fstream & tmp = * m_trace_stream;
|
||||
tmp << "[eof]\n";
|
||||
tmp.close();
|
||||
dealloc(m_trace_stream);
|
||||
m_trace_stream = 0;
|
||||
m_trace_stream = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1492,11 +1492,8 @@ void ast_manager::compact_memory() {
|
|||
unsigned capacity = m_ast_table.capacity();
|
||||
if (capacity > 4*m_ast_table.size()) {
|
||||
ast_table new_ast_table;
|
||||
ast_table::iterator it = m_ast_table.begin();
|
||||
ast_table::iterator end = m_ast_table.end();
|
||||
for (; it != end; ++it) {
|
||||
new_ast_table.insert(*it);
|
||||
}
|
||||
for (ast* curr : m_ast_table)
|
||||
new_ast_table.insert(curr);
|
||||
m_ast_table.swap(new_ast_table);
|
||||
IF_VERBOSE(10, verbose_stream() << "(ast-table :prev-capacity " << capacity
|
||||
<< " :capacity " << m_ast_table.capacity() << " :size " << m_ast_table.size() << ")\n";);
|
||||
|
@ -1510,10 +1507,7 @@ void ast_manager::compress_ids() {
|
|||
ptr_vector<ast> asts;
|
||||
m_expr_id_gen.cleanup();
|
||||
m_decl_id_gen.cleanup(c_first_decl_id);
|
||||
ast_table::iterator it = m_ast_table.begin();
|
||||
ast_table::iterator end = m_ast_table.end();
|
||||
for (; it != end; ++it) {
|
||||
ast * n = *it;
|
||||
for (ast * n : m_ast_table) {
|
||||
if (is_decl(n))
|
||||
n->m_id = m_decl_id_gen.mk();
|
||||
else
|
||||
|
@ -1521,10 +1515,8 @@ void ast_manager::compress_ids() {
|
|||
asts.push_back(n);
|
||||
}
|
||||
m_ast_table.finalize();
|
||||
ptr_vector<ast>::iterator it2 = asts.begin();
|
||||
ptr_vector<ast>::iterator end2 = asts.end();
|
||||
for (; it2 != end2; ++it2)
|
||||
m_ast_table.insert(*it2);
|
||||
for (ast* a : asts)
|
||||
m_ast_table.insert(a);
|
||||
}
|
||||
|
||||
void ast_manager::raise_exception(char const * msg) {
|
||||
|
@ -1540,6 +1532,17 @@ void ast_manager::copy_families_plugins(ast_manager const & from) {
|
|||
tout << "fid: " << fid << " fidname: " << get_family_name(fid) << "\n";
|
||||
});
|
||||
ast_translation trans(const_cast<ast_manager&>(from), *this, false);
|
||||
// Inheriting plugins can create new family ids. Since new family ids are
|
||||
// assigned in the order that they are created, this can result in differing
|
||||
// family ids. To avoid this, we first assign all family ids and only then inherit plugins.
|
||||
for (family_id fid = 0; from.m_family_manager.has_family(fid); fid++) {
|
||||
symbol fid_name = from.get_family_name(fid);
|
||||
if (!m_family_manager.has_family(fid)) {
|
||||
family_id new_fid = mk_family_id(fid_name);
|
||||
(void)new_fid;
|
||||
TRACE("copy_families_plugins", tout << "new target fid created: " << new_fid << " fid_name: " << fid_name << "\n";);
|
||||
}
|
||||
}
|
||||
for (family_id fid = 0; from.m_family_manager.has_family(fid); fid++) {
|
||||
SASSERT(from.is_builtin_family_id(fid) == is_builtin_family_id(fid));
|
||||
SASSERT(!from.is_builtin_family_id(fid) || m_family_manager.has_family(fid));
|
||||
|
@ -1547,11 +1550,6 @@ void ast_manager::copy_families_plugins(ast_manager const & from) {
|
|||
TRACE("copy_families_plugins", tout << "copying: " << fid_name << ", src fid: " << fid
|
||||
<< ", target has_family: " << m_family_manager.has_family(fid) << "\n";
|
||||
if (m_family_manager.has_family(fid)) tout << get_family_id(fid_name) << "\n";);
|
||||
if (!m_family_manager.has_family(fid)) {
|
||||
family_id new_fid = mk_family_id(fid_name);
|
||||
(void)new_fid;
|
||||
TRACE("copy_families_plugins", tout << "new target fid created: " << new_fid << " fid_name: " << fid_name << "\n";);
|
||||
}
|
||||
TRACE("copy_families_plugins", tout << "target fid: " << get_family_id(fid_name) << "\n";);
|
||||
SASSERT(fid == get_family_id(fid_name));
|
||||
if (from.has_plugin(fid) && !has_plugin(fid)) {
|
||||
|
@ -1570,20 +1568,15 @@ void ast_manager::copy_families_plugins(ast_manager const & from) {
|
|||
}
|
||||
|
||||
void ast_manager::set_next_expr_id(unsigned id) {
|
||||
while (true) {
|
||||
id = m_expr_id_gen.set_next_id(id);
|
||||
ast_table::iterator it = m_ast_table.begin();
|
||||
ast_table::iterator end = m_ast_table.end();
|
||||
for (; it != end; ++it) {
|
||||
ast * curr = *it;
|
||||
if (curr->get_id() == id)
|
||||
break;
|
||||
try_again:
|
||||
id = m_expr_id_gen.set_next_id(id);
|
||||
for (ast * curr : m_ast_table) {
|
||||
if (curr->get_id() == id) {
|
||||
// id is in use, move to the next one.
|
||||
++id;
|
||||
goto try_again;
|
||||
}
|
||||
if (it == end)
|
||||
return;
|
||||
// id is in use, move to the next one.
|
||||
id++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsigned ast_manager::get_node_size(ast const * n) { return ::get_node_size(n); }
|
||||
|
@ -1600,7 +1593,7 @@ decl_plugin * ast_manager::get_plugin(family_id fid) const {
|
|||
|
||||
|
||||
bool ast_manager::is_value(expr* e) const {
|
||||
decl_plugin const * p = 0;
|
||||
decl_plugin const * p = nullptr;
|
||||
if (is_app(e)) {
|
||||
p = get_plugin(to_app(e)->get_family_id());
|
||||
return p && p->is_value(to_app(e));
|
||||
|
@ -1609,7 +1602,7 @@ bool ast_manager::is_value(expr* e) const {
|
|||
}
|
||||
|
||||
bool ast_manager::is_unique_value(expr* e) const {
|
||||
decl_plugin const * p = 0;
|
||||
decl_plugin const * p = nullptr;
|
||||
if (is_app(e)) {
|
||||
p = get_plugin(to_app(e)->get_family_id());
|
||||
return p && p->is_unique_value(to_app(e));
|
||||
|
@ -1683,7 +1676,7 @@ ast * ast_manager::register_node_core(ast * n) {
|
|||
bool contains = m_ast_table.contains(n);
|
||||
CASSERT("nondet_bug", contains || slow_not_contains(n));
|
||||
#endif
|
||||
|
||||
|
||||
ast * r = m_ast_table.insert_if_not_there(n);
|
||||
SASSERT(r->m_hash == h);
|
||||
if (r != n) {
|
||||
|
@ -1711,13 +1704,13 @@ ast * ast_manager::register_node_core(ast * n) {
|
|||
// increment reference counters
|
||||
switch (n->get_kind()) {
|
||||
case AST_SORT:
|
||||
if (to_sort(n)->m_info != 0) {
|
||||
if (to_sort(n)->m_info != nullptr) {
|
||||
to_sort(n)->m_info = alloc(sort_info, *(to_sort(n)->get_info()));
|
||||
to_sort(n)->m_info->init_eh(*this);
|
||||
}
|
||||
break;
|
||||
case AST_FUNC_DECL:
|
||||
if (to_func_decl(n)->m_info != 0) {
|
||||
if (to_func_decl(n)->m_info != nullptr) {
|
||||
to_func_decl(n)->m_info = alloc(func_decl_info, *(to_func_decl(n)->get_info()));
|
||||
to_func_decl(n)->m_info->init_eh(*this);
|
||||
}
|
||||
|
@ -1820,14 +1813,14 @@ void ast_manager::delete_node(ast * n) {
|
|||
#endif
|
||||
switch (n->get_kind()) {
|
||||
case AST_SORT:
|
||||
if (to_sort(n)->m_info != 0 && !m_debug_ref_count) {
|
||||
if (to_sort(n)->m_info != nullptr && !m_debug_ref_count) {
|
||||
sort_info * info = to_sort(n)->get_info();
|
||||
info->del_eh(*this);
|
||||
dealloc(info);
|
||||
}
|
||||
break;
|
||||
case AST_FUNC_DECL:
|
||||
if (to_func_decl(n)->m_info != 0 && !m_debug_ref_count) {
|
||||
if (to_func_decl(n)->m_info != nullptr && !m_debug_ref_count) {
|
||||
func_decl_info * info = to_func_decl(n)->get_info();
|
||||
info->del_eh(*this);
|
||||
dealloc(info);
|
||||
|
@ -1862,7 +1855,7 @@ sort * ast_manager::mk_sort(family_id fid, decl_kind k, unsigned num_parameters,
|
|||
decl_plugin * p = get_plugin(fid);
|
||||
if (p)
|
||||
return p->mk_sort(k, num_parameters, parameters);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * ast_manager::mk_func_decl(family_id fid, decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
|
@ -1870,7 +1863,7 @@ func_decl * ast_manager::mk_func_decl(family_id fid, decl_kind k, unsigned num_p
|
|||
decl_plugin * p = get_plugin(fid);
|
||||
if (p)
|
||||
return p->mk_func_decl(k, num_parameters, parameters, arity, domain, range);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
func_decl * ast_manager::mk_func_decl(family_id fid, decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
|
@ -1878,33 +1871,33 @@ func_decl * ast_manager::mk_func_decl(family_id fid, decl_kind k, unsigned num_p
|
|||
decl_plugin * p = get_plugin(fid);
|
||||
if (p)
|
||||
return p->mk_func_decl(k, num_parameters, parameters, num_args, args, range);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
app * ast_manager::mk_app(family_id fid, decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned num_args, expr * const * args, sort * range) {
|
||||
func_decl * decl = mk_func_decl(fid, k, num_parameters, parameters, num_args, args, range);
|
||||
if (decl != 0)
|
||||
if (decl != nullptr)
|
||||
return mk_app(decl, num_args, args);
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
app * ast_manager::mk_app(family_id fid, decl_kind k, unsigned num_args, expr * const * args) {
|
||||
return mk_app(fid, k, 0, 0, num_args, args);
|
||||
return mk_app(fid, k, 0, nullptr, num_args, args);
|
||||
}
|
||||
|
||||
app * ast_manager::mk_app(family_id fid, decl_kind k, expr * arg) {
|
||||
return mk_app(fid, k, 0, 0, 1, &arg);
|
||||
return mk_app(fid, k, 0, nullptr, 1, &arg);
|
||||
}
|
||||
|
||||
app * ast_manager::mk_app(family_id fid, decl_kind k, expr * arg1, expr * arg2) {
|
||||
expr * args[2] = { arg1, arg2 };
|
||||
return mk_app(fid, k, 0, 0, 2, args);
|
||||
return mk_app(fid, k, 0, nullptr, 2, args);
|
||||
}
|
||||
|
||||
app * ast_manager::mk_app(family_id fid, decl_kind k, expr * arg1, expr * arg2, expr * arg3) {
|
||||
expr * args[3] = { arg1, arg2, arg3 };
|
||||
return mk_app(fid, k, 0, 0, 3, args);
|
||||
return mk_app(fid, k, 0, nullptr, 3, args);
|
||||
}
|
||||
|
||||
sort * ast_manager::mk_sort(symbol const & name, sort_info * info) {
|
||||
|
@ -2075,8 +2068,8 @@ bool ast_manager::coercion_needed(func_decl * decl, unsigned num_args, expr * co
|
|||
}
|
||||
|
||||
app * ast_manager::mk_app_core(func_decl * decl, unsigned num_args, expr * const * args) {
|
||||
app * r = 0;
|
||||
app * new_node = 0;
|
||||
app * r = nullptr;
|
||||
app * new_node = nullptr;
|
||||
unsigned sz = app::get_obj_size(num_args);
|
||||
void * mem = allocate_node(sz);
|
||||
|
||||
|
@ -2184,7 +2177,7 @@ app * ast_manager::mk_app(func_decl * decl, unsigned num_args, expr * const * ar
|
|||
<< ") passed to function " << mk_pp(decl, *this);
|
||||
throw ast_exception(buffer.str().c_str());
|
||||
}
|
||||
app * r = 0;
|
||||
app * r = nullptr;
|
||||
if (num_args == 1 && decl->is_chainable() && decl->get_arity() == 2) {
|
||||
r = mk_true();
|
||||
}
|
||||
|
@ -2213,7 +2206,7 @@ app * ast_manager::mk_app(func_decl * decl, unsigned num_args, expr * const * ar
|
|||
r = mk_and(new_args.size(), new_args.c_ptr());
|
||||
}
|
||||
}
|
||||
if (r == 0) {
|
||||
if (r == nullptr) {
|
||||
r = mk_app_core(decl, num_args, args);
|
||||
}
|
||||
SASSERT(r != 0);
|
||||
|
@ -2300,7 +2293,7 @@ app * ast_manager::mk_label_lit(unsigned num_names, symbol const * names) {
|
|||
buffer<parameter> p;
|
||||
for (unsigned i = 0; i < num_names; i++)
|
||||
p.push_back(parameter(names[i]));
|
||||
return mk_app(m_label_family_id, OP_LABEL_LIT, p.size(), p.c_ptr(), 0, 0);
|
||||
return mk_app(m_label_family_id, OP_LABEL_LIT, p.size(), p.c_ptr(), 0, nullptr);
|
||||
}
|
||||
|
||||
app * ast_manager::mk_label_lit(symbol const & name) {
|
||||
|
@ -2322,7 +2315,7 @@ app * ast_manager::mk_pattern(unsigned num_exprs, app * const * exprs) {
|
|||
for (unsigned i = 0; i < num_exprs; ++i) {
|
||||
SASSERT(is_app(exprs[i]));
|
||||
}});
|
||||
return mk_app(m_pattern_family_id, OP_PATTERN, 0, 0, num_exprs, (expr*const*)exprs);
|
||||
return mk_app(m_pattern_family_id, OP_PATTERN, 0, nullptr, num_exprs, (expr*const*)exprs);
|
||||
}
|
||||
|
||||
bool ast_manager::is_pattern(expr const * n) const {
|
||||
|
@ -2358,8 +2351,9 @@ quantifier * ast_manager::mk_quantifier(bool forall, unsigned num_decls, sort *
|
|||
unsigned num_patterns, expr * const * patterns,
|
||||
unsigned num_no_patterns, expr * const * no_patterns) {
|
||||
SASSERT(body);
|
||||
SASSERT(num_patterns == 0 || num_no_patterns == 0);
|
||||
SASSERT(num_decls > 0);
|
||||
if (num_patterns != 0 && num_no_patterns != 0)
|
||||
throw ast_exception("simultaneous patterns and no-patterns not supported");
|
||||
DEBUG_CODE({
|
||||
for (unsigned i = 0; i < num_patterns; ++i) {
|
||||
TRACE("ast", tout << i << " " << mk_pp(patterns[i], *this) << "\n";);
|
||||
|
@ -2418,7 +2412,7 @@ quantifier * ast_manager::update_quantifier(quantifier * q, unsigned num_pattern
|
|||
num_patterns,
|
||||
patterns,
|
||||
num_patterns == 0 ? q->get_num_no_patterns() : 0,
|
||||
num_patterns == 0 ? q->get_no_patterns() : 0);
|
||||
num_patterns == 0 ? q->get_no_patterns() : nullptr);
|
||||
}
|
||||
|
||||
quantifier * ast_manager::update_quantifier(quantifier * q, unsigned num_patterns, expr * const * patterns, unsigned num_no_patterns, expr * const * no_patterns, expr * body) {
|
||||
|
@ -2504,7 +2498,7 @@ quantifier * ast_manager::update_quantifier(quantifier * q, bool is_forall, unsi
|
|||
num_patterns,
|
||||
patterns,
|
||||
num_patterns == 0 ? q->get_num_no_patterns() : 0,
|
||||
num_patterns == 0 ? q->get_no_patterns() : 0);
|
||||
num_patterns == 0 ? q->get_no_patterns() : nullptr);
|
||||
}
|
||||
|
||||
app * ast_manager::mk_distinct(unsigned num_args, expr * const * args) {
|
||||
|
@ -2536,14 +2530,14 @@ app * ast_manager::mk_distinct_expanded(unsigned num_args, expr * const * args)
|
|||
// -----------------------------------
|
||||
|
||||
expr_dependency * ast_manager::mk_leaf(expr * t) {
|
||||
if (t == 0)
|
||||
return 0;
|
||||
if (t == nullptr)
|
||||
return nullptr;
|
||||
else
|
||||
return m_expr_dependency_manager.mk_leaf(t);
|
||||
}
|
||||
|
||||
expr_dependency * ast_manager::mk_join(unsigned n, expr * const * ts) {
|
||||
expr_dependency * d = 0;
|
||||
expr_dependency * d = nullptr;
|
||||
for (unsigned i = 0; i < n; i++)
|
||||
d = mk_join(d, mk_leaf(ts[i]));
|
||||
return d;
|
||||
|
@ -2562,7 +2556,7 @@ void ast_manager::linearize(expr_dependency * d, ptr_vector<expr> & ts) {
|
|||
|
||||
app * ast_manager::mk_model_value(unsigned idx, sort * s) {
|
||||
parameter p[2] = { parameter(idx), parameter(s) };
|
||||
return mk_app(m_model_value_family_id, OP_MODEL_VALUE, 2, p, 0, static_cast<expr * const *>(0));
|
||||
return mk_app(m_model_value_family_id, OP_MODEL_VALUE, 2, p, 0, static_cast<expr * const *>(nullptr));
|
||||
}
|
||||
|
||||
expr * ast_manager::get_some_value(sort * s, some_value_proc * p) {
|
||||
|
@ -2571,17 +2565,17 @@ expr * ast_manager::get_some_value(sort * s, some_value_proc * p) {
|
|||
}
|
||||
|
||||
expr * ast_manager::get_some_value(sort * s) {
|
||||
expr * v = 0;
|
||||
expr * v = nullptr;
|
||||
if (m_some_value_proc)
|
||||
v = (*m_some_value_proc)(s);
|
||||
if (v != 0)
|
||||
if (v != nullptr)
|
||||
return v;
|
||||
family_id fid = s->get_family_id();
|
||||
if (fid != null_family_id) {
|
||||
decl_plugin * p = get_plugin(fid);
|
||||
if (p != 0) {
|
||||
if (p != nullptr) {
|
||||
v = p->get_some_value(s);
|
||||
if (v != 0)
|
||||
if (v != nullptr)
|
||||
return v;
|
||||
}
|
||||
}
|
||||
|
@ -2594,7 +2588,7 @@ bool ast_manager::is_fully_interp(sort * s) const {
|
|||
family_id fid = s->get_family_id();
|
||||
SASSERT(fid != null_family_id);
|
||||
decl_plugin * p = get_plugin(fid);
|
||||
if (p != 0)
|
||||
if (p != nullptr)
|
||||
return p->is_fully_interp(s);
|
||||
return false;
|
||||
}
|
||||
|
@ -2763,7 +2757,7 @@ proof * ast_manager::mk_transitivity(unsigned num_proofs, proof * const * proofs
|
|||
}
|
||||
|
||||
proof * ast_manager::mk_transitivity(unsigned num_proofs, proof * const * proofs, expr * n1, expr * n2) {
|
||||
if (num_proofs == 0)
|
||||
if (num_proofs == 0)
|
||||
return nullptr;
|
||||
if (num_proofs == 1)
|
||||
return proofs[0];
|
||||
|
@ -2792,14 +2786,14 @@ proof * ast_manager::mk_congruence(app * f1, app * f2, unsigned num_proofs, proo
|
|||
SASSERT(get_sort(f1) == get_sort(f2));
|
||||
sort * s = get_sort(f1);
|
||||
sort * d[2] = { s, s };
|
||||
return mk_monotonicity(mk_func_decl(m_basic_family_id, get_eq_op(f1), 0, 0, 2, d), f1, f2, num_proofs, proofs);
|
||||
return mk_monotonicity(mk_func_decl(m_basic_family_id, get_eq_op(f1), 0, nullptr, 2, d), f1, f2, num_proofs, proofs);
|
||||
}
|
||||
|
||||
proof * ast_manager::mk_oeq_congruence(app * f1, app * f2, unsigned num_proofs, proof * const * proofs) {
|
||||
SASSERT(get_sort(f1) == get_sort(f2));
|
||||
sort * s = get_sort(f1);
|
||||
sort * d[2] = { s, s };
|
||||
return mk_monotonicity(mk_func_decl(m_basic_family_id, OP_OEQ, 0, 0, 2, d), f1, f2, num_proofs, proofs);
|
||||
return mk_monotonicity(mk_func_decl(m_basic_family_id, OP_OEQ, 0, nullptr, 2, d), f1, f2, num_proofs, proofs);
|
||||
}
|
||||
|
||||
proof * ast_manager::mk_quant_intro(quantifier * q1, quantifier * q2, proof * p) {
|
||||
|
|
202
src/ast/ast.h
202
src/ast/ast.h
|
@ -53,6 +53,12 @@ Revision History:
|
|||
#pragma warning(disable : 4355)
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# define Z3_NORETURN __declspec(noreturn)
|
||||
#else
|
||||
# define Z3_NORETURN [[noreturn]]
|
||||
#endif
|
||||
|
||||
class ast;
|
||||
class ast_manager;
|
||||
|
||||
|
@ -126,7 +132,7 @@ public:
|
|||
case PARAM_INT: m_int = other.get_int(); break;
|
||||
case PARAM_AST: m_ast = other.get_ast(); break;
|
||||
case PARAM_SYMBOL: m_symbol = other.m_symbol; break;
|
||||
case PARAM_RATIONAL: m_rational = 0; std::swap(m_rational, other.m_rational); break;
|
||||
case PARAM_RATIONAL: m_rational = nullptr; std::swap(m_rational, other.m_rational); break;
|
||||
case PARAM_DOUBLE: m_dval = other.m_dval; break;
|
||||
case PARAM_EXTERNAL: m_ext_id = other.m_ext_id; break;
|
||||
default:
|
||||
|
@ -252,7 +258,7 @@ class decl_info {
|
|||
public:
|
||||
bool m_private_parameters;
|
||||
decl_info(family_id family_id = null_family_id, decl_kind k = null_decl_kind,
|
||||
unsigned num_parameters = 0, parameter const * parameters = 0, bool private_params = false);
|
||||
unsigned num_parameters = 0, parameter const * parameters = nullptr, bool private_params = false);
|
||||
|
||||
decl_info(decl_info const& other);
|
||||
~decl_info() {}
|
||||
|
@ -330,23 +336,23 @@ std::ostream& operator<<(std::ostream& out, sort_size const & ss);
|
|||
// -----------------------------------
|
||||
|
||||
/**
|
||||
\brief Extra information that may be attached to intepreted sorts.
|
||||
\brief Extra information that may be attached to interpreted sorts.
|
||||
*/
|
||||
class sort_info : public decl_info {
|
||||
sort_size m_num_elements;
|
||||
public:
|
||||
sort_info(family_id family_id = null_family_id, decl_kind k = null_decl_kind,
|
||||
unsigned num_parameters = 0, parameter const * parameters = 0, bool private_parameters = false):
|
||||
unsigned num_parameters = 0, parameter const * parameters = nullptr, bool private_parameters = false):
|
||||
decl_info(family_id, k, num_parameters, parameters, private_parameters) {
|
||||
}
|
||||
|
||||
sort_info(family_id family_id, decl_kind k, uint64 num_elements,
|
||||
unsigned num_parameters = 0, parameter const * parameters = 0, bool private_parameters = false):
|
||||
unsigned num_parameters = 0, parameter const * parameters = nullptr, bool private_parameters = false):
|
||||
decl_info(family_id, k, num_parameters, parameters, private_parameters), m_num_elements(num_elements) {
|
||||
}
|
||||
|
||||
sort_info(family_id family_id, decl_kind k, sort_size const& num_elements,
|
||||
unsigned num_parameters = 0, parameter const * parameters = 0, bool private_parameters = false):
|
||||
unsigned num_parameters = 0, parameter const * parameters = nullptr, bool private_parameters = false):
|
||||
decl_info(family_id, k, num_parameters, parameters, private_parameters), m_num_elements(num_elements) {
|
||||
}
|
||||
sort_info(sort_info const& other) : decl_info(other), m_num_elements(other.m_num_elements) {
|
||||
|
@ -384,7 +390,7 @@ struct func_decl_info : public decl_info {
|
|||
bool m_idempotent:1;
|
||||
bool m_skolem:1;
|
||||
|
||||
func_decl_info(family_id family_id = null_family_id, decl_kind k = null_decl_kind, unsigned num_parameters = 0, parameter const * parameters = 0);
|
||||
func_decl_info(family_id family_id = null_family_id, decl_kind k = null_decl_kind, unsigned num_parameters = 0, parameter const * parameters = nullptr);
|
||||
~func_decl_info() {}
|
||||
|
||||
bool is_associative() const { return m_left_assoc && m_right_assoc; }
|
||||
|
@ -559,12 +565,12 @@ public:
|
|||
unsigned get_decl_id() const { SASSERT(get_id() >= c_first_decl_id); return get_id() - c_first_decl_id; }
|
||||
symbol const & get_name() const { return m_name; }
|
||||
decl_info * get_info() const { return m_info; }
|
||||
family_id get_family_id() const { return m_info == 0 ? null_family_id : m_info->get_family_id(); }
|
||||
decl_kind get_decl_kind() const { return m_info == 0 ? null_decl_kind : m_info->get_decl_kind(); }
|
||||
unsigned get_num_parameters() const { return m_info == 0 ? 0 : m_info->get_num_parameters(); }
|
||||
family_id get_family_id() const { return m_info == nullptr ? null_family_id : m_info->get_family_id(); }
|
||||
decl_kind get_decl_kind() const { return m_info == nullptr ? null_decl_kind : m_info->get_decl_kind(); }
|
||||
unsigned get_num_parameters() const { return m_info == nullptr ? 0 : m_info->get_num_parameters(); }
|
||||
parameter const & get_parameter(unsigned idx) const { return m_info->get_parameter(idx); }
|
||||
parameter const * get_parameters() const { return m_info == 0 ? 0 : m_info->get_parameters(); }
|
||||
bool private_parameters() const { return m_info != 0 && m_info->private_parameters(); }
|
||||
parameter const * get_parameters() const { return m_info == nullptr ? nullptr : m_info->get_parameters(); }
|
||||
bool private_parameters() const { return m_info != nullptr && m_info->private_parameters(); }
|
||||
};
|
||||
|
||||
// -----------------------------------
|
||||
|
@ -581,8 +587,8 @@ class sort : public decl {
|
|||
sort(symbol const & name, sort_info * info):decl(AST_SORT, name, info) {}
|
||||
public:
|
||||
sort_info * get_info() const { return static_cast<sort_info*>(m_info); }
|
||||
bool is_infinite() const { return get_info() == 0 || get_info()->is_infinite(); }
|
||||
bool is_very_big() const { return get_info() == 0 || get_info()->is_very_big(); }
|
||||
bool is_infinite() const { return get_info() == nullptr || get_info()->is_infinite(); }
|
||||
bool is_very_big() const { return get_info() == nullptr || get_info()->is_very_big(); }
|
||||
bool is_sort_of(family_id fid, decl_kind k) const { return get_family_id() == fid && get_decl_kind() == k; }
|
||||
sort_size const & get_num_elements() const { return get_info()->get_num_elements(); }
|
||||
void set_num_elements(sort_size const& s) { get_info()->set_num_elements(s); }
|
||||
|
@ -607,16 +613,16 @@ class func_decl : public decl {
|
|||
func_decl(symbol const & name, unsigned arity, sort * const * domain, sort * range, func_decl_info * info);
|
||||
public:
|
||||
func_decl_info * get_info() const { return static_cast<func_decl_info*>(m_info); }
|
||||
bool is_associative() const { return get_info() != 0 && get_info()->is_associative(); }
|
||||
bool is_left_associative() const { return get_info() != 0 && get_info()->is_left_associative(); }
|
||||
bool is_right_associative() const { return get_info() != 0 && get_info()->is_right_associative(); }
|
||||
bool is_flat_associative() const { return get_info() != 0 && get_info()->is_flat_associative(); }
|
||||
bool is_commutative() const { return get_info() != 0 && get_info()->is_commutative(); }
|
||||
bool is_chainable() const { return get_info() != 0 && get_info()->is_chainable(); }
|
||||
bool is_pairwise() const { return get_info() != 0 && get_info()->is_pairwise(); }
|
||||
bool is_injective() const { return get_info() != 0 && get_info()->is_injective(); }
|
||||
bool is_skolem() const { return get_info() != 0 && get_info()->is_skolem(); }
|
||||
bool is_idempotent() const { return get_info() != 0 && get_info()->is_idempotent(); }
|
||||
bool is_associative() const { return get_info() != nullptr && get_info()->is_associative(); }
|
||||
bool is_left_associative() const { return get_info() != nullptr && get_info()->is_left_associative(); }
|
||||
bool is_right_associative() const { return get_info() != nullptr && get_info()->is_right_associative(); }
|
||||
bool is_flat_associative() const { return get_info() != nullptr && get_info()->is_flat_associative(); }
|
||||
bool is_commutative() const { return get_info() != nullptr && get_info()->is_commutative(); }
|
||||
bool is_chainable() const { return get_info() != nullptr && get_info()->is_chainable(); }
|
||||
bool is_pairwise() const { return get_info() != nullptr && get_info()->is_pairwise(); }
|
||||
bool is_injective() const { return get_info() != nullptr && get_info()->is_injective(); }
|
||||
bool is_skolem() const { return get_info() != nullptr && get_info()->is_skolem(); }
|
||||
bool is_idempotent() const { return get_info() != nullptr && get_info()->is_idempotent(); }
|
||||
unsigned get_arity() const { return m_arity; }
|
||||
sort * get_domain(unsigned idx) const { SASSERT(idx < get_arity()); return m_domain[idx]; }
|
||||
sort * const * get_domain() const { return m_domain; }
|
||||
|
@ -932,7 +938,7 @@ struct builtin_name {
|
|||
};
|
||||
|
||||
/**
|
||||
\brief Each family of intepreted function declarations and sorts must provide a plugin
|
||||
\brief Each family of interpreted function declarations and sorts must provide a plugin
|
||||
to build sorts and decls of the family.
|
||||
*/
|
||||
class decl_plugin {
|
||||
|
@ -951,7 +957,7 @@ protected:
|
|||
friend class ast_manager;
|
||||
|
||||
public:
|
||||
decl_plugin():m_manager(0), m_family_id(null_family_id) {}
|
||||
decl_plugin():m_manager(nullptr), m_family_id(null_family_id) {}
|
||||
|
||||
virtual ~decl_plugin() {}
|
||||
virtual void finalize() {}
|
||||
|
@ -1007,7 +1013,7 @@ public:
|
|||
|
||||
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic = symbol()) {}
|
||||
|
||||
virtual expr * get_some_value(sort * s) { return 0; }
|
||||
virtual expr * get_some_value(sort * s) { return nullptr; }
|
||||
|
||||
// Return true if the interpreted sort s does not depend on uninterpreted sorts.
|
||||
// This may be the case, for example, for array and datatype sorts.
|
||||
|
@ -1059,7 +1065,7 @@ protected:
|
|||
ptr_vector<func_decl> m_eq_decls; // cached eqs
|
||||
ptr_vector<func_decl> m_ite_decls; // cached ites
|
||||
|
||||
ptr_vector<func_decl> m_oeq_decls; // cached obsevational eqs
|
||||
ptr_vector<func_decl> m_oeq_decls; // cached observational eqs
|
||||
sort * m_proof_sort;
|
||||
func_decl * m_undef_decl;
|
||||
func_decl * m_true_pr_decl;
|
||||
|
@ -1123,7 +1129,7 @@ protected:
|
|||
unsigned num_parameters, parameter const* params, unsigned num_parents);
|
||||
|
||||
|
||||
virtual void set_manager(ast_manager * m, family_id id);
|
||||
void set_manager(ast_manager * m, family_id id) override;
|
||||
func_decl * mk_eq_decl_core(char const * name, decl_kind k, sort * s, ptr_vector<func_decl> & cache);
|
||||
func_decl * mk_ite_decl(sort * s);
|
||||
sort* join(sort* s1, sort* s2);
|
||||
|
@ -1132,36 +1138,36 @@ protected:
|
|||
public:
|
||||
basic_decl_plugin();
|
||||
|
||||
virtual ~basic_decl_plugin() {}
|
||||
virtual void finalize();
|
||||
~basic_decl_plugin() override {}
|
||||
void finalize() override;
|
||||
|
||||
virtual decl_plugin * mk_fresh() {
|
||||
decl_plugin * mk_fresh() override {
|
||||
return alloc(basic_decl_plugin);
|
||||
}
|
||||
|
||||
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const* parameters);
|
||||
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const* parameters) override;
|
||||
|
||||
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range);
|
||||
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range) override;
|
||||
|
||||
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned num_args, expr * const * args, sort * range);
|
||||
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned num_args, expr * const * args, sort * range) override;
|
||||
|
||||
virtual void get_op_names(svector<builtin_name> & op_names, symbol const & logic);
|
||||
void get_op_names(svector<builtin_name> & op_names, symbol const & logic) override;
|
||||
|
||||
virtual void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic);
|
||||
void get_sort_names(svector<builtin_name> & sort_names, symbol const & logic) override;
|
||||
|
||||
virtual bool is_value(app* a) const;
|
||||
bool is_value(app* a) const override;
|
||||
|
||||
virtual bool is_unique_value(app* a) const;
|
||||
bool is_unique_value(app* a) const override;
|
||||
|
||||
sort * mk_bool_sort() const { return m_bool_sort; }
|
||||
sort * mk_proof_sort() const { return m_proof_sort; }
|
||||
|
||||
virtual expr * get_some_value(sort * s);
|
||||
expr * get_some_value(sort * s) override;
|
||||
};
|
||||
|
||||
typedef app proof; /* a proof is just an applicaton */
|
||||
typedef app proof; /* a proof is just an application */
|
||||
|
||||
// -----------------------------------
|
||||
//
|
||||
|
@ -1182,15 +1188,15 @@ class label_decl_plugin : public decl_plugin {
|
|||
symbol m_lblneg;
|
||||
symbol m_lbllit;
|
||||
|
||||
virtual void set_manager(ast_manager * m, family_id id);
|
||||
void set_manager(ast_manager * m, family_id id) override;
|
||||
|
||||
public:
|
||||
label_decl_plugin();
|
||||
virtual ~label_decl_plugin();
|
||||
~label_decl_plugin() override;
|
||||
|
||||
virtual decl_plugin * mk_fresh() { return alloc(label_decl_plugin); }
|
||||
decl_plugin * mk_fresh() override { return alloc(label_decl_plugin); }
|
||||
|
||||
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
|
||||
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
|
||||
|
||||
/**
|
||||
contract: when label
|
||||
|
@ -1204,8 +1210,8 @@ public:
|
|||
...
|
||||
parameter[n-1] (symbol): label's tag.
|
||||
*/
|
||||
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range);
|
||||
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range) override;
|
||||
};
|
||||
|
||||
// -----------------------------------
|
||||
|
@ -1220,16 +1226,16 @@ enum pattern_op_kind {
|
|||
|
||||
/**
|
||||
\brief Patterns are used to group expressions. These expressions are using during E-matching for
|
||||
heurisitic quantifier instantiation.
|
||||
heuristic quantifier instantiation.
|
||||
*/
|
||||
class pattern_decl_plugin : public decl_plugin {
|
||||
public:
|
||||
virtual decl_plugin * mk_fresh() { return alloc(pattern_decl_plugin); }
|
||||
decl_plugin * mk_fresh() override { return alloc(pattern_decl_plugin); }
|
||||
|
||||
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
|
||||
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
|
||||
|
||||
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range);
|
||||
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range) override;
|
||||
};
|
||||
|
||||
// -----------------------------------
|
||||
|
@ -1245,33 +1251,33 @@ enum model_value_op_kind {
|
|||
/**
|
||||
\brief Values are used during model construction. All values are
|
||||
assumed to be different. Users should not use them, since they may
|
||||
introduce unsoundess if the sort of a value is finite.
|
||||
introduce unsoundness if the sort of a value is finite.
|
||||
|
||||
Moreover, values should never be internalized in a logical context.
|
||||
|
||||
However, values can be used during evaluation (i.e., simplification).
|
||||
|
||||
\remark Model values can be viewed as the partion ids in Z3 1.x.
|
||||
\remark Model values can be viewed as the partition ids in Z3 1.x.
|
||||
*/
|
||||
class model_value_decl_plugin : public decl_plugin {
|
||||
public:
|
||||
model_value_decl_plugin() {}
|
||||
|
||||
virtual decl_plugin * mk_fresh() { return alloc(model_value_decl_plugin); }
|
||||
decl_plugin * mk_fresh() override { return alloc(model_value_decl_plugin); }
|
||||
|
||||
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
|
||||
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
|
||||
|
||||
/**
|
||||
contract:
|
||||
parameter[0]: (integer) value idx
|
||||
parameter[1]: (ast) sort of the value.
|
||||
*/
|
||||
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range);
|
||||
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range) override;
|
||||
|
||||
virtual bool is_value(app* n) const;
|
||||
bool is_value(app* n) const override;
|
||||
|
||||
virtual bool is_unique_value(app* a) const;
|
||||
bool is_unique_value(app* a) const override;
|
||||
};
|
||||
|
||||
// -----------------------------------
|
||||
|
@ -1286,11 +1292,11 @@ class user_sort_plugin : public decl_plugin {
|
|||
public:
|
||||
user_sort_plugin() {}
|
||||
|
||||
virtual sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters);
|
||||
virtual func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range);
|
||||
sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override;
|
||||
func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range) override;
|
||||
decl_kind register_name(symbol s);
|
||||
virtual decl_plugin * mk_fresh();
|
||||
decl_plugin * mk_fresh() override;
|
||||
};
|
||||
|
||||
|
||||
|
@ -1491,14 +1497,14 @@ protected:
|
|||
|
||||
|
||||
public:
|
||||
ast_manager(proof_gen_mode = PGM_DISABLED, char const * trace_file = 0, bool is_format_manager = false);
|
||||
ast_manager(proof_gen_mode = PGM_DISABLED, char const * trace_file = nullptr, bool is_format_manager = false);
|
||||
ast_manager(proof_gen_mode, std::fstream * trace_stream, bool is_format_manager = false);
|
||||
ast_manager(ast_manager const & src, bool disable_proofs = false);
|
||||
~ast_manager();
|
||||
|
||||
// propagate cancellation signal to decl_plugins
|
||||
|
||||
bool has_trace_stream() const { return m_trace_stream != 0; }
|
||||
bool has_trace_stream() const { return m_trace_stream != nullptr; }
|
||||
std::ostream & trace_stream() { SASSERT(has_trace_stream()); return *m_trace_stream; }
|
||||
|
||||
void enable_int_real_coercions(bool f) { m_int_real_coercions = f; }
|
||||
|
@ -1515,9 +1521,9 @@ public:
|
|||
void compress_ids();
|
||||
|
||||
// Equivalent to throw ast_exception(msg)
|
||||
void raise_exception(char const * msg);
|
||||
Z3_NORETURN void raise_exception(char const * msg);
|
||||
|
||||
bool is_format_manager() const { return m_format_manager == 0; }
|
||||
bool is_format_manager() const { return m_format_manager == nullptr; }
|
||||
|
||||
ast_manager & get_format_manager() { return is_format_manager() ? *this : *m_format_manager; }
|
||||
|
||||
|
@ -1552,7 +1558,7 @@ public:
|
|||
|
||||
decl_plugin * get_plugin(family_id fid) const;
|
||||
|
||||
bool has_plugin(family_id fid) const { return get_plugin(fid) != 0; }
|
||||
bool has_plugin(family_id fid) const { return get_plugin(fid) != nullptr; }
|
||||
|
||||
bool has_plugin(symbol const & s) const { return m_family_manager.has_family(s) && has_plugin(m_family_manager.get_family_id(s)); }
|
||||
|
||||
|
@ -1664,7 +1670,7 @@ private:
|
|||
public:
|
||||
sort * mk_uninterpreted_sort(symbol const & name, unsigned num_parameters, parameter const * parameters);
|
||||
|
||||
sort * mk_uninterpreted_sort(symbol const & name) { return mk_uninterpreted_sort(name, 0, 0); }
|
||||
sort * mk_uninterpreted_sort(symbol const & name) { return mk_uninterpreted_sort(name, 0, nullptr); }
|
||||
|
||||
sort * mk_sort(symbol const & name, sort_info const & info) {
|
||||
if (info.get_family_id() == null_family_id) {
|
||||
|
@ -1675,7 +1681,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
sort * mk_sort(family_id fid, decl_kind k, unsigned num_parameters = 0, parameter const * parameters = 0);
|
||||
sort * mk_sort(family_id fid, decl_kind k, unsigned num_parameters = 0, parameter const * parameters = nullptr);
|
||||
|
||||
sort * substitute(sort* s, unsigned n, sort * const * src, sort * const * dst);
|
||||
|
||||
|
@ -1694,13 +1700,13 @@ public:
|
|||
bool is_fully_interp(sort * s) const;
|
||||
|
||||
func_decl * mk_func_decl(family_id fid, decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned arity, sort * const * domain, sort * range = 0);
|
||||
unsigned arity, sort * const * domain, sort * range = nullptr);
|
||||
|
||||
func_decl * mk_func_decl(family_id fid, decl_kind k, unsigned num_parameters, parameter const * parameters,
|
||||
unsigned num_args, expr * const * args, sort * range = 0);
|
||||
unsigned num_args, expr * const * args, sort * range = nullptr);
|
||||
|
||||
app * mk_app(family_id fid, decl_kind k, unsigned num_parameters = 0, parameter const * parameters = 0,
|
||||
unsigned num_args = 0, expr * const * args = 0, sort * range = 0);
|
||||
app * mk_app(family_id fid, decl_kind k, unsigned num_parameters = 0, parameter const * parameters = nullptr,
|
||||
unsigned num_args = 0, expr * const * args = nullptr, sort * range = nullptr);
|
||||
|
||||
app * mk_app(family_id fid, decl_kind k, unsigned num_args, expr * const * args);
|
||||
|
||||
|
@ -1710,7 +1716,7 @@ public:
|
|||
|
||||
app * mk_app(family_id fid, decl_kind k, expr * arg1, expr * arg2, expr * arg3);
|
||||
|
||||
app * mk_const(family_id fid, decl_kind k) { return mk_app(fid, k, 0, static_cast<expr * const *>(0)); }
|
||||
app * mk_const(family_id fid, decl_kind k) { return mk_app(fid, k, 0, static_cast<expr * const *>(nullptr)); }
|
||||
private:
|
||||
func_decl * mk_func_decl(symbol const & name, unsigned arity, sort * const * domain, sort * range,
|
||||
func_decl_info * info);
|
||||
|
@ -1721,13 +1727,13 @@ private:
|
|||
|
||||
public:
|
||||
func_decl * mk_func_decl(symbol const & name, unsigned arity, sort * const * domain, sort * range) {
|
||||
return mk_func_decl(name, arity, domain, range, static_cast<func_decl_info *>(0));
|
||||
return mk_func_decl(name, arity, domain, range, static_cast<func_decl_info *>(nullptr));
|
||||
}
|
||||
|
||||
func_decl * mk_func_decl(symbol const & name, unsigned arity, sort * const * domain, sort * range,
|
||||
func_decl_info const & info) {
|
||||
if (info.is_null()) {
|
||||
return mk_func_decl(name, arity, domain, range, static_cast<func_decl_info *>(0));
|
||||
return mk_func_decl(name, arity, domain, range, static_cast<func_decl_info *>(nullptr));
|
||||
}
|
||||
else {
|
||||
return mk_func_decl(name, arity, domain, range, & const_cast<func_decl_info&>(info));
|
||||
|
@ -1740,11 +1746,11 @@ public:
|
|||
}
|
||||
|
||||
func_decl * mk_const_decl(symbol const & name, sort * s) {
|
||||
return mk_func_decl(name, static_cast<unsigned>(0), 0, s);
|
||||
return mk_func_decl(name, static_cast<unsigned>(0), nullptr, s);
|
||||
}
|
||||
|
||||
func_decl * mk_const_decl(symbol const & name, sort * s, func_decl_info const & info) {
|
||||
return mk_func_decl(name, static_cast<unsigned>(0), 0, s, info);
|
||||
return mk_func_decl(name, static_cast<unsigned>(0), nullptr, s, info);
|
||||
}
|
||||
|
||||
func_decl * mk_func_decl(symbol const & name, sort * domain, sort * range, func_decl_info const & info) {
|
||||
|
@ -1798,7 +1804,7 @@ public:
|
|||
|
||||
app * mk_const(func_decl * decl) {
|
||||
SASSERT(decl->get_arity() == 0);
|
||||
return mk_app(decl, static_cast<unsigned>(0), static_cast<expr**>(0));
|
||||
return mk_app(decl, static_cast<unsigned>(0), static_cast<expr**>(nullptr));
|
||||
}
|
||||
|
||||
app * mk_const(symbol const & name, sort * s) {
|
||||
|
@ -1819,9 +1825,9 @@ public:
|
|||
return mk_fresh_func_decl(symbol(prefix), symbol::null, arity, domain, range);
|
||||
}
|
||||
|
||||
app * mk_fresh_const(char const * prefix, sort * s) { return mk_const(mk_fresh_func_decl(prefix, 0, 0, s)); }
|
||||
app * mk_fresh_const(char const * prefix, sort * s) { return mk_const(mk_fresh_func_decl(prefix, 0, nullptr, s)); }
|
||||
|
||||
symbol mk_fresh_var_name(char const * prefix = 0);
|
||||
symbol mk_fresh_var_name(char const * prefix = nullptr);
|
||||
|
||||
var * mk_var(unsigned idx, sort * ty);
|
||||
|
||||
|
@ -1873,21 +1879,21 @@ public:
|
|||
|
||||
quantifier * mk_quantifier(bool forall, unsigned num_decls, sort * const * decl_sorts, symbol const * decl_names, expr * body,
|
||||
int weight = 0, symbol const & qid = symbol::null, symbol const & skid = symbol::null,
|
||||
unsigned num_patterns = 0, expr * const * patterns = 0,
|
||||
unsigned num_no_patterns = 0, expr * const * no_patterns = 0);
|
||||
unsigned num_patterns = 0, expr * const * patterns = nullptr,
|
||||
unsigned num_no_patterns = 0, expr * const * no_patterns = nullptr);
|
||||
|
||||
quantifier * mk_forall(unsigned num_decls, sort * const * decl_sorts, symbol const * decl_names, expr * body,
|
||||
int weight = 0, symbol const & qid = symbol::null, symbol const & skid = symbol::null,
|
||||
unsigned num_patterns = 0, expr * const * patterns = 0,
|
||||
unsigned num_no_patterns = 0, expr * const * no_patterns = 0) {
|
||||
unsigned num_patterns = 0, expr * const * patterns = nullptr,
|
||||
unsigned num_no_patterns = 0, expr * const * no_patterns = nullptr) {
|
||||
return mk_quantifier(true, num_decls, decl_sorts, decl_names, body, weight, qid, skid, num_patterns, patterns,
|
||||
num_no_patterns, no_patterns);
|
||||
}
|
||||
|
||||
quantifier * mk_exists(unsigned num_decls, sort * const * decl_sorts, symbol const * decl_names, expr * body,
|
||||
int weight = 0, symbol const & qid = symbol::null, symbol const & skid = symbol::null,
|
||||
unsigned num_patterns = 0, expr * const * patterns = 0,
|
||||
unsigned num_no_patterns = 0, expr * const * no_patterns = 0) {
|
||||
unsigned num_patterns = 0, expr * const * patterns = nullptr,
|
||||
unsigned num_no_patterns = 0, expr * const * no_patterns = nullptr) {
|
||||
return mk_quantifier(false, num_decls, decl_sorts, decl_names, body, weight, qid, skid, num_patterns, patterns,
|
||||
num_no_patterns, no_patterns);
|
||||
}
|
||||
|
@ -2051,12 +2057,12 @@ public:
|
|||
|
||||
func_decl* mk_and_decl() {
|
||||
sort* domain[2] = { m_bool_sort, m_bool_sort };
|
||||
return mk_func_decl(m_basic_family_id, OP_AND, 0, 0, 2, domain);
|
||||
return mk_func_decl(m_basic_family_id, OP_AND, 0, nullptr, 2, domain);
|
||||
}
|
||||
func_decl* mk_not_decl() { return mk_func_decl(m_basic_family_id, OP_NOT, 0, 0, 1, &m_bool_sort); }
|
||||
func_decl* mk_not_decl() { return mk_func_decl(m_basic_family_id, OP_NOT, 0, nullptr, 1, &m_bool_sort); }
|
||||
func_decl* mk_or_decl() {
|
||||
sort* domain[2] = { m_bool_sort, m_bool_sort };
|
||||
return mk_func_decl(m_basic_family_id, OP_OR, 0, 0, 2, domain);
|
||||
return mk_func_decl(m_basic_family_id, OP_OR, 0, nullptr, 2, domain);
|
||||
}
|
||||
|
||||
// -----------------------------------
|
||||
|
@ -2204,7 +2210,7 @@ public:
|
|||
|
||||
proof * mk_th_lemma(family_id tid,
|
||||
expr * fact, unsigned num_proofs, proof * const * proofs,
|
||||
unsigned num_params = 0, parameter const* params = 0);
|
||||
unsigned num_params = 0, parameter const* params = nullptr);
|
||||
|
||||
protected:
|
||||
bool check_nnf_proof_parents(unsigned num_proofs, proof * const * proofs) const;
|
||||
|
@ -2461,9 +2467,9 @@ class scoped_mark : public ast_mark {
|
|||
unsigned_vector m_lim;
|
||||
public:
|
||||
scoped_mark(ast_manager& m): m_stack(m) {}
|
||||
virtual ~scoped_mark() {}
|
||||
virtual void mark(ast * n, bool flag);
|
||||
virtual void reset();
|
||||
~scoped_mark() override {}
|
||||
void mark(ast * n, bool flag) override;
|
||||
void reset() override;
|
||||
void mark(ast * n);
|
||||
void push_scope();
|
||||
void pop_scope();
|
||||
|
|
|
@ -319,11 +319,11 @@ void ast_ll_pp(std::ostream & out, ast_manager & m, ast * n, ast_mark & visited,
|
|||
}
|
||||
|
||||
void ast_def_ll_pp(std::ostream & out, ast_manager & m, ast * n, ast_mark & visited, bool only_exprs, bool compact) {
|
||||
ll_printer p(out, m, 0, only_exprs, compact);
|
||||
ll_printer p(out, m, nullptr, only_exprs, compact);
|
||||
p.pp(n, visited);
|
||||
}
|
||||
|
||||
void ast_ll_bounded_pp(std::ostream & out, ast_manager & m, ast * n, unsigned depth) {
|
||||
ll_printer p(out, m, 0, false, true);
|
||||
ll_printer p(out, m, nullptr, false, true);
|
||||
p.display_bounded(n, depth);
|
||||
}
|
||||
|
|
|
@ -24,10 +24,10 @@ Revision History:
|
|||
#include "ast/ast_smt2_pp.h"
|
||||
|
||||
struct mk_pp : public mk_ismt2_pp {
|
||||
mk_pp(ast * t, ast_manager & m, params_ref const & p, unsigned indent = 0, unsigned num_vars = 0, char const * var_prefix = 0):
|
||||
mk_pp(ast * t, ast_manager & m, params_ref const & p, unsigned indent = 0, unsigned num_vars = 0, char const * var_prefix = nullptr):
|
||||
mk_ismt2_pp(t, m, p, indent, num_vars, var_prefix) {
|
||||
}
|
||||
mk_pp(ast * t, ast_manager & m, unsigned indent = 0, unsigned num_vars = 0, char const * var_prefix = 0):
|
||||
mk_pp(ast * t, ast_manager & m, unsigned indent = 0, unsigned num_vars = 0, char const * var_prefix = nullptr):
|
||||
mk_ismt2_pp(t, m, indent, num_vars, var_prefix) {
|
||||
}
|
||||
};
|
||||
|
|
|
@ -38,9 +38,10 @@ void ast_pp_util::collect(expr_ref_vector const& es) {
|
|||
void ast_pp_util::display_decls(std::ostream& out) {
|
||||
smt2_pp_environment_dbg env(m);
|
||||
ast_smt_pp pp(m);
|
||||
coll.order_deps();
|
||||
unsigned n = coll.get_num_sorts();
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
pp.display_ast_smt2(out, coll.get_sorts()[i], 0, 0, 0);
|
||||
pp.display_ast_smt2(out, coll.get_sorts()[i], 0, 0, nullptr);
|
||||
}
|
||||
n = coll.get_num_decls();
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
|
|
|
@ -25,24 +25,24 @@ class simple_ast_printer_context : public ast_printer_context {
|
|||
smt2_pp_environment_dbg & env() const { return *(m_env.get()); }
|
||||
public:
|
||||
simple_ast_printer_context(ast_manager & m):m_manager(m) { m_env = alloc(smt2_pp_environment_dbg, m); }
|
||||
virtual ~simple_ast_printer_context() {}
|
||||
~simple_ast_printer_context() override {}
|
||||
ast_manager & m() const { return m_manager; }
|
||||
virtual ast_manager & get_ast_manager() { return m_manager; }
|
||||
virtual void display(std::ostream & out, sort * s, unsigned indent = 0) const { out << mk_ismt2_pp(s, m(), indent); }
|
||||
virtual void display(std::ostream & out, expr * n, unsigned indent = 0) const { out << mk_ismt2_pp(n, m(), indent); }
|
||||
virtual void display(std::ostream & out, func_decl * f, unsigned indent = 0) const {
|
||||
ast_manager & get_ast_manager() override { return m_manager; }
|
||||
void display(std::ostream & out, sort * s, unsigned indent = 0) const override { out << mk_ismt2_pp(s, m(), indent); }
|
||||
void display(std::ostream & out, expr * n, unsigned indent = 0) const override { out << mk_ismt2_pp(n, m(), indent); }
|
||||
void display(std::ostream & out, func_decl * f, unsigned indent = 0) const override {
|
||||
out << f->get_name();
|
||||
}
|
||||
virtual void pp(sort * s, format_ns::format_ref & r) const { mk_smt2_format(s, env(), params_ref(), r); }
|
||||
virtual void pp(func_decl * f, format_ns::format_ref & r) const { mk_smt2_format(f, env(), params_ref(), r); }
|
||||
virtual void pp(expr * n, format_ns::format_ref & r) const {
|
||||
void pp(sort * s, format_ns::format_ref & r) const override { mk_smt2_format(s, env(), params_ref(), r); }
|
||||
void pp(func_decl * f, format_ns::format_ref & r) const override { mk_smt2_format(f, env(), params_ref(), r); }
|
||||
void pp(expr * n, format_ns::format_ref & r) const override {
|
||||
sbuffer<symbol> buf;
|
||||
mk_smt2_format(n, env(), params_ref(), 0, 0, r, buf);
|
||||
mk_smt2_format(n, env(), params_ref(), 0, nullptr, r, buf);
|
||||
}
|
||||
virtual void pp(expr * n, unsigned num_vars, char const * var_prefix, format_ns::format_ref & r, sbuffer<symbol> & var_names) const {
|
||||
void pp(expr * n, unsigned num_vars, char const * var_prefix, format_ns::format_ref & r, sbuffer<symbol> & var_names) const override {
|
||||
mk_smt2_format(n, env(), params_ref(), num_vars, var_prefix, r, var_names);
|
||||
}
|
||||
virtual void display(std::ostream & out, expr * n, unsigned indent, unsigned num_vars, char const * var_prefix, sbuffer<symbol> & var_names) const {
|
||||
void display(std::ostream & out, expr * n, unsigned indent, unsigned num_vars, char const * var_prefix, sbuffer<symbol> & var_names) const override {
|
||||
NOT_IMPLEMENTED_YET();
|
||||
}
|
||||
|
||||
|
|
|
@ -45,7 +45,7 @@ public:
|
|||
|
||||
class ast_printer_context : public ast_printer {
|
||||
public:
|
||||
virtual ~ast_printer_context() {}
|
||||
~ast_printer_context() override {}
|
||||
virtual ast_manager & get_ast_manager() = 0;
|
||||
virtual std::ostream & regular_stream() { return std::cout; }
|
||||
virtual std::ostream & diagnostic_stream() { return std::cerr; }
|
||||
|
|
|
@ -236,7 +236,7 @@ format * smt2_pp_environment::pp_float_literal(app * t, bool use_bv_lits, bool u
|
|||
mpf_manager & fm = get_futil().fm();
|
||||
scoped_mpf v(fm);
|
||||
ast_manager & m = get_manager();
|
||||
format * body = 0;
|
||||
format * body = nullptr;
|
||||
string_buffer<> buf;
|
||||
VERIFY(get_futil().is_numeral(t, v));
|
||||
if (fm.is_nan(v)) {
|
||||
|
@ -750,7 +750,7 @@ class smt2_printer {
|
|||
}
|
||||
buffer<symbol> labels;
|
||||
bool is_pos;
|
||||
format * f = 0;
|
||||
format * f = nullptr;
|
||||
format ** it = m_format_stack.c_ptr() + fr.m_spos;
|
||||
format ** end = m_format_stack.c_ptr() + m_format_stack.size();
|
||||
if (m().is_label(t, is_pos, labels)) {
|
||||
|
@ -1004,7 +1004,7 @@ class smt2_printer {
|
|||
void del_expr2alias_stack() {
|
||||
std::for_each(m_expr2alias_stack.begin(), m_expr2alias_stack.end(), delete_proc<expr2alias>());
|
||||
m_expr2alias_stack.reset();
|
||||
m_expr2alias = 0;
|
||||
m_expr2alias = nullptr;
|
||||
}
|
||||
|
||||
void reset_expr2alias_stack() {
|
||||
|
@ -1064,7 +1064,7 @@ public:
|
|||
m_manager(env.get_manager()),
|
||||
m_env(env),
|
||||
m_soccs(m_manager),
|
||||
m_root(0),
|
||||
m_root(nullptr),
|
||||
m_aliased_pps(fm()),
|
||||
m_next_alias_idx(1),
|
||||
m_format_stack(fm()) {
|
||||
|
@ -1092,7 +1092,7 @@ public:
|
|||
|
||||
void operator()(expr * n, unsigned num, char const * var_prefix, format_ref & r, sbuffer<symbol> & var_names) {
|
||||
reset_var_names();
|
||||
if (var_prefix == 0)
|
||||
if (var_prefix == nullptr)
|
||||
var_prefix = "x";
|
||||
if (strcmp(var_prefix, ALIAS_PREFIX) == 0) {
|
||||
var_prefix = "_a";
|
||||
|
@ -1228,7 +1228,7 @@ mk_ismt2_pp::mk_ismt2_pp(ast * t, ast_manager & m, unsigned indent, unsigned num
|
|||
|
||||
std::ostream& operator<<(std::ostream& out, mk_ismt2_pp const & p) {
|
||||
smt2_pp_environment_dbg env(p.m_manager);
|
||||
if (p.m_ast == 0) {
|
||||
if (p.m_ast == nullptr) {
|
||||
out << "null";
|
||||
}
|
||||
else if (is_expr(p.m_ast)) {
|
||||
|
@ -1263,13 +1263,13 @@ std::ostream& operator<<(std::ostream& out, sort_ref const& e) {
|
|||
std::ostream& operator<<(std::ostream& out, expr_ref_vector const& e) {
|
||||
smt2_pp_environment_dbg env(e.get_manager());
|
||||
params_ref p;
|
||||
return ast_smt2_pp(out, e.size(), e.c_ptr(), env, p, 0, 0, 0);
|
||||
return ast_smt2_pp(out, e.size(), e.c_ptr(), env, p, 0, 0, nullptr);
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, app_ref_vector const& e) {
|
||||
smt2_pp_environment_dbg env(e.get_manager());
|
||||
params_ref p;
|
||||
return ast_smt2_pp(out, e.size(), (expr*const*)e.c_ptr(), env, p, 0, 0, 0);
|
||||
return ast_smt2_pp(out, e.size(), (expr*const*)e.c_ptr(), env, p, 0, 0, nullptr);
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, func_decl_ref_vector const& e) {
|
||||
|
|
|
@ -80,15 +80,15 @@ class smt2_pp_environment_dbg : public smt2_pp_environment {
|
|||
datalog::dl_decl_util m_dlutil;
|
||||
public:
|
||||
smt2_pp_environment_dbg(ast_manager & m):m_manager(m), m_autil(m), m_bvutil(m), m_arutil(m), m_futil(m), m_sutil(m), m_dtutil(m), m_dlutil(m) {}
|
||||
virtual ast_manager & get_manager() const { return m_manager; }
|
||||
virtual arith_util & get_autil() { return m_autil; }
|
||||
virtual bv_util & get_bvutil() { return m_bvutil; }
|
||||
virtual seq_util & get_sutil() { return m_sutil; }
|
||||
virtual array_util & get_arutil() { return m_arutil; }
|
||||
virtual fpa_util & get_futil() { return m_futil; }
|
||||
virtual datalog::dl_decl_util& get_dlutil() { return m_dlutil; }
|
||||
virtual datatype_util& get_dtutil() { return m_dtutil; }
|
||||
virtual bool uses(symbol const & s) const { return false; }
|
||||
ast_manager & get_manager() const override { return m_manager; }
|
||||
arith_util & get_autil() override { return m_autil; }
|
||||
bv_util & get_bvutil() override { return m_bvutil; }
|
||||
seq_util & get_sutil() override { return m_sutil; }
|
||||
array_util & get_arutil() override { return m_arutil; }
|
||||
fpa_util & get_futil() override { return m_futil; }
|
||||
datalog::dl_decl_util& get_dlutil() override { return m_dlutil; }
|
||||
datatype_util& get_dtutil() override { return m_dtutil; }
|
||||
bool uses(symbol const & s) const override { return false; }
|
||||
};
|
||||
|
||||
void mk_smt2_format(expr * n, smt2_pp_environment & env, params_ref const & p,
|
||||
|
@ -98,7 +98,7 @@ void mk_smt2_format(sort * s, smt2_pp_environment & env, params_ref const & p, f
|
|||
void mk_smt2_format(func_decl * f, smt2_pp_environment & env, params_ref const & p, format_ns::format_ref & r);
|
||||
|
||||
std::ostream & ast_smt2_pp(std::ostream & out, expr * n, smt2_pp_environment & env, params_ref const & p = params_ref(), unsigned indent = 0,
|
||||
unsigned num_vars = 0, char const * var_prefix = 0);
|
||||
unsigned num_vars = 0, char const * var_prefix = nullptr);
|
||||
std::ostream & ast_smt2_pp(std::ostream & out, sort * s, smt2_pp_environment & env, params_ref const & p = params_ref(), unsigned indent = 0);
|
||||
std::ostream & ast_smt2_pp(std::ostream & out, func_decl * f, smt2_pp_environment & env, params_ref const & p = params_ref(), unsigned indent = 0);
|
||||
|
||||
|
@ -113,8 +113,8 @@ struct mk_ismt2_pp {
|
|||
unsigned m_indent;
|
||||
unsigned m_num_vars;
|
||||
char const * m_var_prefix;
|
||||
mk_ismt2_pp(ast * t, ast_manager & m, params_ref const & p, unsigned indent = 0, unsigned num_vars = 0, char const * var_prefix = 0);
|
||||
mk_ismt2_pp(ast * t, ast_manager & m, unsigned indent = 0, unsigned num_vars = 0, char const * var_prefix = 0);
|
||||
mk_ismt2_pp(ast * t, ast_manager & m, params_ref const & p, unsigned indent = 0, unsigned num_vars = 0, char const * var_prefix = nullptr);
|
||||
mk_ismt2_pp(ast * t, ast_manager & m, unsigned indent = 0, unsigned num_vars = 0, char const * var_prefix = nullptr);
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, mk_ismt2_pp const & p);
|
||||
|
|
|
@ -340,8 +340,7 @@ class smt_printer {
|
|||
}
|
||||
|
||||
|
||||
void pp_arg(expr *arg, app *parent)
|
||||
{
|
||||
void pp_arg(expr *arg, app *parent) {
|
||||
pp_marked_expr(arg);
|
||||
}
|
||||
|
||||
|
@ -417,7 +416,7 @@ class smt_printer {
|
|||
else if (m_simplify_implies && m_manager.is_implies(decl) && m_manager.is_implies(n->get_arg(1))) {
|
||||
expr *curr = n;
|
||||
expr *arg;
|
||||
m_out << "(implies (and";
|
||||
m_out << "(=> (and";
|
||||
while (m_manager.is_implies(curr)) {
|
||||
arg = to_app(curr)->get_arg(0);
|
||||
|
||||
|
@ -476,9 +475,8 @@ class smt_printer {
|
|||
}
|
||||
}
|
||||
|
||||
void print_no_lets(expr *e)
|
||||
{
|
||||
smt_printer p(m_out, m_manager, m_qlists, m_renaming, m_logic, true, m_simplify_implies, true, m_indent, m_num_var_names, m_var_names);
|
||||
void print_no_lets(expr *e) {
|
||||
smt_printer p(m_out, m_manager, m_qlists, m_renaming, m_logic, true, m_simplify_implies, m_indent, m_num_var_names, m_var_names);
|
||||
p(e);
|
||||
}
|
||||
|
||||
|
@ -511,7 +509,7 @@ class smt_printer {
|
|||
m_out << "(! ";
|
||||
}
|
||||
{
|
||||
smt_printer p(m_out, m_manager, m_qlists, m_renaming, m_logic, false, true, m_simplify_implies, m_indent, m_num_var_names, m_var_names);
|
||||
smt_printer p(m_out, m_manager, m_qlists, m_renaming, m_logic, false, m_simplify_implies, m_indent, m_num_var_names, m_var_names);
|
||||
p(q->get_expr());
|
||||
}
|
||||
|
||||
|
@ -704,7 +702,7 @@ class smt_printer {
|
|||
|
||||
public:
|
||||
smt_printer(std::ostream& out, ast_manager& m, ptr_vector<quantifier>& ql, smt_renaming& rn,
|
||||
symbol logic, bool no_lets, bool is_smt2, bool simplify_implies, unsigned indent, unsigned num_var_names = 0, char const* const* var_names = 0) :
|
||||
symbol logic, bool no_lets, bool simplify_implies, unsigned indent, unsigned num_var_names = 0, char const* const* var_names = nullptr) :
|
||||
m_out(out),
|
||||
m_manager(m),
|
||||
m_qlists(ql),
|
||||
|
@ -770,7 +768,7 @@ public:
|
|||
}
|
||||
m_mark.reset();
|
||||
m_num_lets = 0;
|
||||
m_top = 0;
|
||||
m_top = nullptr;
|
||||
}
|
||||
|
||||
void pp_dt(ast_mark& mark, sort* s) {
|
||||
|
@ -894,25 +892,17 @@ ast_smt_pp::ast_smt_pp(ast_manager& m):
|
|||
m_simplify_implies(true)
|
||||
{}
|
||||
|
||||
|
||||
void ast_smt_pp::display_expr(std::ostream& strm, expr* n) {
|
||||
ptr_vector<quantifier> ql;
|
||||
smt_renaming rn;
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, false, false, m_simplify_implies, 0);
|
||||
p(n);
|
||||
}
|
||||
|
||||
void ast_smt_pp::display_expr_smt2(std::ostream& strm, expr* n, unsigned indent, unsigned num_var_names, char const* const* var_names) {
|
||||
ptr_vector<quantifier> ql;
|
||||
smt_renaming rn;
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, false, true, m_simplify_implies, indent, num_var_names, var_names);
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, false, m_simplify_implies, indent, num_var_names, var_names);
|
||||
p(n);
|
||||
}
|
||||
|
||||
void ast_smt_pp::display_ast_smt2(std::ostream& strm, ast* a, unsigned indent, unsigned num_var_names, char const* const* var_names) {
|
||||
ptr_vector<quantifier> ql;
|
||||
smt_renaming rn;
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, false, true, m_simplify_implies, indent, num_var_names, var_names);
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, false, m_simplify_implies, indent, num_var_names, var_names);
|
||||
if (is_expr(a)) {
|
||||
p(to_expr(a));
|
||||
}
|
||||
|
@ -962,6 +952,10 @@ void ast_smt_pp::display_smt2(std::ostream& strm, expr* n) {
|
|||
strm << "; " << m_attributes.c_str();
|
||||
}
|
||||
|
||||
#if 0
|
||||
decls.display_decls(strm);
|
||||
#else
|
||||
decls.order_deps();
|
||||
ast_mark sort_mark;
|
||||
for (unsigned i = 0; i < decls.get_num_sorts(); ++i) {
|
||||
sort* s = decls.get_sorts()[i];
|
||||
|
@ -988,18 +982,19 @@ void ast_smt_pp::display_smt2(std::ostream& strm, expr* n) {
|
|||
strm << "\n";
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
for (unsigned i = 0; i < m_assumptions.size(); ++i) {
|
||||
for (expr* a : m_assumptions) {
|
||||
smt_printer p(strm, m, ql, rn, m_logic, false, true, m_simplify_implies, 1);
|
||||
strm << "(assert\n ";
|
||||
p(m_assumptions[i].get());
|
||||
p(a);
|
||||
strm << ")\n";
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < m_assumptions_star.size(); ++i) {
|
||||
for (expr* a : m_assumptions_star) {
|
||||
smt_printer p(strm, m, ql, rn, m_logic, false, true, m_simplify_implies, 1);
|
||||
strm << "(assert\n ";
|
||||
p(m_assumptions_star[i].get());
|
||||
p(a);
|
||||
strm << ")\n";
|
||||
}
|
||||
|
||||
|
@ -1021,92 +1016,3 @@ void ast_smt_pp::display_smt2(std::ostream& strm, expr* n) {
|
|||
p(n);
|
||||
}
|
||||
}
|
||||
|
||||
void ast_smt_pp::display(std::ostream& strm, expr* n) {
|
||||
ptr_vector<quantifier> ql;
|
||||
decl_collector decls(m_manager);
|
||||
smt_renaming rn;
|
||||
|
||||
for (unsigned i = 0; i < m_assumptions.size(); ++i) {
|
||||
decls.visit(m_assumptions[i].get());
|
||||
}
|
||||
for (unsigned i = 0; i < m_assumptions_star.size(); ++i) {
|
||||
decls.visit(m_assumptions_star[i].get());
|
||||
}
|
||||
decls.visit(n);
|
||||
|
||||
strm << "(benchmark ";
|
||||
|
||||
if (m_benchmark_name != symbol::null) {
|
||||
strm << m_benchmark_name << "\n";
|
||||
}
|
||||
else {
|
||||
strm << "unnamed\n";
|
||||
}
|
||||
if (m_source_info != symbol::null && m_source_info != symbol("")) {
|
||||
strm << ":source { " << m_source_info << " }\n";
|
||||
}
|
||||
strm << ":status " << m_status << "\n";
|
||||
if (m_category != symbol::null && m_category != symbol("")) {
|
||||
strm << ":category { " << m_category << " }\n";
|
||||
}
|
||||
if (m_logic != symbol::null && m_logic != symbol("")) {
|
||||
strm << ":logic " << m_logic << "\n";
|
||||
}
|
||||
|
||||
if (m_attributes.size() > 0) {
|
||||
strm << m_attributes.c_str();
|
||||
}
|
||||
|
||||
ast_mark sort_mark;
|
||||
for (unsigned i = 0; i < decls.get_num_sorts(); ++i) {
|
||||
sort* s = decls.get_sorts()[i];
|
||||
if (!(*m_is_declared)(s)) {
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, true, false, m_simplify_implies, 0);
|
||||
p.pp_sort_decl(sort_mark, s);
|
||||
}
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < decls.get_num_decls(); ++i) {
|
||||
func_decl* d = decls.get_func_decls()[i];
|
||||
if (!(*m_is_declared)(d)) {
|
||||
strm << ":extrafuns (";
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, true, false, m_simplify_implies, 0);
|
||||
p(d);
|
||||
strm << ")\n";
|
||||
}
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < decls.get_num_preds(); ++i) {
|
||||
func_decl* d = decls.get_pred_decls()[i];
|
||||
if (!(*m_is_declared)(d)) {
|
||||
strm << ":extrapreds (";
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, true, false, m_simplify_implies, 0);
|
||||
p.visit_pred(d);
|
||||
strm << ")\n";
|
||||
}
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < m_assumptions.size(); ++i) {
|
||||
expr * e = m_assumptions[i].get();
|
||||
strm << ":assumption\n";
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, false, false, m_simplify_implies, 0);
|
||||
p(e);
|
||||
strm << "\n";
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < m_assumptions_star.size(); ++i) {
|
||||
strm << ":assumption-core\n";
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, false, false, m_simplify_implies, 0);
|
||||
p(m_assumptions_star[i].get());
|
||||
strm << "\n";
|
||||
}
|
||||
|
||||
{
|
||||
strm << ":formula\n";
|
||||
smt_printer p(strm, m_manager, ql, rn, m_logic, false, false, m_simplify_implies, 0);
|
||||
p(n);
|
||||
strm << "\n";
|
||||
}
|
||||
strm << ")\n";
|
||||
}
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue