mirror of
https://github.com/Z3Prover/z3
synced 2025-04-10 03:07:07 +00:00
200 lines
9 KiB
C++
200 lines
9 KiB
C++
/*++
|
|
Copyright (c) 2012 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
api_util.h
|
|
|
|
Abstract:
|
|
Goodies used to build the Z3 external API.
|
|
|
|
Author:
|
|
|
|
Leonardo de Moura (leonardo) 2012-02-29.
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#pragma once
|
|
|
|
#include "util/params.h"
|
|
#include "util/lbool.h"
|
|
#include "util/mutex.h"
|
|
#include "ast/ast.h"
|
|
|
|
#define Z3_TRY try {
|
|
#define Z3_CATCH_CORE(CODE) } catch (z3_exception & ex) { mk_c(c)->handle_exception(ex); CODE }
|
|
#define Z3_CATCH Z3_CATCH_CORE(return;)
|
|
#define Z3_CATCH_RETURN(VAL) Z3_CATCH_CORE(return VAL;)
|
|
#define Z3_CATCH_RETURN_NO_HANDLE(VAL) } catch (z3_exception &) { return VAL; }
|
|
|
|
#define CHECK_REF_COUNT(a) (reinterpret_cast<ast const*>(a)->get_ref_count() > 0)
|
|
|
|
namespace api {
|
|
class context;
|
|
|
|
// Generic wrapper for ref-count objects exposed by the API
|
|
class object {
|
|
atomic<unsigned> m_ref_count;
|
|
unsigned m_id;
|
|
context& m_context;
|
|
public:
|
|
object(context& c);
|
|
virtual ~object() = default;
|
|
unsigned ref_count() const { return m_ref_count; }
|
|
unsigned id() const { return m_id; }
|
|
void inc_ref();
|
|
void dec_ref();
|
|
};
|
|
};
|
|
|
|
inline ast * to_ast(Z3_ast a) { return reinterpret_cast<ast *>(a); }
|
|
inline Z3_ast of_ast(ast* a) { return reinterpret_cast<Z3_ast>(a); }
|
|
|
|
inline expr * to_expr(Z3_ast a) { return reinterpret_cast<expr*>(a); }
|
|
inline Z3_ast of_expr(expr* e) { return reinterpret_cast<Z3_ast>(e); }
|
|
|
|
inline expr * const * to_exprs(unsigned n, Z3_ast const* a) { return reinterpret_cast<expr* const*>(a); }
|
|
inline Z3_ast * const * of_exprs(expr* const* e) { return reinterpret_cast<Z3_ast* const*>(e); }
|
|
|
|
inline app * to_app(Z3_app a) { return reinterpret_cast<app*>(a); }
|
|
inline app * to_app(Z3_ast a) { return reinterpret_cast<app*>(a); }
|
|
inline Z3_app of_app(app* a) { return reinterpret_cast<Z3_app>(a); }
|
|
|
|
inline app * const* to_apps(Z3_ast const* a) { return reinterpret_cast<app * const*>(a); }
|
|
|
|
inline ast * const * to_asts(Z3_ast const* a) { return reinterpret_cast<ast* const*>(a); }
|
|
|
|
inline sort * to_sort(Z3_sort a) { return reinterpret_cast<sort*>(a); }
|
|
inline Z3_sort of_sort(sort* s) { return reinterpret_cast<Z3_sort>(s); }
|
|
|
|
inline sort * const * to_sorts(Z3_sort const* a) { return reinterpret_cast<sort* const*>(a); }
|
|
inline Z3_sort const * of_sorts(sort* const* s) { return reinterpret_cast<Z3_sort const*>(s); }
|
|
|
|
inline func_decl * to_func_decl(Z3_func_decl a) { return reinterpret_cast<func_decl*>(a); }
|
|
inline Z3_func_decl of_func_decl(func_decl* f) { return reinterpret_cast<Z3_func_decl>(f); }
|
|
|
|
inline func_decl * const * to_func_decls(Z3_func_decl const* f) { return reinterpret_cast<func_decl*const*>(f); }
|
|
|
|
inline symbol to_symbol(Z3_symbol s) { return symbol::c_api_ext2symbol(s); }
|
|
inline Z3_symbol of_symbol(symbol s) { return static_cast<Z3_symbol>(s.c_api_symbol2ext()); }
|
|
|
|
inline Z3_pattern of_pattern(ast* a) { return reinterpret_cast<Z3_pattern>(a); }
|
|
inline app* to_pattern(Z3_pattern p) { return reinterpret_cast<app*>(p); }
|
|
|
|
inline Z3_lbool of_lbool(lbool b) { return static_cast<Z3_lbool>(b); }
|
|
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) {}
|
|
};
|
|
|
|
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 == nullptr ? const_cast<params_ref&>(params_ref::get_empty()) : 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) {}
|
|
};
|
|
|
|
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 == nullptr ? nullptr : &(to_param_descrs(p)->m_descrs); }
|
|
|
|
|
|
#define SKIP ((void) 0)
|
|
|
|
#define MK_UNARY_BODY(NAME, FID, OP, EXTRA_CODE) \
|
|
Z3_TRY; \
|
|
RESET_ERROR_CODE(); \
|
|
EXTRA_CODE; \
|
|
CHECK_IS_EXPR(n, nullptr); \
|
|
expr * _n = to_expr(n); \
|
|
ast* a = mk_c(c)->m().mk_app(FID, OP, 0, 0, 1, &_n); \
|
|
mk_c(c)->save_ast_trail(a); \
|
|
check_sorts(c, a); \
|
|
RETURN_Z3(of_ast(a)); \
|
|
Z3_CATCH_RETURN(0);
|
|
|
|
#define MK_UNARY(NAME, FID, OP, EXTRA_CODE) \
|
|
Z3_ast Z3_API NAME(Z3_context c, Z3_ast n) { \
|
|
LOG_ ## NAME(c, n); \
|
|
MK_UNARY_BODY(NAME, FID, OP, EXTRA_CODE); \
|
|
}
|
|
|
|
#define MK_BINARY_BODY(NAME, FID, OP, EXTRA_CODE) \
|
|
Z3_TRY; \
|
|
RESET_ERROR_CODE(); \
|
|
EXTRA_CODE; \
|
|
CHECK_IS_EXPR(n1, nullptr); \
|
|
CHECK_IS_EXPR(n2, nullptr); \
|
|
expr * args[2] = { to_expr(n1), to_expr(n2) }; \
|
|
ast* a = mk_c(c)->m().mk_app(FID, OP, 0, 0, 2, args); \
|
|
mk_c(c)->save_ast_trail(a); \
|
|
check_sorts(c, a); \
|
|
RETURN_Z3(of_ast(a)); \
|
|
Z3_CATCH_RETURN(0);
|
|
|
|
#define MK_BINARY(NAME, FID, OP, EXTRA_CODE) \
|
|
Z3_ast Z3_API NAME(Z3_context c, Z3_ast n1, Z3_ast n2) { \
|
|
LOG_ ## NAME(c, n1, n2); \
|
|
MK_BINARY_BODY(NAME, FID, OP, EXTRA_CODE); \
|
|
}
|
|
|
|
#define MK_TERNARY_BODY(NAME, FID, OP, EXTRA_CODE) \
|
|
Z3_TRY; \
|
|
RESET_ERROR_CODE(); \
|
|
EXTRA_CODE; \
|
|
CHECK_IS_EXPR(n1, nullptr); \
|
|
CHECK_IS_EXPR(n2, nullptr); \
|
|
CHECK_IS_EXPR(n3, nullptr); \
|
|
expr * args[3] = { to_expr(n1), to_expr(n2), to_expr(n3) }; \
|
|
ast* a = mk_c(c)->m().mk_app(FID, OP, 0, 0, 3, args); \
|
|
mk_c(c)->save_ast_trail(a); \
|
|
check_sorts(c, a); \
|
|
RETURN_Z3(of_ast(a)); \
|
|
Z3_CATCH_RETURN(0);
|
|
|
|
#define MK_TERNARY(NAME, FID, OP, EXTRA_CODE) \
|
|
Z3_ast Z3_API NAME(Z3_context c, Z3_ast n1, Z3_ast n2, Z3_ast n3) { \
|
|
LOG_ ## NAME(c, n1, n2, n3); \
|
|
MK_TERNARY_BODY(NAME, FID, OP, EXTRA_CODE); \
|
|
}
|
|
|
|
#define MK_FOURARY_BODY(NAME, FID, OP, EXTRA_CODE) \
|
|
Z3_TRY; \
|
|
RESET_ERROR_CODE(); \
|
|
EXTRA_CODE; \
|
|
CHECK_IS_EXPR(n1, nullptr); \
|
|
CHECK_IS_EXPR(n2, nullptr); \
|
|
CHECK_IS_EXPR(n3, nullptr); \
|
|
CHECK_IS_EXPR(n4, nullptr); \
|
|
expr * args[4] = { to_expr(n1), to_expr(n2), to_expr(n3), to_expr(n4) }; \
|
|
ast* a = mk_c(c)->m().mk_app(FID, OP, 0, 0, 4, args); \
|
|
mk_c(c)->save_ast_trail(a); \
|
|
check_sorts(c, a); \
|
|
RETURN_Z3(of_ast(a)); \
|
|
Z3_CATCH_RETURN(0);
|
|
|
|
#define MK_FOURARY(NAME, FID, OP, EXTRA_CODE) \
|
|
Z3_ast Z3_API NAME(Z3_context c, Z3_ast n1, Z3_ast n2, Z3_ast n3, Z3_ast n4) { \
|
|
LOG_ ## NAME(c, n1, n2, n3, n4); \
|
|
MK_FOURARY_BODY(NAME, FID, OP, EXTRA_CODE); \
|
|
}
|
|
|
|
#define MK_NARY(NAME, FID, OP, EXTRA_CODE) \
|
|
Z3_ast Z3_API NAME(Z3_context c, unsigned num_args, Z3_ast const* args) { \
|
|
Z3_TRY; \
|
|
LOG_ ## NAME(c, num_args, args); \
|
|
RESET_ERROR_CODE(); \
|
|
EXTRA_CODE; \
|
|
ast* a = mk_c(c)->m().mk_app(FID, OP, 0, 0, num_args, to_exprs(num_args, args)); \
|
|
mk_c(c)->save_ast_trail(a); \
|
|
check_sorts(c, a); \
|
|
RETURN_Z3(of_ast(a)); \
|
|
Z3_CATCH_RETURN(0); \
|
|
}
|
|
|