Reorganizing the code

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

src/api/api_arith.cpp

@@ -0,0 +1,219 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_arith.cpp
+
+Abstract:
+    API for arith theory
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"arith_decl_plugin.h"
+#include"algebraic_numbers.h"
+
+#define MK_ARITH_OP(NAME, OP) MK_NARY(NAME, mk_c(c)->get_arith_fid(), OP, SKIP)
+#define MK_BINARY_ARITH_OP(NAME, OP) MK_BINARY(NAME, mk_c(c)->get_arith_fid(), OP, SKIP)
+#define MK_ARITH_PRED(NAME, OP) MK_BINARY(NAME, mk_c(c)->get_arith_fid(), OP, SKIP)
+
+extern "C" {
+
+    Z3_sort Z3_API Z3_mk_int_sort(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_mk_int_sort(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_sort Z3_API Z3_mk_real_sort(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_mk_real_sort(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_ast Z3_API Z3_mk_real(__in Z3_context c, int num, int den) {
+        Z3_TRY;
+        LOG_Z3_mk_real(c, num, den);
+        RESET_ERROR_CODE();          
+        if (den == 0) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        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);
+    }
+    
+    MK_ARITH_OP(Z3_mk_add, OP_ADD);
+    MK_ARITH_OP(Z3_mk_mul, OP_MUL);
+    MK_BINARY_ARITH_OP(Z3_mk_power, OP_POWER);
+    MK_BINARY_ARITH_OP(Z3_mk_mod, OP_MOD);
+    MK_BINARY_ARITH_OP(Z3_mk_rem, OP_REM);
+
+    Z3_ast Z3_API Z3_mk_div(Z3_context c, Z3_ast n1, Z3_ast n2) {
+        Z3_TRY;
+        LOG_Z3_mk_div(c, n1, n2);
+        RESET_ERROR_CODE();                                                 
+        decl_kind k = OP_IDIV;
+        sort* ty = mk_c(c)->m().get_sort(to_expr(n1));
+        sort* real_ty = mk_c(c)->m().mk_sort(mk_c(c)->get_arith_fid(), REAL_SORT);
+        if (ty == real_ty) {
+            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);       
+        mk_c(c)->save_ast_trail(a);                                         
+        check_sorts(c, a);                                                  
+        RETURN_Z3(of_ast(a));
+        Z3_CATCH_RETURN(0);
+    }
+
+    MK_ARITH_PRED(Z3_mk_lt,  OP_LT);
+    MK_ARITH_PRED(Z3_mk_gt,  OP_GT);
+    MK_ARITH_PRED(Z3_mk_le,  OP_LE);
+    MK_ARITH_PRED(Z3_mk_ge,  OP_GE);
+    MK_UNARY(Z3_mk_int2real, mk_c(c)->get_arith_fid(), OP_TO_REAL, SKIP);
+    MK_UNARY(Z3_mk_real2int, mk_c(c)->get_arith_fid(), OP_TO_INT, SKIP);
+    MK_UNARY(Z3_mk_is_int,   mk_c(c)->get_arith_fid(), OP_IS_INT, SKIP);
+
+    Z3_ast Z3_API Z3_mk_sub(Z3_context c, unsigned num_args, Z3_ast const args[]) {
+        Z3_TRY;
+        LOG_Z3_mk_sub(c, num_args, args);
+        RESET_ERROR_CODE();
+        if (num_args == 0) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        if (mk_c(c)->fparams().m_pre_simplify_expr) {
+            // Do not use logging here... the function is implemented using API primitives
+            Z3_ast m1 = Z3_mk_int(c, -1, Z3_get_sort(c, args[0]));
+            Z3_ast args1[2] = { args[0], 0 };
+            for (unsigned i = 1; i < num_args; ++i) {
+                Z3_ast args2[3] = { m1, args[i] };
+                args1[1] = Z3_mk_mul(c, 2, args2);
+                args1[0] = Z3_mk_add(c, 2, args1);
+            }
+            RETURN_Z3(args1[0]);
+        }
+        else {
+            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);
+                check_sorts(c, r);
+            }
+            mk_c(c)->save_ast_trail(r);
+            RETURN_Z3(of_expr(r));
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_mk_unary_minus(Z3_context c, Z3_ast n) {
+        Z3_TRY;
+        LOG_Z3_mk_unary_minus(c, n);
+        RESET_ERROR_CODE();
+        if (mk_c(c)->fparams().m_pre_simplify_expr) {
+            Z3_ast m1 = Z3_mk_int(c, -1, Z3_get_sort(c, n));
+            Z3_ast args[2] = { m1, n };
+            Z3_ast r = Z3_mk_mul(c, 2, args);
+            RETURN_Z3(r);
+        }
+        MK_UNARY_BODY(Z3_mk_unary_minus, mk_c(c)->get_arith_fid(), OP_UMINUS, SKIP);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_is_algebraic_number(c, a);
+        RESET_ERROR_CODE();
+        expr * e = to_expr(a);
+        return mk_c(c)->autil().is_irrational_algebraic_numeral(e);
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    Z3_ast Z3_API Z3_get_algebraic_number_lower(Z3_context c, Z3_ast a, unsigned precision) {
+        Z3_TRY;
+        LOG_Z3_get_algebraic_number_lower(c, a, precision);
+        RESET_ERROR_CODE();
+        if (!Z3_is_algebraic_number(c, a)) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        expr * e = to_expr(a);
+        algebraic_numbers::anum const & val = mk_c(c)->autil().to_irrational_algebraic_numeral(e);
+        rational l;
+        mk_c(c)->autil().am().get_lower(val, l, precision);
+        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_ast Z3_API Z3_get_algebraic_number_upper(Z3_context c, Z3_ast a, unsigned precision) {
+        Z3_TRY;
+        LOG_Z3_get_algebraic_number_upper(c, a, precision);
+        RESET_ERROR_CODE();
+        if (!Z3_is_algebraic_number(c, a)) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        expr * e = to_expr(a);
+        algebraic_numbers::anum const & val = mk_c(c)->autil().to_irrational_algebraic_numeral(e);
+        rational l;
+        mk_c(c)->autil().am().get_upper(val, l, precision);
+        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_ast Z3_API Z3_get_numerator(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_get_numerator(c, a);
+        RESET_ERROR_CODE();
+        rational val;
+        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);
+        }
+        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_ast Z3_API Z3_get_denominator(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_get_denominator(c, a);
+        RESET_ERROR_CODE();
+        rational val;
+        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);
+        }
+        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);
+    }
+
+};

src/api/api_array.cpp

@@ -0,0 +1,233 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_array.cpp
+
+Abstract:
+    API for array theory
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"array_decl_plugin.h"
+
+extern "C" {
+
+    Z3_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range) {
+        Z3_TRY;
+        LOG_Z3_mk_array_sort(c, domain, range);
+        RESET_ERROR_CODE();  
+        parameter params[2]  = { parameter(to_sort(domain)), parameter(to_sort(range)) };
+        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_ast Z3_API Z3_mk_select(Z3_context c, Z3_ast a, Z3_ast i) {
+        Z3_TRY;
+        LOG_Z3_mk_select(c, a, i);
+        RESET_ERROR_CODE();
+        ast_manager & m = mk_c(c)->m();
+        expr * _a        = to_expr(a);
+        expr * _i        = to_expr(i);
+        sort * a_ty = m.get_sort(_a);
+        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);
+        }
+        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);
+        expr * args[2]        = {_a, _i};
+        app * r        = m.mk_app(d, 2, args);
+        mk_c(c)->save_ast_trail(r);
+        check_sorts(c, r);
+        RETURN_Z3(of_ast(r));
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v) {
+        Z3_TRY;
+        LOG_Z3_mk_store(c, a, i, v);
+        RESET_ERROR_CODE();
+        ast_manager & m = mk_c(c)->m();
+        expr * _a        = to_expr(a);
+        expr * _i        = to_expr(i);
+        expr * _v        = to_expr(v);
+        sort * a_ty = m.get_sort(_a);
+        sort * i_ty = m.get_sort(_i);
+        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);
+        }
+        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);
+        expr * args[3]        = {_a, _i, _v};
+        app * r        = m.mk_app(d, 3, args);
+        mk_c(c)->save_ast_trail(r);
+        check_sorts(c, r);
+        RETURN_Z3(of_ast(r));
+        Z3_CATCH_RETURN(0);
+    }
+  
+    Z3_ast Z3_API Z3_mk_map(__in Z3_context c, __in Z3_func_decl f, unsigned n, __in Z3_ast const* args) {
+        Z3_TRY;
+        LOG_Z3_mk_map(c, f, n, args);
+        RESET_ERROR_CODE();
+        if (n == 0) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        ast_manager & m = mk_c(c)->m();
+        func_decl* _f      = to_func_decl(f);
+        expr* const* _args = to_exprs(args);
+        
+        ptr_vector<sort> domain;
+        for (unsigned i = 0; i < n; ++i) {
+            domain.push_back(m.get_sort(_args[i]));
+        }
+        parameter param(_f);
+        func_decl * d = m.mk_func_decl(mk_c(c)->get_array_fid(), OP_ARRAY_MAP, 1, &param, n, domain.c_ptr());
+        app* r = m.mk_app(d, n, _args);
+        mk_c(c)->save_ast_trail(r);
+        check_sorts(c, r);
+        RETURN_Z3(of_ast(r));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_mk_const_array(__in Z3_context c, __in Z3_sort domain, __in Z3_ast v) {
+        Z3_TRY;
+        LOG_Z3_mk_const_array(c, domain, v);
+        RESET_ERROR_CODE(); 
+        ast_manager & m = mk_c(c)->m();
+        expr * _v        = to_expr(v);
+        sort * _range = m.get_sort(_v);
+        sort * _domain = to_sort(domain);
+        parameter params[2]  = { parameter(_domain), parameter(_range) };
+        sort * a_ty    = mk_c(c)->m().mk_sort(mk_c(c)->get_array_fid(), ARRAY_SORT, 2, params);
+        parameter param(a_ty);
+        func_decl* cd   = m.mk_func_decl(mk_c(c)->get_array_fid(), OP_CONST_ARRAY, 1, &param, 1, &_range);
+        app * r        = m.mk_app(cd, 1, &_v);
+        mk_c(c)->save_ast_trail(r);
+        check_sorts(c, r);
+        RETURN_Z3(of_ast(r));        
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_mk_array_default(__in Z3_context c, __in Z3_ast array) {
+        Z3_TRY;
+        LOG_Z3_mk_array_default(c, array);
+        RESET_ERROR_CODE(); 
+        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);
+        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_ast mk_app_array_core(__in Z3_context c, __in Z3_sort domain, __in Z3_ast v) {
+        RESET_ERROR_CODE();   
+        ast_manager & m = mk_c(c)->m();
+        expr * _v        = to_expr(v);
+        sort * _range = m.get_sort(_v);
+        sort * _domain = to_sort(domain);
+        parameter params[2]  = { parameter(_domain), parameter(_range) };
+        sort * a_ty    = mk_c(c)->m().mk_sort(mk_c(c)->get_array_fid(), ARRAY_SORT, 2, params);
+        parameter param(a_ty);
+        func_decl * cd   = m.mk_func_decl(mk_c(c)->get_array_fid(), OP_CONST_ARRAY, 1, &param, 1, &_range);
+        app * r        = m.mk_app(cd, 1, &_v);
+        mk_c(c)->save_ast_trail(r);
+        check_sorts(c, r);
+        return of_ast(r);
+    }
+
+    Z3_sort Z3_API Z3_mk_set_sort(__in Z3_context c, __in Z3_sort ty) {
+        Z3_TRY;
+        return Z3_mk_array_sort(c, ty, Z3_mk_bool_sort(c));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_mk_empty_set(__in Z3_context c, __in Z3_sort domain) {
+        Z3_TRY;
+        LOG_Z3_mk_empty_set(c, domain);
+        RESET_ERROR_CODE();
+        Z3_ast r = mk_app_array_core(c, domain, Z3_mk_false(c));
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_mk_full_set(__in Z3_context c, __in Z3_sort domain) {
+        Z3_TRY;
+        LOG_Z3_mk_full_set(c, domain);
+        RESET_ERROR_CODE();
+        Z3_ast r = mk_app_array_core(c, domain, Z3_mk_true(c));
+        RETURN_Z3(r);  
+        Z3_CATCH_RETURN(0);
+    }
+
+    MK_NARY(Z3_mk_set_union, mk_c(c)->get_array_fid(), OP_SET_UNION, SKIP);
+    MK_NARY(Z3_mk_set_intersect, mk_c(c)->get_array_fid(), OP_SET_INTERSECT, SKIP);
+    MK_BINARY(Z3_mk_set_difference, mk_c(c)->get_array_fid(), OP_SET_DIFFERENCE, SKIP);
+    MK_UNARY(Z3_mk_set_complement, mk_c(c)->get_array_fid(), OP_SET_COMPLEMENT, SKIP);
+    MK_BINARY(Z3_mk_set_subset, mk_c(c)->get_array_fid(), OP_SET_SUBSET, SKIP);
+    
+    Z3_ast Z3_mk_set_member(__in Z3_context c, __in Z3_ast elem, __in Z3_ast set) {
+        return Z3_mk_select(c, set, elem);
+    }
+
+    Z3_ast Z3_mk_set_add(__in Z3_context c, __in Z3_ast set, __in Z3_ast elem) {
+        return Z3_mk_store(c, set, elem, Z3_mk_true(c));
+    }
+
+    Z3_ast Z3_mk_set_del(__in Z3_context c, __in Z3_ast set, __in Z3_ast elem) {
+        return Z3_mk_store(c, set, elem, Z3_mk_false(c));
+    }
+
+    Z3_sort Z3_API Z3_get_array_sort_domain(Z3_context c, Z3_sort t) {
+        Z3_TRY;
+        LOG_Z3_get_array_sort_domain(c, t);
+        RESET_ERROR_CODE();
+        CHECK_VALID_AST(t, 0); 
+        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);
+    }
+    
+    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);
+        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(1).get_ast());
+            RETURN_Z3(r);
+        }
+        SET_ERROR_CODE(Z3_INVALID_ARG);
+        RETURN_Z3(0);
+        Z3_CATCH_RETURN(0);
+    }
+
+};

src/api/api_ast_map.cpp

@@ -0,0 +1,169 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_ast_map.cpp
+
+Abstract:
+    API for creating AST maps
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-09.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_ast_map.h"
+#include"api_ast_vector.h"
+#include"ast_smt2_pp.h"
+#include"dec_ref_util.h"
+
+Z3_ast_map_ref::~Z3_ast_map_ref() {
+    dec_ref_key_values(m, m_map);
+}
+
+extern "C" {
+
+    Z3_ast_map Z3_API Z3_mk_ast_map(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_mk_ast_map(c);
+        RESET_ERROR_CODE();
+        Z3_ast_map_ref * m = alloc(Z3_ast_map_ref, mk_c(c)->m());
+        mk_c(c)->save_object(m);
+        Z3_ast_map r       = of_ast_map(m);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_ast_map_inc_ref(Z3_context c, Z3_ast_map m) {
+        Z3_TRY;
+        LOG_Z3_ast_map_inc_ref(c, m);
+        RESET_ERROR_CODE();
+        to_ast_map(m)->inc_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_ast_map_dec_ref(Z3_context c, Z3_ast_map m) {
+        Z3_TRY;
+        LOG_Z3_ast_map_dec_ref(c, m);
+        RESET_ERROR_CODE();
+        to_ast_map(m)->dec_ref();
+        Z3_CATCH;
+    }
+
+    Z3_bool Z3_API Z3_ast_map_contains(Z3_context c, Z3_ast_map m, Z3_ast k) {
+        Z3_TRY;
+        LOG_Z3_ast_map_contains(c, m, k);
+        RESET_ERROR_CODE();
+        return to_ast_map_ref(m).contains(to_ast(k));
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    Z3_ast Z3_API Z3_ast_map_find(Z3_context c, Z3_ast_map m, Z3_ast k) {
+        Z3_TRY;
+        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) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        else {
+            ast * r = entry->get_data().m_value;
+            RETURN_Z3(of_ast(r));
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_ast_map_insert(Z3_context c, Z3_ast_map m, Z3_ast k, Z3_ast v) {
+        Z3_TRY;
+        LOG_Z3_ast_map_insert(c, m, k, v);
+        RESET_ERROR_CODE();
+        ast_manager & mng = to_ast_map(m)->m;
+        obj_map<ast, ast*>::obj_map_entry * entry = to_ast_map_ref(m).insert_if_not_there2(to_ast(k), 0);
+        if (entry->get_data().m_value == 0) {
+            // new entry
+            mng.inc_ref(to_ast(k));
+            mng.inc_ref(to_ast(v));
+            entry->get_data().m_value = to_ast(v);            
+        }
+        else {
+            // replacing entry
+            mng.inc_ref(to_ast(v));
+            mng.dec_ref(entry->get_data().m_value);
+            entry->get_data().m_value = to_ast(v);
+        }
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_ast_map_reset(Z3_context c, Z3_ast_map m) {
+        Z3_TRY;
+        LOG_Z3_ast_map_reset(c, m);
+        RESET_ERROR_CODE();
+        dec_ref_key_values(to_ast_map(m)->m, to_ast_map_ref(m));
+        SASSERT(to_ast_map_ref(m).empty());
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_ast_map_erase(Z3_context c, Z3_ast_map m, Z3_ast k) {
+        Z3_TRY;
+        LOG_Z3_ast_map_erase(c, m, k);
+        RESET_ERROR_CODE();
+        ast * v = 0;
+        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;
+            mng.dec_ref(to_ast(k));
+            mng.dec_ref(v);
+        }
+        Z3_CATCH;
+    }
+    
+    unsigned Z3_API Z3_ast_map_size(Z3_context c, Z3_ast_map m) {
+        Z3_TRY;
+        LOG_Z3_ast_map_size(c, m);
+        RESET_ERROR_CODE();
+        return to_ast_map_ref(m).size();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast_vector Z3_API Z3_ast_map_keys(Z3_context c, Z3_ast_map m) {
+        Z3_TRY;
+        LOG_Z3_ast_map_keys(c, m);
+        RESET_ERROR_CODE();
+        Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, to_ast_map(m)->m);
+        mk_c(c)->save_object(v);
+        obj_map<ast, ast*>::iterator it  = to_ast_map_ref(m).begin();
+        obj_map<ast, ast*>::iterator end = to_ast_map_ref(m).end();
+        for (; it != end; ++it) {
+            v->m_ast_vector.push_back(it->m_key);
+        }
+        Z3_ast_vector r       = of_ast_vector(v);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_string Z3_API Z3_ast_map_to_string(Z3_context c, Z3_ast_map m) {
+        Z3_TRY;
+        LOG_Z3_ast_map_to_string(c, m);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        ast_manager & mng = to_ast_map(m)->m;
+        buffer << "(ast-map";
+        obj_map<ast, ast*>::iterator it  = to_ast_map_ref(m).begin();
+        obj_map<ast, ast*>::iterator end = to_ast_map_ref(m).end();
+        for (; it != end; ++it) {
+            buffer << "\n  (" << mk_ismt2_pp(it->m_key, mng, 3) << "\n   " << mk_ismt2_pp(it->m_value, mng, 3) << ")";
+        }
+        buffer << ")";
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN(0);
+    }
+
+};

src/api/api_ast_map.h

@@ -0,0 +1,35 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_ast_map.h
+
+Abstract:
+    API for creating AST maps
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-09.
+
+Revision History:
+
+--*/
+#ifndef _API_AST_MAP_H_
+#define _API_AST_MAP_H_
+
+#include"api_util.h"
+#include"obj_hashtable.h"
+
+struct Z3_ast_map_ref : public api::object {
+    ast_manager &            m;
+    obj_map<ast, ast*> m_map;
+    Z3_ast_map_ref(ast_manager & _m):m(_m) {}
+    virtual ~Z3_ast_map_ref();
+};
+
+inline Z3_ast_map_ref * to_ast_map(Z3_ast_map v) { return reinterpret_cast<Z3_ast_map_ref *>(v); }
+inline Z3_ast_map of_ast_map(Z3_ast_map_ref * v) { return reinterpret_cast<Z3_ast_map>(v); }
+inline obj_map<ast, ast*> & to_ast_map_ref(Z3_ast_map v) { return to_ast_map(v)->m_map; }
+
+#endif

src/api/api_ast_vector.cpp

@@ -0,0 +1,140 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_ast_vector.cpp
+
+Abstract:
+    API for creating AST vectors
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-09.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_ast_vector.h"
+#include"ast_translation.h"
+#include"ast_smt2_pp.h"
+
+extern "C" {
+
+    Z3_ast_vector Z3_API Z3_mk_ast_vector(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_mk_ast_vector(c);
+        RESET_ERROR_CODE();
+        Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, mk_c(c)->m());
+        mk_c(c)->save_object(v);
+        Z3_ast_vector r       = of_ast_vector(v);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_ast_vector_inc_ref(Z3_context c, Z3_ast_vector v) {
+        Z3_TRY;
+        LOG_Z3_ast_vector_inc_ref(c, v);
+        RESET_ERROR_CODE();
+        to_ast_vector(v)->inc_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_ast_vector_dec_ref(Z3_context c, Z3_ast_vector v) {
+        Z3_TRY;
+        LOG_Z3_ast_vector_dec_ref(c, v);
+        RESET_ERROR_CODE();
+        to_ast_vector(v)->dec_ref();
+        Z3_CATCH;
+    }
+    
+    unsigned Z3_API Z3_ast_vector_size(Z3_context c, Z3_ast_vector v) {
+        Z3_TRY;
+        LOG_Z3_ast_vector_size(c, v);
+        RESET_ERROR_CODE();
+        return to_ast_vector_ref(v).size();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_ast_vector_get(Z3_context c, Z3_ast_vector v, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_ast_vector_get(c, v, i);
+        RESET_ERROR_CODE();
+        if (i >= to_ast_vector_ref(v).size()) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        // 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);
+    }
+
+    void Z3_API Z3_ast_vector_set(Z3_context c, Z3_ast_vector v, unsigned i, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_ast_vector_set(c, v, i, a);
+        RESET_ERROR_CODE();
+        if (i >= to_ast_vector_ref(v).size()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return;
+        }
+        to_ast_vector_ref(v).set(i, to_ast(a));
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_ast_vector_resize(Z3_context c, Z3_ast_vector v, unsigned n) {
+        Z3_TRY;
+        LOG_Z3_ast_vector_resize(c, v, n);
+        RESET_ERROR_CODE();
+        to_ast_vector_ref(v).resize(n);
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_ast_vector_push(Z3_context c, Z3_ast_vector v, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_ast_vector_push(c, v, a);
+        RESET_ERROR_CODE();
+        to_ast_vector_ref(v).push_back(to_ast(a));
+        Z3_CATCH;
+    }
+
+    Z3_ast_vector Z3_API Z3_ast_vector_translate(Z3_context c, Z3_ast_vector v, Z3_context t) {
+        Z3_TRY;
+        LOG_Z3_ast_vector_translate(c, v, t);
+        RESET_ERROR_CODE();
+        if (c == t) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        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)->m());
+        mk_c(t)->save_object(new_v);
+        unsigned sz = to_ast_vector_ref(v).size();
+        for (unsigned i = 0; i < sz; i++) {
+            ast * new_ast = translator(to_ast_vector_ref(v).get(i));
+            new_v->m_ast_vector.push_back(new_ast);
+        }
+        RETURN_Z3(of_ast_vector(new_v));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_string Z3_API Z3_ast_vector_to_string(Z3_context c, Z3_ast_vector v) {
+        Z3_TRY;
+        LOG_Z3_ast_vector_to_string(c, v);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        buffer << "(ast-vector";
+        unsigned sz = to_ast_vector_ref(v).size();
+        for (unsigned i = 0; i < sz; i++) {
+            buffer << "\n  " << mk_ismt2_pp(to_ast_vector_ref(v).get(i), mk_c(c)->m(), 2);
+        }
+        buffer << ")";
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN(0);
+    }
+
+};

src/api/api_ast_vector.h

@@ -0,0 +1,33 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_ast_vector.h
+
+Abstract:
+    API for creating AST vectors
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-09.
+
+Revision History:
+
+--*/
+#ifndef _API_AST_VECTOR_H_
+#define _API_AST_VECTOR_H_
+
+#include"api_util.h"
+
+struct Z3_ast_vector_ref : public api::object {
+    ast_ref_vector  m_ast_vector;
+    Z3_ast_vector_ref(ast_manager & m):m_ast_vector(m) {}
+    virtual ~Z3_ast_vector_ref() {}
+};
+
+inline Z3_ast_vector_ref * to_ast_vector(Z3_ast_vector v) { return reinterpret_cast<Z3_ast_vector_ref *>(v); }
+inline Z3_ast_vector of_ast_vector(Z3_ast_vector_ref * v) { return reinterpret_cast<Z3_ast_vector>(v); }
+inline ast_ref_vector & to_ast_vector_ref(Z3_ast_vector v) { return to_ast_vector(v)->m_ast_vector; }
+
+#endif

src/api/api_bv.cpp

@@ -0,0 +1,320 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_bv.cpp
+
+Abstract:
+    API for bv theory
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"bv_decl_plugin.h"
+
+extern "C" {
+
+    Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz) {
+        Z3_TRY;
+        LOG_Z3_mk_bv_sort(c, sz);
+        RESET_ERROR_CODE(); 
+        if (sz == 0) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+        }
+        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);
+    }
+
+#define MK_BV_UNARY(NAME, OP) MK_UNARY(NAME, mk_c(c)->get_bv_fid(), OP, SKIP)
+#define MK_BV_BINARY(NAME, OP) MK_BINARY(NAME, mk_c(c)->get_bv_fid(), OP, SKIP)
+    
+    MK_BV_UNARY(Z3_mk_bvnot, OP_BNOT);
+    MK_BV_UNARY(Z3_mk_bvredand, OP_BREDAND);
+    MK_BV_UNARY(Z3_mk_bvredor, OP_BREDOR);
+    MK_BV_BINARY(Z3_mk_bvand, OP_BAND);
+    MK_BV_BINARY(Z3_mk_bvor, OP_BOR);
+    MK_BV_BINARY(Z3_mk_bvxor, OP_BXOR);
+    MK_BV_BINARY(Z3_mk_bvnand, OP_BNAND);
+    MK_BV_BINARY(Z3_mk_bvnor, OP_BNOR);
+    MK_BV_BINARY(Z3_mk_bvxnor, OP_BXNOR);
+    MK_BV_BINARY(Z3_mk_bvadd, OP_BADD);
+    MK_BV_BINARY(Z3_mk_bvmul, OP_BMUL);
+    MK_BV_BINARY(Z3_mk_bvudiv, OP_BUDIV);
+    MK_BV_BINARY(Z3_mk_bvsdiv, OP_BSDIV);
+    MK_BV_BINARY(Z3_mk_bvurem, OP_BUREM);
+    MK_BV_BINARY(Z3_mk_bvsrem, OP_BSREM);
+    MK_BV_BINARY(Z3_mk_bvsmod, OP_BSMOD);
+    MK_BV_BINARY(Z3_mk_bvule, OP_ULEQ);
+    MK_BV_BINARY(Z3_mk_bvsle, OP_SLEQ);
+    MK_BV_BINARY(Z3_mk_bvuge, OP_UGEQ);
+    MK_BV_BINARY(Z3_mk_bvsge, OP_SGEQ);
+    MK_BV_BINARY(Z3_mk_bvult, OP_ULT);
+    MK_BV_BINARY(Z3_mk_bvslt, OP_SLT);
+    MK_BV_BINARY(Z3_mk_bvugt, OP_UGT);
+    MK_BV_BINARY(Z3_mk_bvsgt, OP_SGT);
+    MK_BV_BINARY(Z3_mk_concat, OP_CONCAT);
+    MK_BV_BINARY(Z3_mk_bvshl, OP_BSHL);
+    MK_BV_BINARY(Z3_mk_bvlshr, OP_BLSHR);
+    MK_BV_BINARY(Z3_mk_bvashr, OP_BASHR);
+    MK_BV_BINARY(Z3_mk_ext_rotate_left, OP_EXT_ROTATE_LEFT);
+    MK_BV_BINARY(Z3_mk_ext_rotate_right, OP_EXT_ROTATE_RIGHT);
+
+    Z3_ast mk_extract_core(Z3_context c, unsigned high, unsigned low, Z3_ast n) {
+        expr * _n = to_expr(n);
+        parameter params[2] = { parameter(high), parameter(low) };
+        expr * a = mk_c(c)->m().mk_app(mk_c(c)->get_bv_fid(), OP_EXTRACT, 2, params, 1, &_n);
+        mk_c(c)->save_ast_trail(a);  
+        check_sorts(c, a);
+        return of_ast(a);
+    }
+    
+    Z3_ast Z3_API Z3_mk_extract(Z3_context c, unsigned high, unsigned low, Z3_ast n) {
+        Z3_TRY;
+        LOG_Z3_mk_extract(c, high, low, n);
+        RESET_ERROR_CODE();
+        Z3_ast r = mk_extract_core(c, high, low, n);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+    
+#define MK_BV_PUNARY(NAME, OP)                                          \
+Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) {                \
+    Z3_TRY;                                                             \
+    LOG_ ## NAME(c, i, n);                                              \
+    RESET_ERROR_CODE();                                                 \
+    expr * _n = to_expr(n);                                             \
+    parameter p(i);                                                     \
+    ast* a = mk_c(c)->m().mk_app(mk_c(c)->get_bv_fid(), OP, 1, &p, 1, &_n); \
+    mk_c(c)->save_ast_trail(a);                                         \
+    check_sorts(c, a);                                                  \
+    RETURN_Z3(of_ast(a));                                               \
+    Z3_CATCH_RETURN(0);                                                 \
+}
+
+    MK_BV_PUNARY(Z3_mk_sign_ext, OP_SIGN_EXT);
+    MK_BV_PUNARY(Z3_mk_zero_ext, OP_ZERO_EXT);
+    MK_BV_PUNARY(Z3_mk_repeat,   OP_REPEAT);
+    MK_BV_PUNARY(Z3_mk_rotate_left, OP_ROTATE_LEFT);
+    MK_BV_PUNARY(Z3_mk_rotate_right, OP_ROTATE_RIGHT);
+    MK_BV_PUNARY(Z3_mk_int2bv, OP_INT2BV);
+
+    Z3_ast Z3_API Z3_mk_bv2int(Z3_context c, Z3_ast n, Z3_bool is_signed) {
+        Z3_TRY;
+        LOG_Z3_mk_bv2int(c, n, is_signed);
+        RESET_ERROR_CODE();                                                         
+        Z3_sort int_s = Z3_mk_int_sort(c);
+        if (is_signed) {
+            Z3_ast r = Z3_mk_bv2int(c, n, false);
+            Z3_sort s = Z3_get_sort(c, n);
+            unsigned sz = Z3_get_bv_sort_size(c, s);
+            rational max_bound = power(rational(2), sz);
+            Z3_ast bound = Z3_mk_numeral(c, max_bound.to_string().c_str(), int_s);
+            Z3_ast pred = Z3_mk_bvslt(c, n, Z3_mk_int(c, 0, s));        
+            // if n <_sigend 0 then r - s^sz else r
+            Z3_ast args[2] = { r, bound };
+            Z3_ast res = Z3_mk_ite(c, pred, Z3_mk_sub(c, 2, args), r);
+            RETURN_Z3(res);
+        }
+        else {
+            expr * _n = to_expr(n);                                                     
+            parameter p(to_sort(int_s));                                                             
+            ast* a = mk_c(c)->m().mk_app(mk_c(c)->get_bv_fid(), OP_BV2INT, 1, &p, 1, &_n);   
+            mk_c(c)->save_ast_trail(a);                                                 
+            check_sorts(c, a);                                                          
+            RETURN_Z3(of_ast(a)); 
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    /**
+       \brief \mlh mk_bvmsb c s \endmlh
+       Create a bit-vector of sort \s with 1 in the most significant bit position.
+       
+       The sort \s must be a bit-vector sort.
+
+       This function is a shorthand for <tt>shl(1, N-1)</tt>
+       where <tt>N</tt> are the number of bits of \c s.
+    */
+    Z3_ast Z3_API Z3_mk_bvmsb(__in Z3_context c, __in Z3_sort s) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        // Not logging this one, since it is just syntax sugar.
+        unsigned sz = Z3_get_bv_sort_size(c, s);
+        if (sz == 0) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return 0;
+        }
+        return Z3_mk_bvshl(c, Z3_mk_int64(c, 1, s), Z3_mk_int64(c, sz - 1, s));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_mk_bvsmin(__in Z3_context c, __in Z3_sort s) {
+        return Z3_mk_bvmsb(c, s);
+    }
+
+    Z3_ast Z3_mk_bvsmax(__in Z3_context c, __in Z3_sort s) {
+        return Z3_mk_bvnot(c, Z3_mk_bvmsb(c, s));
+    }
+
+    Z3_ast Z3_mk_bvumax(__in Z3_context c, __in Z3_sort s) {
+        return Z3_mk_int(c, -1, s);
+    }
+
+    Z3_ast Z3_API Z3_mk_bvadd_no_overflow(__in Z3_context c, __in Z3_ast t1, __in Z3_ast t2, Z3_bool is_signed) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        if (is_signed) {
+            Z3_ast zero = Z3_mk_int(c, 0, Z3_get_sort(c, t1));
+            Z3_ast r = Z3_mk_bvadd(c, t1, t2);
+            Z3_ast args[2] = { Z3_mk_bvslt(c, zero, t1), Z3_mk_bvslt(c, zero, t2) };
+            Z3_ast args_pos = Z3_mk_and(c, 2, args);
+            return Z3_mk_implies(c, args_pos, Z3_mk_bvslt(c, zero, r));
+        }
+        else {
+            unsigned sz = Z3_get_bv_sort_size(c, Z3_get_sort(c, t1));
+            t1 = Z3_mk_zero_ext(c, 1, t1);
+            t2 = Z3_mk_zero_ext(c, 1, t2);
+            Z3_ast r = Z3_mk_bvadd(c, t1, t2);
+            return Z3_mk_eq(c, Z3_mk_extract(c, sz, sz, r), Z3_mk_int(c, 0, Z3_mk_bv_sort(c, 1)));
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    // only for signed machine integers
+    Z3_ast Z3_API Z3_mk_bvadd_no_underflow(__in Z3_context c, __in Z3_ast t1, __in Z3_ast t2) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        Z3_ast zero = Z3_mk_int(c, 0, Z3_get_sort(c, t1));
+        Z3_ast r = Z3_mk_bvadd(c, t1, t2);
+        Z3_ast args[2] = { Z3_mk_bvslt(c, t1, zero), Z3_mk_bvslt(c, t2, zero) };
+        Z3_ast args_neg = Z3_mk_and(c, 2, args);
+        return Z3_mk_implies(c, args_neg, Z3_mk_bvslt(c, r, zero));
+        Z3_CATCH_RETURN(0);
+    }
+
+    // only for signed machine integers
+    Z3_ast Z3_API Z3_mk_bvsub_no_overflow(__in Z3_context c, __in Z3_ast t1, __in Z3_ast t2) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        Z3_sort s = Z3_get_sort(c, t2);
+        Z3_ast minus_t2 = Z3_mk_bvneg(c, t2);
+        Z3_ast min = Z3_mk_bvsmin(c, s);
+        return Z3_mk_ite(c, Z3_mk_eq(c, t2, min), 
+                         Z3_mk_bvslt(c, t1, Z3_mk_int(c, 0, s)),
+                         Z3_mk_bvadd_no_overflow(c, t1, minus_t2, true));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_mk_bvsub_no_underflow(__in Z3_context c, __in Z3_ast t1, __in Z3_ast t2, Z3_bool is_signed) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        if (is_signed) {
+            Z3_ast zero = Z3_mk_int(c, 0, Z3_get_sort(c, t1));
+            if (Z3_get_error_code(c) != Z3_OK) return 0;
+            Z3_ast minus_t2 = Z3_mk_bvneg(c, t2);
+            if (Z3_get_error_code(c) != Z3_OK) return 0;
+            return Z3_mk_implies(c, Z3_mk_bvslt(c, zero, t2), Z3_mk_bvadd_no_underflow(c, t1, minus_t2));
+        }
+        else {
+            return Z3_mk_bvule(c, t2, t1);
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_mk_bvmul_no_overflow(__in Z3_context c, __in Z3_ast n1, __in Z3_ast n2, Z3_bool is_signed) {
+        LOG_Z3_mk_bvmul_no_overflow(c, n1, n2, is_signed);
+        RESET_ERROR_CODE();
+        if (is_signed) {
+            MK_BINARY_BODY(Z3_mk_bvmul_no_overflow, mk_c(c)->get_bv_fid(), OP_BSMUL_NO_OVFL, SKIP);
+        }
+        else {
+            MK_BINARY_BODY(Z3_mk_bvmul_no_overflow, mk_c(c)->get_bv_fid(), OP_BUMUL_NO_OVFL, SKIP);
+        }
+    }
+
+    // only for signed machine integers
+    Z3_ast Z3_API Z3_mk_bvmul_no_underflow(__in Z3_context c, __in Z3_ast n1, __in Z3_ast n2) {
+        LOG_Z3_mk_bvmul_no_underflow(c, n1, n2);
+        MK_BINARY_BODY(Z3_mk_bvmul_no_underflow, mk_c(c)->get_bv_fid(), OP_BSMUL_NO_UDFL, SKIP);
+    }
+
+    // only for signed machine integers
+    Z3_ast Z3_API Z3_mk_bvneg_no_overflow(__in Z3_context c, __in Z3_ast t) {
+        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;
+        Z3_ast eq  = Z3_mk_eq(c, t, min);
+        if (Z3_get_error_code(c) != Z3_OK) return 0;
+        return Z3_mk_not(c, eq);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    // only for signed machine integers
+    Z3_ast Z3_API Z3_mk_bvsdiv_no_overflow(__in Z3_context c, __in Z3_ast t1, __in Z3_ast t2) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        Z3_sort s = Z3_get_sort(c, t1);
+        if (Z3_get_error_code(c) != Z3_OK) return 0;
+        Z3_ast min = Z3_mk_bvmsb(c, s);
+        if (Z3_get_error_code(c) != Z3_OK) return 0;
+        Z3_ast args[2] = { Z3_mk_eq(c, t1, min),
+                           Z3_mk_eq(c, t2, Z3_mk_int(c, -1, s)) };
+        return Z3_mk_not(c, Z3_mk_and(c, 2, args));
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_ast Z3_API Z3_mk_bvsub(Z3_context c, Z3_ast n1, Z3_ast n2) {
+        Z3_TRY;
+        LOG_Z3_mk_bvsub(c, n1, n2);
+        RESET_ERROR_CODE();
+        // TODO: Do we really need this pre_simplifier hack?
+        if (mk_c(c)->fparams().m_pre_simplify_expr) {
+            Z3_ast m1 = Z3_mk_int(c, -1, Z3_get_sort(c, n2));
+            Z3_ast r = Z3_mk_bvadd(c, n1, Z3_mk_bvmul(c, m1, n2));
+            RETURN_Z3(r);
+        }
+        MK_BINARY_BODY(Z3_mk_bvsub, mk_c(c)->get_bv_fid(), OP_BSUB, SKIP);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_mk_bvneg(Z3_context c, Z3_ast n) {
+        Z3_TRY;
+        LOG_Z3_mk_bvneg(c, n);
+        RESET_ERROR_CODE();
+        // TODO: Do we really need this pre_simplifier hack? 
+        if (mk_c(c)->fparams().m_pre_simplify_expr) {
+            Z3_ast m1 = Z3_mk_int(c, -1, Z3_get_sort(c, n));
+            Z3_ast r  = Z3_mk_bvmul(c, m1, n);
+            RETURN_Z3(r);
+        }
+        MK_UNARY_BODY(Z3_mk_bvneg, mk_c(c)->get_bv_fid(), OP_BNEG, SKIP);
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_API Z3_get_bv_sort_size(Z3_context c, Z3_sort t) {
+        Z3_TRY;
+        LOG_Z3_get_bv_sort_size(c, t);
+        RESET_ERROR_CODE(); 
+        CHECK_VALID_AST(t, 0);
+        if (to_sort(t)->get_family_id() == mk_c(c)->get_bv_fid() && to_sort(t)->get_decl_kind() == BV_SORT) {
+            return to_sort(t)->get_parameter(0).get_int();
+        }
+        SET_ERROR_CODE(Z3_INVALID_ARG);
+        return 0;
+        Z3_CATCH_RETURN(0);
+    }
+    
+};

src/api/api_config_params.cpp

@@ -0,0 +1,122 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_config_params.cpp
+
+Abstract:
+    Configuration parameters
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include"z3.h"
+#include"api_context.h"
+#include"api_config_params.h"
+#include"pp.h"
+#include"api_log_macros.h"
+#include"api_util.h"
+#include"symbol.h"
+
+namespace api {
+
+    config_params::config_params():
+        m_ini(false /* do not abort on errors */) {
+        register_verbosity_level(m_ini);
+        register_warning(m_ini);
+        m_params.register_params(m_ini); 
+        register_pp_params(m_ini);
+    }
+    
+    config_params::config_params(front_end_params const & p):m_params(p) {
+        register_verbosity_level(m_ini);
+        register_warning(m_ini);
+        register_pp_params(m_ini);
+    }
+
+};
+
+extern std::string smt_keyword2opt_name(symbol const & opt);
+
+extern "C" {
+    Z3_config Z3_API Z3_mk_config() {
+        LOG_Z3_mk_config();
+        memory::initialize(0);
+        Z3_config r = reinterpret_cast<Z3_config>(alloc(api::config_params));
+        RETURN_Z3(r);
+    }
+    
+    void Z3_API Z3_del_config(Z3_config c) {
+        LOG_Z3_del_config(c);
+        dealloc((reinterpret_cast<api::config_params*>(c)));
+    }
+    
+    void Z3_API Z3_set_param_value(Z3_config c, char const * param_id, char const * param_value) {
+        try { 
+            LOG_Z3_set_param_value(c, param_id, param_value);
+            api::config_params* p = reinterpret_cast<api::config_params*>(c);
+            if (param_id != 0 && param_id[0] == ':') {
+                // Allow SMT2 style paramater names such as  :model, :relevancy, etc
+                std::string new_param_id = smt_keyword2opt_name(symbol(param_id));
+                p->m_ini.set_param_value(new_param_id.c_str(), param_value);
+            }
+            else {
+                p->m_ini.set_param_value(param_id, param_value);
+            }
+        }
+        catch (set_get_param_exception & ex) {
+            // The error handler was not set yet.
+            // Just throw a warning.
+            std::ostringstream buffer;
+            buffer << "Error setting " << param_id << ", " << ex.get_msg();
+            warning_msg(buffer.str().c_str());
+        }
+    }
+
+    void Z3_API Z3_update_param_value(Z3_context c, Z3_string param_id, Z3_string param_value) {
+        LOG_Z3_update_param_value(c, param_id, param_value);
+        RESET_ERROR_CODE();
+        ini_params ini;        
+        mk_c(c)->fparams().register_params(ini);
+        register_pp_params(ini);
+        register_verbosity_level(ini);
+        register_warning(ini);
+        if (mk_c(c)->has_solver()) {
+            ini.freeze();
+        }
+        if (param_id != 0 && param_id[0] == ':') {
+            // Allow SMT2 style paramater names such as  :model, :relevancy, etc
+            std::string new_param_id = smt_keyword2opt_name(symbol(param_id));
+            ini.set_param_value(new_param_id.c_str(), param_value);
+        }
+        else {
+            ini.set_param_value(param_id, param_value);
+        }
+        memory::set_high_watermark(static_cast<size_t>(mk_c(c)->fparams().m_memory_high_watermark)*1024*1024);
+        memory::set_max_size(static_cast<size_t>(mk_c(c)->fparams().m_memory_max_size)*1024*1024);
+    }
+
+    Z3_bool Z3_API Z3_get_param_value(Z3_context c, Z3_string param_id, Z3_string* param_value) {
+        LOG_Z3_get_param_value(c, param_id, param_value);
+        ini_params ini;        
+        mk_c(c)->fparams().register_params(ini);
+        register_verbosity_level(ini);
+        register_pp_params(ini);
+        register_warning(ini);
+        std::string param_value_s;
+        if (!ini.get_param_value(param_id, param_value_s)) {
+            if (param_value) *param_value = 0;
+            return false;
+        }
+        if (param_value) {
+            *param_value = mk_c(c)->mk_external_string(param_value_s);
+        }
+        return true;
+    }
+
+};

src/api/api_config_params.h

@@ -0,0 +1,36 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_config_params.h
+
+Abstract:
+    Configuration parameters
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#ifndef _API_CONFIG_PARAMS_H_
+#define _API_CONFIG_PARAMS_H_
+
+#include"ini_file.h"
+#include"front_end_params.h"
+
+namespace api {
+
+    class config_params {
+    public:
+        ini_params       m_ini;
+        front_end_params m_params;
+        config_params();
+        config_params(front_end_params const & p);
+    };
+
+};
+
+#endif

src/api/api_context.cpp

@@ -0,0 +1,571 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_context.cpp
+
+Abstract:
+    Interface of Z3 with "external world".
+
+    It was called _Z3_context
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include"api_context.h"
+#include"api_config_params.h"
+#include"smtparser.h"
+#include"version.h"
+#include"ast_pp.h"
+#include"ast_ll_pp.h"
+#include"api_log_macros.h"
+#include"api_util.h"
+#include"install_tactics.h"
+
+namespace api {
+
+    static void default_error_handler(Z3_context, Z3_error_code c) {
+        printf("Error: %s\n", Z3_get_error_msg(c));
+        exit(1);
+    }
+
+    Z3_search_failure mk_Z3_search_failure(smt::failure f) {
+        switch(f) {
+        case smt::OK: return Z3_NO_FAILURE;
+        case smt::UNKNOWN: return Z3_UNKNOWN;
+        case smt::TIMEOUT: return Z3_TIMEOUT;
+        case smt::MEMOUT: return Z3_MEMOUT_WATERMARK;
+        case smt::CANCELED: return Z3_CANCELED;
+        case smt::NUM_CONFLICTS: return Z3_NUM_CONFLICTS;
+        case smt::THEORY: return Z3_THEORY;
+        case smt::QUANTIFIERS: return Z3_QUANTIFIERS;
+        default:
+            UNREACHABLE();
+            break;
+        }
+        return static_cast<Z3_search_failure>(f);
+    }
+
+    context::param_ini::param_ini(front_end_params & p) : m_params(p) {
+        p.open_trace_file();
+    }
+
+    context::param_ini::~param_ini() {
+        m_params.close_trace_file();
+    }
+        
+    context::add_plugins::add_plugins(ast_manager & m) {
+        m.register_decl_plugins();
+    }
+
+    // ------------------------
+    //
+    // Core
+    //
+    // ------------------------
+
+    context::set_interruptable::set_interruptable(context & ctx, event_handler & i):
+        m_ctx(ctx) {
+        #pragma omp critical (set_interruptable) 
+        {
+            SASSERT(m_ctx.m_interruptable == 0);
+            m_ctx.m_interruptable = &i;
+        }
+    }
+
+    context::set_interruptable::~set_interruptable() {
+        #pragma omp critical (set_interruptable) 
+        {
+            m_ctx.m_interruptable = 0;
+        }
+    }
+
+    context::context(config_params * p, bool user_ref_count):
+        m_params(p ? p->m_params : front_end_params()),
+        m_param_ini(m_params),
+        m_user_ref_count(user_ref_count),
+        m_manager(m_params.m_proof_mode, m_params.m_trace_stream),
+        m_plugins(m_manager),
+        m_arith_util(m_manager),
+        m_bv_util(m_manager),
+        m_datalog_util(m_manager),
+        m_last_result(m_manager),
+        m_ast_trail(m_manager),
+        m_replay_stack() {
+
+        m_solver     = 0;
+        m_error_code = Z3_OK;
+        m_print_mode = Z3_PRINT_SMTLIB_FULL;
+        m_searching  = false;
+        
+        m_interruptable = 0;
+
+        m_smtlib_parser           = 0;
+        m_smtlib_parser_has_decls = false;
+        
+        z3_bound_num_procs();
+        //
+        // Configuration parameter settings.
+        //
+        memory::set_high_watermark(static_cast<size_t>(m_params.m_memory_high_watermark)*1024*1024);
+        memory::set_max_size(static_cast<size_t>(m_params.m_memory_max_size)*1024*1024);
+        if (m_params.m_debug_ref_count) {
+            m_manager.debug_ref_count();
+        }
+        
+        m_error_handler = &default_error_handler;
+
+        m_basic_fid = m_manager.get_basic_family_id();
+        m_arith_fid = m_manager.get_family_id("arith");
+        m_bv_fid    = m_manager.get_family_id("bv");
+        m_array_fid = m_manager.get_family_id("array");
+        m_dt_fid    = m_manager.get_family_id("datatype");
+        m_datalog_fid = m_manager.get_family_id("datalog_relation");
+        m_dt_plugin = static_cast<datatype_decl_plugin*>(m_manager.get_plugin(m_dt_fid));
+
+        if (!m_user_ref_count) {
+            m_replay_stack.push_back(0);
+        }
+    
+        install_tactics(*this);
+    }
+
+
+    context::~context() {
+        m_last_obj = 0;
+        if (!m_user_ref_count) {
+            for (unsigned i = 0; i < m_replay_stack.size(); ++i) {
+                dealloc(m_replay_stack[i]);
+            }
+        }
+        reset_parser();
+        dealloc(m_solver);
+    }
+
+    void context::interrupt() {
+        #pragma omp critical (set_interruptable)
+        {
+            if (m_interruptable)
+                (*m_interruptable)();
+        }
+    }
+    
+    void context::set_error_code(Z3_error_code err) {
+        m_error_code = err; 
+        if (err != Z3_OK) 
+            invoke_error_handler(err); 
+    }
+
+    void context::check_searching() {
+        if (m_searching) { 
+            set_error_code(Z3_INVALID_USAGE); // TBD: error code could be fixed.
+        } 
+    }
+
+    char * context::mk_external_string(char const * str) {
+        m_string_buffer = str;
+        return const_cast<char *>(m_string_buffer.c_str());
+    }
+    
+    char * context::mk_external_string(std::string const & str) {
+        m_string_buffer = str;
+        return const_cast<char *>(m_string_buffer.c_str());
+    }
+
+    expr * context::mk_numeral_core(rational const & n, sort * s) {
+        expr* e = 0;
+        family_id fid  = s->get_family_id();
+        if (fid == m_arith_fid) {
+            e = m_arith_util.mk_numeral(n, s);
+        }
+        else if (fid == m_bv_fid) {
+            e = m_bv_util.mk_numeral(n, s);
+        }
+        else if (fid == get_datalog_fid() && n.is_uint64()) {
+            uint64 sz;
+            if (m_datalog_util.try_get_size(s, sz) && 
+                sz <= n.get_uint64()) {
+                invoke_error_handler(Z3_INVALID_ARG);
+            }
+            e = m_datalog_util.mk_numeral(n.get_uint64(), s);
+        }
+        else {
+            invoke_error_handler(Z3_INVALID_ARG);
+        }
+        save_ast_trail(e);
+        return e;    
+    }
+        
+    expr * context::mk_and(unsigned num_exprs, expr * const * exprs) {
+        switch(num_exprs) {
+        case 0: 
+            return m_manager.mk_true(); 
+        case 1: 
+            save_ast_trail(exprs[0]);
+            return exprs[0];
+        default: {
+            expr * a = m_manager.mk_and(num_exprs, exprs);
+            save_ast_trail(a);
+            return a;
+        } }
+    }
+
+    void context::persist_ast(ast * n, unsigned num_scopes) {
+        // persist_ast is irrelevant when m_user_ref_count == true
+        if (m_user_ref_count)
+            return;
+        if (num_scopes > m_ast_lim.size()) {
+            num_scopes = m_ast_lim.size();
+        }
+        SASSERT(m_replay_stack.size() > num_scopes);
+        unsigned j = m_replay_stack.size() - num_scopes - 1;
+        if (!m_replay_stack[j]) {
+            m_replay_stack[j] = alloc(ast_ref_vector, m_manager);
+        }
+        m_replay_stack[j]->push_back(n);
+    }
+
+    void context::save_ast_trail(ast * n) {
+        SASSERT(m().contains(n));
+        if (m_user_ref_count) {
+            // Corner case bug: n may be in m_last_result, and this is the only reference to n.
+            // When, we execute reset() it is deleted
+            // To avoid this bug, I bump the reference counter before reseting m_last_result
+            m().inc_ref(n);
+            m_last_result.reset();
+            m_last_result.push_back(n);
+            m().dec_ref(n);
+        }
+        else {
+            m_ast_trail.push_back(n);
+        }
+    }
+
+    void context::save_multiple_ast_trail(ast * n) {
+        if (m_user_ref_count)
+            m_last_result.push_back(n);
+        else
+            m_ast_trail.push_back(n);
+    }
+
+    void context::reset_last_result() {
+        if (m_user_ref_count)
+            m_last_result.reset();
+        m_last_obj = 0;
+    }
+
+    void context::save_object(object * r) {
+        m_last_obj = r;
+    }
+
+    void context::handle_exception(z3_exception & ex) {
+        if (ex.has_error_code()) {
+            switch(ex.error_code()) {
+            case ERR_MEMOUT: 
+                set_error_code(Z3_MEMOUT_FAIL);
+            break;
+            case ERR_PARSER: 
+                set_error_code(Z3_PARSER_ERROR);
+                break;
+            case ERR_INI_FILE: 
+                set_error_code(Z3_INVALID_ARG);
+                break;
+            case ERR_OPEN_FILE:
+                set_error_code(Z3_FILE_ACCESS_ERROR);
+                break;
+            default:
+                set_error_code(Z3_INTERNAL_FATAL);
+                break;
+            }
+        }
+        else {
+            m_exception_msg = ex.msg();
+            set_error_code(Z3_EXCEPTION); 
+        }
+    }
+    
+    void context::invoke_error_handler(Z3_error_code c) {
+        if (m_error_handler) {
+            if (g_z3_log) {
+                // error handler can do crazy stuff such as longjmp
+                g_z3_log_enabled = true;
+            }
+            m_error_handler(reinterpret_cast<Z3_context>(this), c);
+        }
+    }
+
+    void context::check_sorts(ast * n) {
+        if (!m().check_sorts(n)) {
+            switch(n->get_kind()) {
+            case AST_APP: {
+                std::ostringstream buffer;
+                app * a = to_app(n);
+                buffer << mk_pp(a->get_decl(), m()) << " applied to: ";
+                if (a->get_num_args() > 1) buffer << "\n";
+                for (unsigned i = 0; i < a->get_num_args(); ++i) {
+                    buffer << mk_bounded_pp(a->get_arg(i), m(), 3) << " of sort ";
+                    buffer << mk_pp(m().get_sort(a->get_arg(i)), m()) << "\n";
+                }
+                warning_msg("%s",buffer.str().c_str());
+                break;
+            }
+            case AST_VAR:
+            case AST_QUANTIFIER:
+            case AST_SORT:
+            case AST_FUNC_DECL:
+                break;
+            }
+            set_error_code(Z3_SORT_ERROR);
+        }
+    }
+
+    // ------------------------
+    //
+    // Solver interface for backward compatibility 
+    //
+    // ------------------------
+
+    smt::solver & context::get_solver() {
+        if (!m_solver) {
+            m_solver = alloc(smt::solver, m_manager, m_params);
+        }
+        return *m_solver;
+    }
+        
+    void context::assert_cnstr(expr * a) {
+        get_solver().assert_expr(a);
+    }
+    
+    lbool context::check(model_ref & m) {
+        flet<bool> searching(m_searching, true);
+        lbool r;
+        r = get_solver().check();
+        if (r != l_false)
+            get_solver().get_model(m);
+        return r;
+    }
+    
+    void context::push() {
+        get_solver().push();
+        if (!m_user_ref_count) {
+            m_ast_lim.push_back(m_ast_trail.size());
+            m_replay_stack.push_back(0);
+        }
+    }
+    
+    void context::pop(unsigned num_scopes) {
+        for (unsigned i = 0; i < num_scopes; ++i) {
+            if (!m_user_ref_count) {
+                unsigned sz = m_ast_lim.back();
+                m_ast_lim.pop_back();
+                dealloc(m_replay_stack.back());
+                m_replay_stack.pop_back();
+                while (m_ast_trail.size() > sz) {
+                    m_ast_trail.pop_back();
+                }
+            }
+        }
+        get_solver().pop(num_scopes);
+    }
+
+    // ------------------------
+    //
+    // 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();
+        }
+    }
+};
+
+
+// ------------------------
+//
+// Context creation API
+//
+// ------------------------
+
+extern "C" {
+    
+    Z3_context Z3_API Z3_mk_context(Z3_config c) {
+        LOG_Z3_mk_context(c);
+        memory::initialize(0);
+        Z3_context r = reinterpret_cast<Z3_context>(alloc(api::context, reinterpret_cast<api::config_params*>(c), false));
+        RETURN_Z3(r);
+    }
+
+    Z3_context Z3_API Z3_mk_context_rc(Z3_config c) {
+        LOG_Z3_mk_context_rc(c);
+        memory::initialize(0);
+        Z3_context r = reinterpret_cast<Z3_context>(alloc(api::context, reinterpret_cast<api::config_params*>(c), true));
+        RETURN_Z3(r);
+    }
+
+    void Z3_API Z3_del_context(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_del_context(c);
+        RESET_ERROR_CODE();
+        dealloc(mk_c(c));
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_interrupt(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_interrupt(c);
+        mk_c(c)->interrupt();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_toggle_warning_messages(Z3_bool enabled) {
+        LOG_Z3_toggle_warning_messages(enabled);
+        enable_warning_messages(enabled != 0);
+    }
+
+    void Z3_API Z3_inc_ref(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_inc_ref(c, a);
+        RESET_ERROR_CODE();
+        mk_c(c)->m().inc_ref(to_ast(a));
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_dec_ref(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_dec_ref(c, a);
+        RESET_ERROR_CODE();
+        if (to_ast(a)->get_ref_count() == 0) {
+            SET_ERROR_CODE(Z3_DEC_REF_ERROR);
+            return;
+        }
+        mk_c(c)->m().dec_ref(to_ast(a));
+        Z3_CATCH;
+    }
+
+    Z3_bool Z3_API Z3_set_logic(Z3_context c, Z3_string logic) {
+        Z3_TRY;
+        LOG_Z3_set_logic(c, logic);
+        RESET_ERROR_CODE();
+        return mk_c(c)->get_solver().set_logic(symbol(logic));
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    void Z3_API Z3_get_version(unsigned * major, 
+                               unsigned * minor, 
+                               unsigned * build_number, 
+                               unsigned * revision_number) {
+        LOG_Z3_get_version(major, minor, build_number, revision_number);
+        *major           = Z3_MAJOR_VERSION;
+        *minor           = Z3_MINOR_VERSION;
+        *build_number    = Z3_BUILD_NUMBER;
+        *revision_number = Z3_REVISION_NUMBER;
+    }
+
+    void Z3_API Z3_reset_memory(void) {
+        LOG_Z3_reset_memory();
+        memory::finalize();
+        memory::initialize(0);
+    }
+
+    Z3_error_code Z3_API Z3_get_error_code(Z3_context c) {
+        LOG_Z3_get_error_code(c);
+        return mk_c(c)->get_error_code();
+    }
+
+    void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h) {
+        RESET_ERROR_CODE();    
+        mk_c(c)->set_error_handler(h);
+        // [Leo]: using exception handling, we don't need global error handlers anymore
+    }
+
+    void Z3_API Z3_set_error(__in Z3_context c, __in Z3_error_code e) {
+        SET_ERROR_CODE(e);
+    }
+
+    static char const * _get_error_msg_ex(Z3_context c, Z3_error_code err) {
+        switch(err) {
+        case Z3_OK:                return "ok";
+        case Z3_SORT_ERROR:        return "type error";
+        case Z3_IOB:               return "index out of bounds";
+        case Z3_INVALID_ARG:       return "invalid argument";
+        case Z3_PARSER_ERROR:      return "parser error";
+        case Z3_NO_PARSER:         return "parser (data) is not available";
+        case Z3_INVALID_PATTERN:   return "invalid pattern";
+        case Z3_MEMOUT_FAIL:       return "out of memory";
+        case Z3_FILE_ACCESS_ERROR: return "file access error";
+        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();
+        default:                   return "unknown";
+        }
+    }
+
+    char const * Z3_API Z3_get_error_msg(Z3_error_code err) {
+        LOG_Z3_get_error_msg(err);
+        return _get_error_msg_ex(0, err);
+    }
+
+    char const * Z3_API Z3_get_error_msg_ex(Z3_context c, Z3_error_code err) {
+        LOG_Z3_get_error_msg_ex(c, err);
+        return _get_error_msg_ex(c, err);
+    }
+
+    void Z3_API Z3_persist_ast(Z3_context c, Z3_ast n, unsigned num_scopes) {
+        Z3_TRY;
+        LOG_Z3_persist_ast(c, n, num_scopes);
+        RESET_ERROR_CODE();
+        CHECK_VALID_AST(to_ast(n), );
+        mk_c(c)->persist_ast(to_ast(n), num_scopes);
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_set_ast_print_mode(Z3_context c, Z3_ast_print_mode mode) {
+        Z3_TRY;
+        LOG_Z3_set_ast_print_mode(c, mode);
+        RESET_ERROR_CODE();
+        mk_c(c)->set_print_mode(mode);
+        Z3_CATCH;
+    }
+    
+};
+
+ast_manager & Z3_API Z3_get_manager(__in Z3_context c) {
+    return mk_c(c)->m();
+}
+
+front_end_params& Z3_API Z3_get_parameters(__in Z3_context c) {
+    return mk_c(c)->fparams();
+}
+
+Z3_context Z3_mk_context_from_params(front_end_params const& p) {
+    api::config_params cp(p);
+    return reinterpret_cast<Z3_context>(alloc(api::context, &cp));
+}

src/api/api_context.h

@@ -0,0 +1,216 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_context.h
+
+Abstract:
+    Interface of Z3 with "external world".
+
+    It was called _Z3_context
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#ifndef _API_CONTEXT_H_
+#define _API_CONTEXT_H_
+
+#include"z3.h"
+#include"ast.h"
+#include"api_util.h"
+#include"arith_decl_plugin.h"
+#include"bv_decl_plugin.h"
+#include"datatype_decl_plugin.h"
+#include"dl_decl_plugin.h"
+#include"smt_solver.h"
+#include"front_end_params.h"
+#include"event_handler.h"
+#include"tactic_manager.h"
+
+namespace smtlib {
+    class parser;
+};
+
+namespace api {
+    class config_params;
+
+    Z3_search_failure mk_Z3_search_failure(smt::failure f);
+       
+
+    class context : public tactic_manager {
+        class param_ini {
+            front_end_params & m_params;
+        public:
+            param_ini(front_end_params & p);
+            ~param_ini();
+        };
+        
+        struct add_plugins {  add_plugins(ast_manager & m); };
+        
+        front_end_params           m_params;
+        param_ini                  m_param_ini;
+        bool                       m_user_ref_count; //!< if true, the user is responsible for managing referenc counters.
+        ast_manager                m_manager;
+        add_plugins                m_plugins;
+
+        arith_util                 m_arith_util;
+        bv_util                    m_bv_util;
+        datalog::dl_decl_util      m_datalog_util;
+
+        smt::solver *              m_solver;     // General purpose solver for backward compatibility
+        
+        ast_ref_vector             m_last_result; //!< used when m_user_ref_count == true
+        ast_ref_vector             m_ast_trail;   //!< used when m_user_ref_count == false
+        unsigned_vector            m_ast_lim;
+        ptr_vector<ast_ref_vector> m_replay_stack;
+
+        ref<api::object>           m_last_obj; //!< reference to the last API object returned by the APIs
+
+        family_id                  m_basic_fid;
+        family_id                  m_array_fid;
+        family_id                  m_arith_fid;
+        family_id                  m_bv_fid;
+        family_id                  m_dt_fid;
+        family_id                  m_datalog_fid;
+        datatype_decl_plugin *     m_dt_plugin;
+        
+        std::string                m_string_buffer; // temporary buffer used to cache strings sent to the "external" world.
+
+        Z3_error_code              m_error_code;
+        Z3_error_handler *         m_error_handler;
+        std::string                m_exception_msg; // catch the message associated with a Z3 exception
+        bool                       m_searching;
+        Z3_ast_print_mode          m_print_mode;
+
+        event_handler *            m_interruptable; // Reference to an object that can be interrupted by Z3_interrupt
+    public:
+        // Scoped obj for setting m_interruptable
+        class set_interruptable {
+            context & m_ctx;
+        public:
+            set_interruptable(context & ctx, event_handler & i);
+            ~set_interruptable();
+        };
+
+        // ------------------------
+        //
+        // Core
+        //
+        // ------------------------
+        
+        context(config_params * p, bool user_ref_count = false);
+        ~context();
+
+        front_end_params & fparams() { return m_params; }
+        ast_manager & m() { return m_manager; }
+        arith_util & autil() { return m_arith_util; }
+        bv_util & bvutil() { return m_bv_util; }
+        datalog::dl_decl_util & datalog_util() { return m_datalog_util; }
+        family_id get_basic_fid() const { return m_basic_fid; }
+        family_id get_array_fid() const { return m_array_fid; }
+        family_id get_arith_fid() const { return m_arith_fid; }
+        family_id get_bv_fid() const { return m_bv_fid; }
+        family_id get_dt_fid() const { return m_dt_fid; }
+        family_id get_datalog_fid() const { return m_datalog_fid; }
+        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 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
+        void check_searching();
+
+        Z3_ast_print_mode get_print_mode() const { return m_print_mode; }
+        void set_print_mode(Z3_ast_print_mode m) { m_print_mode = m; }
+
+        // Store a copy of str in m_string_buffer, and return a reference to it.
+        // This method is used to communicate local/internal strings with the "external world"
+        char * mk_external_string(char const * str);
+        char * mk_external_string(std::string const & str);
+
+        // 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.
+        expr * mk_and(unsigned num_exprs, expr * const * exprs);
+
+        // Hack for preventing an AST for being GC when ref-count is not used
+        void persist_ast(ast * n, unsigned num_scopes);
+
+        // "Save" an AST that will exposed to the "external" world.
+        void save_ast_trail(ast * n);
+        
+        // Similar to previous method, but it "adds" n to the result.
+        void save_multiple_ast_trail(ast * n);
+        
+        // Reset the cache that stores the ASTs exposed in the previous call.
+        // This is a NOOP if ref-count is disabled.
+        void reset_last_result();
+        
+        // "Save" a reference to an object that is exposed by the API
+        void save_object(object * r);
+
+        // Process exception: save message and set error code.
+        void handle_exception(z3_exception & ex);
+        char const * get_exception_msg() const { return m_exception_msg.c_str(); }
+
+        // Interrupt the current interruptable object
+        void interrupt();
+
+        void invoke_error_handler(Z3_error_code c);
+        
+        static void out_of_memory_handler(void * _ctx);
+
+        void check_sorts(ast * n);
+        // ------------------------
+        //
+        // Solver interface for backward compatibility 
+        //
+        // ------------------------
+        
+        bool has_solver() const { return m_solver != 0; }
+        smt::solver & get_solver();
+        void assert_cnstr(expr * a);
+        lbool check(model_ref & m);
+        void push();
+        void pop(unsigned num_scopes);
+        unsigned get_num_scopes() const { return m_ast_lim.size(); }
+
+        // ------------------------
+        //
+        // Parser interface for backward compatibility 
+        //
+        // ------------------------
+
+        // 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();
+        
+    };
+    
+};
+
+inline api::context * mk_c(Z3_context c) { return reinterpret_cast<api::context*>(c); }
+#define RESET_ERROR_CODE() { mk_c(c)->reset_error_code(); }
+#define SET_ERROR_CODE(ERR) { mk_c(c)->set_error_code(ERR); }
+#define CHECK_NON_NULL(_p_,_ret_) { if (_p_ == 0) { SET_ERROR_CODE(Z3_INVALID_ARG); return _ret_; } }
+#define CHECK_VALID_AST(_a_, _ret_) { if (_a_ == 0 || !CHECK_REF_COUNT(_a_)) { SET_ERROR_CODE(Z3_INVALID_ARG); return _ret_; } }
+#define CHECK_SEARCHING(c) mk_c(c)->check_searching();
+inline bool is_expr(Z3_ast a) { return is_expr(to_ast(a)); }
+inline bool is_bool_expr(Z3_context c, Z3_ast a) { return is_expr(a) && mk_c(c)->m().is_bool(to_expr(a)); }
+#define CHECK_FORMULA(_a_, _ret_) { if (_a_ == 0 || !CHECK_REF_COUNT(_a_) || !is_bool_expr(c, _a_)) { SET_ERROR_CODE(Z3_INVALID_ARG); return _ret_; } }
+inline void check_sorts(Z3_context c, ast * n) { mk_c(c)->check_sorts(n); }
+
+#endif

src/api/api_datalog.cpp

@@ -0,0 +1,561 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_datalog.cpp
+
+Abstract:
+    Datalog API
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include"api_datalog.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"dl_context.h"
+#include"ast_pp.h"
+#include"api_ast_vector.h"
+#include"api_log_macros.h"
+#include"api_stats.h"
+#include"datalog_parser.h"
+#include"cancel_eh.h"
+#include"scoped_timer.h"
+
+namespace api {
+    
+    fixedpoint_context::fixedpoint_context(ast_manager& m, front_end_params& p) : 
+        m_state(0), 
+        m_reduce_app(0), 
+        m_reduce_assign(0), 
+        m_context(m, p),
+        m_trail(m) {}
+    
+    
+    void fixedpoint_context::set_state(void* state) {
+        SASSERT(!m_state);
+        m_state = state;
+        symbol name("datalog_relation");
+        ast_manager& m = m_context.get_manager();
+        if (!m.has_plugin(name)) {
+            m.register_plugin(name, alloc(datalog::dl_decl_plugin));
+        }        
+        datalog::relation_manager& r = m_context.get_rmanager();
+        r.register_plugin(alloc(datalog::external_relation_plugin, *this, r));
+    }        
+    
+    void fixedpoint_context::reduce(func_decl* f, unsigned num_args, expr * const* args, expr_ref& result) {
+        expr* r = 0;
+        if (m_reduce_app) {
+            m_reduce_app(m_state, f, num_args, args, &r);
+            result = r;
+            m_trail.push_back(f);
+            for (unsigned i = 0; i < num_args; ++i) {
+                m_trail.push_back(args[i]);
+            }
+            m_trail.push_back(r);
+        }
+        // allow fallthrough.
+        if (r == 0) {
+            ast_manager& m = m_context.get_manager();
+            result = m.mk_app(f, num_args, args);
+        }
+    }
+    
+    // overwrite terms passed in outs vector with values computed by function.
+    void fixedpoint_context::reduce_assign(func_decl* f, unsigned num_args, expr * const* args, unsigned num_out, expr* const* outs) {
+        if (m_reduce_assign) {
+            m_trail.push_back(f);
+            for (unsigned i = 0; i < num_args; ++i) {
+                m_trail.push_back(args[i]);
+            }
+            m_reduce_assign(m_state, f, num_args, args, num_out, outs);
+        }
+    }
+
+
+    void fixedpoint_context::add_rule(expr* rule, symbol const& name) {
+        m_context.add_rule(rule, name);
+    }   
+
+    void fixedpoint_context::update_rule(expr* rule, symbol const& name) {
+        m_context.update_rule(rule, name);
+    }   
+
+    void fixedpoint_context::add_table_fact(func_decl* r, unsigned num_args, unsigned args[]) {
+        m_context.add_table_fact(r, num_args, args);
+    }   
+
+    unsigned fixedpoint_context::get_num_levels(func_decl* pred) {
+        return m_context.get_num_levels(pred);
+    }
+
+    expr_ref fixedpoint_context::get_cover_delta(int level, func_decl* pred) {
+        return m_context.get_cover_delta(level, pred);
+    }
+
+    void fixedpoint_context::add_cover(int level, func_decl* pred, expr* predicate) {
+        m_context.add_cover(level, pred, predicate);
+    }
+
+    std::string fixedpoint_context::get_last_status() {
+        datalog::execution_result status = m_context.get_status();
+        switch(status) {
+        case datalog::INPUT_ERROR:
+            return "input error";        
+        case datalog::OK:
+            return "ok";
+        case datalog::TIMEOUT:            
+            return "timeout";
+        default:
+            UNREACHABLE();
+            return "unknown";
+        }
+    } 
+
+    std::string fixedpoint_context::to_string(unsigned num_queries, expr*const* queries) {
+        std::stringstream str;
+        m_context.display_smt2(num_queries, queries, str);
+        return str.str();
+    } 
+
+    void fixedpoint_context::simplify_rules(
+        unsigned num_rules, expr* const* rules, 
+        unsigned num_outputs,  func_decl* const* outputs, expr_ref_vector& result) {
+        ast_manager& m = m_context.get_manager();
+        
+        datalog::context ctx(m, m_context.get_fparams());
+        datalog::rule_manager& rm = ctx.get_rule_manager();
+        for (unsigned i = 0; i < num_rules; ++i) {
+            expr* rule = rules[i], *body, *head;
+            while (true) {
+                if (is_quantifier(rule)) {
+                    rule = to_quantifier(rule)->get_expr();
+                }
+                else if (m.is_implies(rule, body, head)) {
+                    rule = head;
+                }
+                else {
+                    break;
+                }
+            }
+            if (is_app(rule)) {
+                func_decl* r = to_app(rule)->get_decl();
+                if (!ctx.is_predicate(r)) {
+                    ctx.register_predicate(r);
+                    if (num_outputs == 0) {
+                        ctx.set_output_predicate(r);
+                    }
+                }
+            }
+        }
+        for (unsigned i = 0; i < num_outputs; ++i) {
+            ctx.set_output_predicate(outputs[i]);
+        }
+        for (unsigned i = 0; i < num_rules; ++i) {
+            expr* rule = rules[i];
+            ctx.add_rule(rule, symbol::null);
+        }
+        model_converter_ref mc; // not exposed.
+        proof_converter_ref pc; // not exposed.
+        ctx.apply_default_transformation(mc, pc);
+        datalog::rule_set const& new_rules = ctx.get_rules();
+        datalog::rule_set::iterator it = new_rules.begin(), end = new_rules.end();
+        for (; it != end; ++it) {
+            datalog::rule* r = *it;
+            expr_ref fml(m);
+            r->to_formula(fml);
+            result.push_back(fml);
+        }
+    }
+
+};
+
+extern "C" {
+    
+    ////////////////////////////////////
+    // Datalog utilities
+    // 
+
+
+    unsigned Z3_API Z3_get_relation_arity(Z3_context c, Z3_sort s) {
+        Z3_TRY;
+        LOG_Z3_get_relation_arity(c, s);
+        RESET_ERROR_CODE();  
+        sort * r = to_sort(s);
+        if (Z3_get_sort_kind(c, s) != Z3_RELATION_SORT) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return 0;
+        }
+        return r->get_num_parameters();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_sort Z3_API Z3_get_relation_column(Z3_context c, Z3_sort s, unsigned col) {
+        Z3_TRY;
+        LOG_Z3_get_relation_column(c, s, col);
+        RESET_ERROR_CODE();  
+        sort * r = to_sort(s);
+        if (Z3_get_sort_kind(c, s) != Z3_RELATION_SORT) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        if (col >= r->get_num_parameters()) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        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);
+        }
+        Z3_sort res = of_sort(to_sort(p.get_ast()));
+        RETURN_Z3(res);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, unsigned __int64 size) {
+        Z3_TRY;
+        LOG_Z3_mk_finite_domain_sort(c, name, size);
+        RESET_ERROR_CODE();
+        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_bool Z3_API Z3_get_finite_domain_sort_size(Z3_context c, Z3_sort s, unsigned __int64 * out) {
+        Z3_TRY;
+        if (out) {
+            *out = 0;
+        }
+        if (Z3_get_sort_kind(c, s) != Z3_FINITE_DOMAIN_SORT) {
+            return Z3_FALSE;
+        }
+        if (!out) {
+            return Z3_FALSE;
+        }
+        // must start loggging here, since function uses Z3_get_sort_kind above
+        LOG_Z3_get_finite_domain_sort_size(c, s, out);
+        RESET_ERROR_CODE();  
+        VERIFY(mk_c(c)->datalog_util().try_get_size(to_sort(s), *out));
+        return Z3_TRUE;
+
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    Z3_fixedpoint Z3_API Z3_mk_fixedpoint(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_mk_fixedpoint(c);
+        RESET_ERROR_CODE();
+        Z3_fixedpoint_ref * d = alloc(Z3_fixedpoint_ref);
+        d->m_datalog = alloc(api::fixedpoint_context, mk_c(c)->m(), mk_c(c)->fparams());
+        mk_c(c)->save_object(d);
+        Z3_fixedpoint r = of_datalog(d);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_fixedpoint_inc_ref(Z3_context c, Z3_fixedpoint s) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_inc_ref(c, s);
+        RESET_ERROR_CODE();
+        to_fixedpoint(s)->inc_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_fixedpoint_dec_ref(Z3_context c, Z3_fixedpoint s) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_dec_ref(c, s);
+        RESET_ERROR_CODE();
+        to_fixedpoint(s)->dec_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_fixedpoint_assert(Z3_context c, Z3_fixedpoint d, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_assert(c, d, a);
+        RESET_ERROR_CODE();
+        CHECK_FORMULA(a,);        
+        to_fixedpoint_ref(d)->ctx().assert_expr(to_expr(a));
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_fixedpoint_add_rule(Z3_context c, Z3_fixedpoint d, Z3_ast a, Z3_symbol name) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_add_rule(c, d, a, name);
+        RESET_ERROR_CODE();
+        CHECK_FORMULA(a,);        
+        to_fixedpoint_ref(d)->add_rule(to_expr(a), to_symbol(name));
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_fixedpoint_add_fact(Z3_context c, Z3_fixedpoint d, 
+                                       Z3_func_decl r, unsigned num_args, unsigned args[]) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_add_fact(c, d, r, num_args, args);
+        RESET_ERROR_CODE();
+        to_fixedpoint_ref(d)->add_table_fact(to_func_decl(r), num_args, args);
+        Z3_CATCH;
+    }
+
+    Z3_lbool Z3_API Z3_fixedpoint_query(Z3_context c,Z3_fixedpoint d, Z3_ast q) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_query(c, d, q);
+        RESET_ERROR_CODE();
+        lbool r = l_undef;
+        cancel_eh<api::fixedpoint_context> eh(*to_fixedpoint_ref(d));
+        unsigned timeout = to_fixedpoint(d)->m_params.get_uint(":timeout", UINT_MAX);
+        api::context::set_interruptable(*(mk_c(c)), eh);        
+        {
+            scoped_timer timer(timeout, &eh);
+            try {
+                r = to_fixedpoint_ref(d)->ctx().query(to_expr(q));
+            }
+            catch (z3_exception& ex) {
+                mk_c(c)->handle_exception(ex);
+                r = l_undef;
+            }
+            to_fixedpoint_ref(d)->ctx().cleanup();
+        }
+        return of_lbool(r);
+        Z3_CATCH_RETURN(Z3_L_UNDEF);
+    }
+
+    Z3_lbool Z3_API Z3_fixedpoint_query_relations(
+        __in Z3_context c,__in Z3_fixedpoint d, 
+        __in unsigned num_relations, Z3_func_decl const relations[]) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_query_relations(c, d, num_relations, relations);
+        RESET_ERROR_CODE();
+        lbool r = l_undef;
+        unsigned timeout = to_fixedpoint(d)->m_params.get_uint(":timeout", UINT_MAX);
+        cancel_eh<api::fixedpoint_context> eh(*to_fixedpoint_ref(d));
+        api::context::set_interruptable(*(mk_c(c)), eh);
+        {
+            scoped_timer timer(timeout, &eh);
+            try {
+                r = to_fixedpoint_ref(d)->ctx().dl_query(num_relations, to_func_decls(relations));
+            }
+            catch (z3_exception& ex) {
+                mk_c(c)->handle_exception(ex);
+                r = l_undef;
+            }
+            to_fixedpoint_ref(d)->ctx().cleanup();
+        }
+        return of_lbool(r);
+        Z3_CATCH_RETURN(Z3_L_UNDEF);
+    }
+
+    Z3_ast Z3_API Z3_fixedpoint_get_answer(Z3_context c, Z3_fixedpoint d) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_get_answer(c, d);
+        RESET_ERROR_CODE();
+        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_string Z3_API Z3_fixedpoint_get_reason_unknown(Z3_context c,Z3_fixedpoint d) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_get_reason_unknown(c, d);
+        RESET_ERROR_CODE();
+        return mk_c(c)->mk_external_string(to_fixedpoint_ref(d)->get_last_status());
+        Z3_CATCH_RETURN("");
+    }
+
+    Z3_string Z3_API Z3_fixedpoint_to_string(
+        Z3_context c, 
+        Z3_fixedpoint d,
+        unsigned num_queries,
+        Z3_ast _queries[]) {
+        Z3_TRY;
+        expr*const* queries = to_exprs(_queries);        
+        LOG_Z3_fixedpoint_to_string(c, d, num_queries, _queries);
+        RESET_ERROR_CODE();
+        return mk_c(c)->mk_external_string(to_fixedpoint_ref(d)->to_string(num_queries, queries));
+        Z3_CATCH_RETURN("");
+    }
+
+    Z3_stats Z3_API Z3_fixedpoint_get_statistics(Z3_context c,Z3_fixedpoint d) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_get_statistics(c, d);
+        RESET_ERROR_CODE();
+        Z3_stats_ref * st = alloc(Z3_stats_ref);
+        to_fixedpoint_ref(d)->ctx().collect_statistics(st->m_stats);
+        mk_c(c)->save_object(st);
+        Z3_stats r = of_stats(st);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    void Z3_API Z3_fixedpoint_register_relation(Z3_context c,Z3_fixedpoint d, Z3_func_decl f) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_register_relation(c, d, f);
+        to_fixedpoint_ref(d)->ctx().register_predicate(to_func_decl(f));
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_fixedpoint_set_predicate_representation(
+        Z3_context c,
+        Z3_fixedpoint d, 
+        Z3_func_decl f, 
+        unsigned num_relations, 
+        Z3_symbol const relation_kinds[]) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_set_predicate_representation(c, d, f, num_relations, relation_kinds);
+        svector<symbol> kinds;
+        for (unsigned i = 0; i < num_relations; ++i) {
+            kinds.push_back(to_symbol(relation_kinds[i]));
+        }
+        to_fixedpoint_ref(d)->ctx().set_predicate_representation(to_func_decl(f), num_relations, kinds.c_ptr());
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_fixedpoint_set_reduce_assign_callback(
+        Z3_context c, Z3_fixedpoint d, Z3_fixedpoint_reduce_assign_callback_fptr f) {
+        Z3_TRY;
+        // no logging
+        to_fixedpoint_ref(d)->set_reduce_assign((reduce_assign_callback_fptr)f);
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_fixedpoint_set_reduce_app_callback(
+        Z3_context c, Z3_fixedpoint d, Z3_fixedpoint_reduce_app_callback_fptr f) {
+        Z3_TRY;
+        // no logging
+        to_fixedpoint_ref(d)->set_reduce_app((reduce_app_callback_fptr)f);       
+        Z3_CATCH;
+    }
+
+    Z3_ast_vector Z3_API Z3_fixedpoint_simplify_rules(
+        Z3_context c,
+        Z3_fixedpoint d,
+        unsigned num_rules,
+        Z3_ast _rules[],
+        unsigned num_outputs,
+        Z3_func_decl _outputs[]) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_simplify_rules(c, d, num_rules, _rules, num_outputs, _outputs);
+        RESET_ERROR_CODE();        
+        expr** rules = (expr**)_rules;
+        func_decl** outputs = (func_decl**)_outputs;
+        ast_manager& m = mk_c(c)->m();        
+        expr_ref_vector result(m);
+        to_fixedpoint_ref(d)->simplify_rules(num_rules, rules, num_outputs, outputs, result);        
+        Z3_ast_vector_ref* v = alloc(Z3_ast_vector_ref, mk_c(c)->m());
+        mk_c(c)->save_object(v);
+        for (unsigned i = 0; i < result.size(); ++i) {
+            v->m_ast_vector.push_back(result[i].get());
+        }
+        RETURN_Z3(of_ast_vector(v));
+        Z3_CATCH_RETURN(0)
+    }
+
+
+    void Z3_API Z3_fixedpoint_init(Z3_context c,Z3_fixedpoint d, void* state) {
+        Z3_TRY;
+        // not logged
+        to_fixedpoint_ref(d)->set_state(state);
+        Z3_CATCH;
+    }
+
+
+    void Z3_API Z3_fixedpoint_update_rule(Z3_context c, Z3_fixedpoint d, Z3_ast a, Z3_symbol name) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_update_rule(c, d, a, name);
+        RESET_ERROR_CODE();
+        CHECK_FORMULA(a,);        
+        to_fixedpoint_ref(d)->update_rule(to_expr(a), to_symbol(name));
+        Z3_CATCH;
+    }
+
+    unsigned Z3_API Z3_fixedpoint_get_num_levels(Z3_context c, Z3_fixedpoint d, Z3_func_decl pred) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_get_num_levels(c, d, pred);
+        RESET_ERROR_CODE();
+        return to_fixedpoint_ref(d)->get_num_levels(to_func_decl(pred));
+        Z3_CATCH_RETURN(0)
+    }
+
+    Z3_ast Z3_API Z3_fixedpoint_get_cover_delta(Z3_context c, Z3_fixedpoint d, int level, Z3_func_decl pred) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_get_cover_delta(c, d, level, pred);
+        RESET_ERROR_CODE();
+        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);
+    }
+
+    void Z3_API Z3_fixedpoint_add_cover(Z3_context c, Z3_fixedpoint d, int level, Z3_func_decl pred, Z3_ast property) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_add_cover(c, d, level, pred, property);
+        RESET_ERROR_CODE();
+        to_fixedpoint_ref(d)->add_cover(level, to_func_decl(pred), to_expr(property));        
+        Z3_CATCH;
+    }
+
+    Z3_string Z3_API Z3_fixedpoint_get_help(Z3_context c, Z3_fixedpoint d) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_get_help(c, d);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        param_descrs descrs;
+        to_fixedpoint_ref(d)->collect_param_descrs(descrs);
+        descrs.display(buffer);
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN("");
+    }
+
+    Z3_param_descrs Z3_API Z3_fixedpoint_get_param_descrs(Z3_context c, Z3_fixedpoint f) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_get_param_descrs(c, f);
+        RESET_ERROR_CODE();
+        Z3_param_descrs_ref * d = alloc(Z3_param_descrs_ref);
+        mk_c(c)->save_object(d);
+        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);
+    }
+    
+    void Z3_API Z3_fixedpoint_set_params(Z3_context c, Z3_fixedpoint d, Z3_params p) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_set_params(c, d, p);
+        RESET_ERROR_CODE();
+        param_descrs descrs;
+        to_fixedpoint_ref(d)->collect_param_descrs(descrs);
+        to_params(p)->m_params.validate(descrs);
+        to_fixedpoint_ref(d)->updt_params(to_param_ref(p));
+        to_fixedpoint(d)->m_params = to_param_ref(p);
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_fixedpoint_push(Z3_context c,Z3_fixedpoint d) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_push(c, d);
+        RESET_ERROR_CODE();
+        to_fixedpoint_ref(d)->ctx().push();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_fixedpoint_pop(Z3_context c,Z3_fixedpoint d) {
+        Z3_TRY;
+        LOG_Z3_fixedpoint_pop(c, d);
+        RESET_ERROR_CODE();
+        to_fixedpoint_ref(d)->ctx().pop();
+        Z3_CATCH;
+
+    }
+    
+
+};

src/api/api_datalog.h

@@ -0,0 +1,84 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_datalog.h
+
+Abstract:
+    Datalog API
+    old external_relation_context_impl
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#ifndef _API_DATALOG_H_
+#define _API_DATALOG_H_
+
+#include"z3.h"
+#include"ast.h"
+#include"front_end_params.h"
+#include"dl_external_relation.h"
+#include"dl_decl_plugin.h"
+#include"smt_solver.h"
+#include"api_util.h"
+#include"dl_context.h"
+
+typedef void (*reduce_app_callback_fptr)(void*, func_decl*, unsigned, expr*const*, expr**);
+typedef void (*reduce_assign_callback_fptr)(void*, func_decl*, unsigned, expr*const*, unsigned, expr*const*);
+
+namespace api {
+    
+    class fixedpoint_context : public datalog::external_relation_context {
+        void *                       m_state;
+        reduce_app_callback_fptr     m_reduce_app;
+        reduce_assign_callback_fptr  m_reduce_assign;
+        datalog::context             m_context;    
+        ast_ref_vector               m_trail;        
+    public:
+        fixedpoint_context(ast_manager& m, front_end_params& p);
+        virtual ~fixedpoint_context() {}
+        family_id get_family_id() const { return const_cast<datalog::context&>(m_context).get_decl_util().get_family_id(); }
+        void set_state(void* state);
+        void set_reduce_app(reduce_app_callback_fptr f) { m_reduce_app = f; }
+        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);
+        virtual void reduce_assign(func_decl* f, unsigned num_args, expr * const* args, unsigned num_out, expr* const* outs);
+        datalog::context& ctx() { return m_context; }
+        void add_rule(expr* rule, symbol const& name);
+        void update_rule(expr* rule, symbol const& name);
+        void add_table_fact(func_decl* r, unsigned num_args, unsigned args[]);
+        std::string get_last_status();
+        std::string to_string(unsigned num_queries, expr*const* queries);
+        void cancel() { m_context.cancel(); }
+
+        unsigned get_num_levels(func_decl* pred);
+        expr_ref get_cover_delta(int level, func_decl* pred);
+        void add_cover(int level, func_decl* pred, expr* predicate);
+        void collect_param_descrs(param_descrs & p) { m_context.collect_params(p); }
+        void updt_params(params_ref const& p) { m_context.updt_params(p); }
+
+        void simplify_rules(
+            unsigned num_rules, expr* const* rules, 
+            unsigned num_outputs,  func_decl* const* outputs, expr_ref_vector& result);
+    };
+};
+
+
+struct Z3_fixedpoint_ref : public api::object {
+    api::fixedpoint_context *   m_datalog;
+    params_ref               m_params;
+    Z3_fixedpoint_ref():m_datalog(0) {}
+    virtual ~Z3_fixedpoint_ref() { dealloc(m_datalog); }
+};
+
+inline Z3_fixedpoint_ref * to_fixedpoint(Z3_fixedpoint s) { return reinterpret_cast<Z3_fixedpoint_ref *>(s); }
+inline Z3_fixedpoint of_datalog(Z3_fixedpoint_ref * s) { return reinterpret_cast<Z3_fixedpoint>(s); }
+inline api::fixedpoint_context * to_fixedpoint_ref(Z3_fixedpoint s) { return to_fixedpoint(s)->m_datalog; }
+
+
+#endif

src/api/api_datatype.cpp

@@ -0,0 +1,621 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_datatype.cpp
+
+Abstract:
+    API for datatype theory
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"datatype_decl_plugin.h"
+
+extern "C" {
+
+    Z3_sort Z3_API Z3_mk_tuple_sort(Z3_context c, 
+                                    Z3_symbol name,
+                                    unsigned num_fields, 
+                                    Z3_symbol const field_names[],
+                                    Z3_sort const field_sorts[],
+                                    Z3_func_decl * mk_tuple_decl,
+                                    Z3_func_decl proj_decls[]) {
+        Z3_TRY;
+        LOG_Z3_mk_tuple_sort(c, name, num_fields, field_names, field_sorts, mk_tuple_decl, proj_decls);
+        RESET_ERROR_CODE(); 
+        mk_c(c)->reset_last_result();
+        ast_manager& m = mk_c(c)->m();
+        datatype_util dt_util(m);
+
+        sort_ref_vector tuples(m);
+        sort* tuple;
+        std::string recognizer_s("is_");
+        recognizer_s += to_symbol(name).str();
+        symbol recognizer(recognizer_s.c_str());
+        
+        ptr_vector<accessor_decl> acc;
+        for (unsigned i = 0; i < num_fields; ++i) {
+            acc.push_back(mk_accessor_decl(to_symbol(field_names[i]), type_ref(to_sort(field_sorts[i]))));
+        }
+
+        constructor_decl* constrs[1] = { mk_constructor_decl(to_symbol(name), recognizer, acc.size(), acc.c_ptr()) };
+        
+        {
+            datatype_decl * dt = mk_datatype_decl(to_symbol(name), 1, constrs);
+            bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &dt, tuples);
+            del_datatype_decl(dt);
+
+            if (!is_ok) {
+                SET_ERROR_CODE(Z3_INVALID_ARG);
+                RETURN_Z3(0);
+            }
+        }
+
+        // create tuple type
+        SASSERT(tuples.size() == 1);        
+        tuple = tuples[0].get();
+        mk_c(c)->save_multiple_ast_trail(tuple);
+
+        // create constructor
+        SASSERT(dt_util.is_datatype(tuple));
+        SASSERT(!dt_util.is_recursive(tuple));
+        ptr_vector<func_decl> const * decls = dt_util.get_datatype_constructors(tuple);
+        func_decl* decl = (*decls)[0];
+        mk_c(c)->save_multiple_ast_trail(decl);        
+        *mk_tuple_decl = of_func_decl(decl);
+        
+        // Create projections
+        ptr_vector<func_decl> const * accs = dt_util.get_constructor_accessors(decl);
+        if (!accs) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        ptr_vector<func_decl> const & _accs = *accs;
+        SASSERT(_accs.size() == num_fields);
+        for (unsigned i = 0; i < _accs.size(); i++) {
+            mk_c(c)->save_multiple_ast_trail(_accs[i]);
+            proj_decls[i] = of_func_decl(_accs[i]);
+        }
+        RETURN_Z3_mk_tuple_sort(of_sort(tuple));
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_sort Z3_API Z3_mk_enumeration_sort(Z3_context c, 
+                                          Z3_symbol name,
+                                          unsigned n,
+                                          Z3_symbol const enum_names[],
+                                          Z3_func_decl enum_consts[],
+                                          Z3_func_decl enum_testers[]) {
+        Z3_TRY;
+        LOG_Z3_mk_enumeration_sort(c, name, n, enum_names, enum_consts, enum_testers);
+        RESET_ERROR_CODE();
+        mk_c(c)->reset_last_result();
+        ast_manager& m = mk_c(c)->m();
+        datatype_util dt_util(m);
+
+        sort_ref_vector sorts(m);
+        sort* e;
+        
+        ptr_vector<constructor_decl> constrs;
+        for (unsigned i = 0; i < n; ++i) {
+            symbol e_name(to_symbol(enum_names[i]));
+            std::string recognizer_s("is_");
+            recognizer_s += e_name.str();
+            symbol recognizer(recognizer_s.c_str());
+
+            constrs.push_back(mk_constructor_decl(e_name, recognizer, 0, 0));
+        }
+
+
+        {
+            datatype_decl * dt = mk_datatype_decl(to_symbol(name), n, constrs.c_ptr());
+            bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &dt, sorts);
+            del_datatype_decl(dt);
+
+            if (!is_ok) {
+                SET_ERROR_CODE(Z3_INVALID_ARG);
+                RETURN_Z3(0);
+            }
+        }
+            
+        // create enum type.
+        SASSERT(sorts.size() == 1);        
+        e = sorts[0].get();
+        mk_c(c)->save_multiple_ast_trail(e);
+
+        // create constructor
+        SASSERT(dt_util.is_datatype(e));
+        SASSERT(!dt_util.is_recursive(e));
+        ptr_vector<func_decl> const * decls = dt_util.get_datatype_constructors(e);
+        SASSERT(decls && decls->size() == n);
+        for (unsigned i = 0; i < n; ++i) {
+            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);
+            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_sort Z3_API Z3_mk_list_sort(Z3_context c,
+                                   Z3_symbol name,
+                                   Z3_sort   elem_sort,
+                                   Z3_func_decl* nil_decl,
+                                   Z3_func_decl* is_nil_decl,
+                                   Z3_func_decl* cons_decl,
+                                   Z3_func_decl* is_cons_decl,
+                                   Z3_func_decl* head_decl,
+                                   Z3_func_decl* tail_decl
+                                   ) {
+        Z3_TRY;
+        LOG_Z3_mk_list_sort(c, name, elem_sort, nil_decl, is_nil_decl, cons_decl, is_cons_decl, head_decl, tail_decl);
+        RESET_ERROR_CODE();
+        ast_manager& m = mk_c(c)->m();
+        mk_c(c)->reset_last_result();
+        datatype_util data_util(m);
+        accessor_decl* head_tail[2] = { 
+            mk_accessor_decl(symbol("head"), type_ref(to_sort(elem_sort))),
+            mk_accessor_decl(symbol("tail"), type_ref(0))
+        };
+        constructor_decl* constrs[2] = { 
+            mk_constructor_decl(symbol("nil"), symbol("is_nil"), 0, 0),
+            // Leo: SMT 2.0 document uses 'insert' instead of cons
+            mk_constructor_decl(symbol("cons"), symbol("is_cons"), 2, head_tail)
+        };
+
+        sort_ref_vector sorts(m);
+        {
+            datatype_decl * decl = mk_datatype_decl(to_symbol(name), 2, constrs);
+            bool is_ok = mk_c(c)->get_dt_plugin()->mk_datatypes(1, &decl, sorts);
+            del_datatype_decl(decl);
+
+            if (!is_ok) {
+                SET_ERROR_CODE(Z3_INVALID_ARG);
+                RETURN_Z3(0);
+            }
+        }
+        sort * s = sorts.get(0);
+
+        mk_c(c)->save_multiple_ast_trail(s);
+        ptr_vector<func_decl> const& cnstrs = *data_util.get_datatype_constructors(s);
+        SASSERT(cnstrs.size() == 2);
+        func_decl* f;
+        if (nil_decl) {
+            f = cnstrs[0];
+            mk_c(c)->save_multiple_ast_trail(f);            
+            *nil_decl = of_func_decl(f);
+        }
+        if (is_nil_decl) {
+            f = data_util.get_constructor_recognizer(cnstrs[0]);
+            mk_c(c)->save_multiple_ast_trail(f);            
+            *is_nil_decl = of_func_decl(f);
+        }
+        if (cons_decl) {
+            f = cnstrs[1];
+            mk_c(c)->save_multiple_ast_trail(f);                        
+            *cons_decl = of_func_decl(f);
+        }
+        if (is_cons_decl) {
+            f = data_util.get_constructor_recognizer(cnstrs[1]);
+            mk_c(c)->save_multiple_ast_trail(f);                        
+            *is_cons_decl = of_func_decl(f);
+        }
+        if (head_decl) {
+            ptr_vector<func_decl> const* acc = data_util.get_constructor_accessors(cnstrs[1]);
+            SASSERT(acc);
+            SASSERT(acc->size() == 2);
+            f = (*acc)[0];
+            mk_c(c)->save_multiple_ast_trail(f);                        
+            *head_decl = of_func_decl(f);
+        }
+        if (tail_decl) {
+            ptr_vector<func_decl> const* acc = data_util.get_constructor_accessors(cnstrs[1]);
+            SASSERT(acc);
+            SASSERT(acc->size() == 2);
+            f = (*acc)[1];
+            mk_c(c)->save_multiple_ast_trail(f);                        
+            *tail_decl = of_func_decl(f);
+        }
+        RETURN_Z3_mk_list_sort(of_sort(s));
+        Z3_CATCH_RETURN(0);
+    }
+
+    struct constructor {
+        symbol           m_name;
+        symbol           m_tester;
+        svector<symbol>  m_field_names;
+        sort_ref_vector  m_sorts;
+        unsigned_vector  m_sort_refs;
+        func_decl_ref    m_constructor;
+        constructor(ast_manager& m) : m_sorts(m), m_constructor(m) {}
+    };
+
+    Z3_constructor Z3_API Z3_mk_constructor(Z3_context c,
+                                            Z3_symbol name,
+                                            Z3_symbol tester,
+                                            unsigned num_fields,
+                                            Z3_symbol const field_names[],
+                                            Z3_sort const sorts[],
+                                            unsigned sort_refs[]
+                                            ) {
+        Z3_TRY;
+        LOG_Z3_mk_constructor(c, name, tester, num_fields, field_names, sorts, sort_refs);
+        RESET_ERROR_CODE();  
+        ast_manager& m = mk_c(c)->m();
+        constructor* cnstr = alloc(constructor, m);
+        cnstr->m_name = to_symbol(name);
+        cnstr->m_tester = to_symbol(tester);
+        for (unsigned i = 0; i < num_fields; ++i) {
+            cnstr->m_field_names.push_back(to_symbol(field_names[i]));
+            cnstr->m_sorts.push_back(to_sort(sorts[i]));
+            cnstr->m_sort_refs.push_back(sort_refs[i]);
+        }
+        RETURN_Z3(reinterpret_cast<Z3_constructor>(cnstr));
+        Z3_CATCH_RETURN(0);
+    }
+
+
+    void Z3_API Z3_query_constructor(Z3_context c,
+                                     Z3_constructor constr,
+                                     unsigned num_fields,
+                                     Z3_func_decl* constructor_decl,
+                                     Z3_func_decl* tester,
+                                     Z3_func_decl accessors[]) {
+        Z3_TRY;
+        LOG_Z3_query_constructor(c, constr, num_fields, constructor_decl, tester, accessors);
+        RESET_ERROR_CODE();
+        mk_c(c)->reset_last_result();
+        if (!constr) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return;
+        }
+        ast_manager& m = mk_c(c)->m();
+        datatype_util data_util(m);
+        func_decl* f = reinterpret_cast<constructor*>(constr)->m_constructor.get();
+
+        if (!f) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return;
+        }    
+        if (constructor_decl) {
+            mk_c(c)->save_multiple_ast_trail(f);
+            *constructor_decl = of_func_decl(f);
+        }
+        if (tester) {
+            func_decl* f2 = data_util.get_constructor_recognizer(f);
+            mk_c(c)->save_multiple_ast_trail(f2);
+            *tester = of_func_decl(f2);
+        }
+        
+        ptr_vector<func_decl> const* accs = data_util.get_constructor_accessors(f);
+        if (!accs && num_fields > 0) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return;            
+        }
+        for (unsigned i = 0; i < num_fields; ++i) {
+            func_decl* f2 = (*accs)[i];
+            mk_c(c)->save_multiple_ast_trail(f2);            
+            accessors[i] = of_func_decl(f2);
+        }
+        RETURN_Z3_query_constructor;
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_del_constructor(Z3_context c, Z3_constructor constr) {
+        Z3_TRY;
+        LOG_Z3_del_constructor(c, constr);
+        RESET_ERROR_CODE();
+        dealloc(reinterpret_cast<constructor*>(constr));
+        Z3_CATCH;
+    }
+
+    static datatype_decl* mk_datatype_decl(Z3_context c, 
+                                           Z3_symbol name,
+                                           unsigned num_constructors,
+                                           Z3_constructor constructors[]) {
+        ptr_vector<constructor_decl> constrs;
+        for (unsigned i = 0; i < num_constructors; ++i) {
+            constructor* cn = reinterpret_cast<constructor*>(constructors[i]);
+            ptr_vector<accessor_decl> acc;
+            for (unsigned j = 0; j < cn->m_sorts.size(); ++j) {
+                if (cn->m_sorts[j].get()) {
+                    acc.push_back(mk_accessor_decl(cn->m_field_names[j], type_ref(cn->m_sorts[j].get())));
+                }
+                else {
+                    acc.push_back(mk_accessor_decl(cn->m_field_names[j], type_ref(cn->m_sort_refs[j])));
+                }
+            }
+            constrs.push_back(mk_constructor_decl(cn->m_name, cn->m_tester, acc.size(), acc.c_ptr()));
+        }
+        return mk_datatype_decl(to_symbol(name), num_constructors, constrs.c_ptr());        
+    }
+
+    Z3_sort Z3_API Z3_mk_datatype(Z3_context c,
+                                  Z3_symbol name,
+                                  unsigned num_constructors,
+                                  Z3_constructor constructors[]) {
+        Z3_TRY;
+        LOG_Z3_mk_datatype(c, name, num_constructors, constructors);
+        RESET_ERROR_CODE();
+        ast_manager& m = mk_c(c)->m();        
+        datatype_util data_util(m);
+        
+        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, sorts);
+            del_datatype_decl(data);
+
+            if (!is_ok) {
+                SET_ERROR_CODE(Z3_INVALID_ARG);
+                RETURN_Z3(0);
+            }
+        }
+        sort * s = sorts.get(0);
+
+        mk_c(c)->save_ast_trail(s);
+        ptr_vector<func_decl> const* cnstrs = data_util.get_datatype_constructors(s);
+        
+        for (unsigned i = 0; i < num_constructors; ++i) {
+            constructor* cn = reinterpret_cast<constructor*>(constructors[i]);
+            cn->m_constructor = (*cnstrs)[i];
+        }
+        RETURN_Z3_mk_datatype(of_sort(s));
+        Z3_CATCH_RETURN(0);
+    }
+
+    typedef ptr_vector<constructor> constructor_list;
+
+    Z3_constructor_list Z3_API Z3_mk_constructor_list(Z3_context c,
+                                                      unsigned num_constructors,
+                                                      Z3_constructor const constructors[]) {
+        Z3_TRY;
+        LOG_Z3_mk_constructor_list(c, num_constructors, constructors);
+        RESET_ERROR_CODE();
+        constructor_list* result = alloc(ptr_vector<constructor>);
+        for (unsigned i = 0; i < num_constructors; ++i) {
+            result->push_back(reinterpret_cast<constructor*>(constructors[i]));
+        }
+        RETURN_Z3(reinterpret_cast<Z3_constructor_list>(result));
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_del_constructor_list(Z3_context c, Z3_constructor_list clist) {
+        Z3_TRY;
+        LOG_Z3_del_constructor_list(c, clist);
+        RESET_ERROR_CODE();
+        dealloc(reinterpret_cast<constructor_list*>(clist));
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_mk_datatypes(Z3_context c,
+                                unsigned num_sorts,
+                                Z3_symbol const sort_names[],
+                                Z3_sort sorts[],
+                                Z3_constructor_list constructor_lists[]) {
+        Z3_TRY;
+        LOG_Z3_mk_datatypes(c, num_sorts, sort_names, sorts, constructor_lists);
+        RESET_ERROR_CODE();
+        ast_manager& m = mk_c(c)->m();        
+        mk_c(c)->reset_last_result();
+        datatype_util data_util(m);
+
+        ptr_vector<datatype_decl> datas;
+        for (unsigned i = 0; i < num_sorts; ++i) {
+            constructor_list* cl = reinterpret_cast<constructor_list*>(constructor_lists[i]);
+            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(), _sorts);
+        del_datatype_decls(datas.size(), datas.c_ptr());
+        
+        if (!ok) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return;
+        }
+
+        SASSERT(_sorts.size() == num_sorts);
+        for (unsigned i = 0; i < _sorts.size(); ++i) {
+            sort* s = _sorts[i].get();
+            mk_c(c)->save_multiple_ast_trail(s);
+            sorts[i] = of_sort(s);
+            constructor_list* cl = reinterpret_cast<constructor_list*>(constructor_lists[i]);
+            ptr_vector<func_decl> const* cnstrs = data_util.get_datatype_constructors(s);
+            for (unsigned j = 0; j < cl->size(); ++j) {
+                constructor* cn = (*cl)[j];                
+                cn->m_constructor = (*cnstrs)[j];                
+            }
+        }
+        RETURN_Z3_mk_datatypes;
+        Z3_CATCH;
+    }
+
+    unsigned Z3_API Z3_get_datatype_sort_num_constructors(Z3_context c, Z3_sort t) {
+        Z3_TRY;
+        LOG_Z3_get_datatype_sort_num_constructors(c, t);
+        RESET_ERROR_CODE();
+        CHECK_VALID_AST(t, 0);
+        sort * _t = to_sort(t);
+        datatype_util dt_util(mk_c(c)->m());
+        
+        if (!dt_util.is_datatype(_t)) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return 0;            
+        }
+        ptr_vector<func_decl> const * decls = dt_util.get_datatype_constructors(_t);
+        if (!decls) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return 0;                        
+        }
+        return decls->size();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_func_decl get_datatype_sort_constructor_core(Z3_context c, Z3_sort t, unsigned idx) {
+        RESET_ERROR_CODE();
+        CHECK_VALID_AST(t, 0);   
+        sort * _t = to_sort(t);
+        datatype_util dt_util(mk_c(c)->m());
+        if (!dt_util.is_datatype(_t)) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return 0;
+        }
+        ptr_vector<func_decl> const * decls = dt_util.get_datatype_constructors(_t);
+        if (!decls || idx >= decls->size()) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return 0;
+        }
+        func_decl* decl = (*decls)[idx];
+        mk_c(c)->save_ast_trail(decl);
+        return of_func_decl(decl);
+    }
+
+    Z3_func_decl Z3_API Z3_get_datatype_sort_constructor(Z3_context c, Z3_sort t, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_get_datatype_sort_constructor(c, t, idx);
+        RESET_ERROR_CODE();
+        Z3_func_decl r = get_datatype_sort_constructor_core(c, t, idx);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_func_decl Z3_API Z3_get_datatype_sort_recognizer(Z3_context c, Z3_sort t, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_get_datatype_sort_recognizer(c, t, idx);
+        RESET_ERROR_CODE();   
+        sort * _t = to_sort(t);
+        datatype_util dt_util(mk_c(c)->m());
+        
+        if (!dt_util.is_datatype(_t)) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        ptr_vector<func_decl> const * decls = dt_util.get_datatype_constructors(_t);
+        if (!decls || idx >= decls->size()) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);                        
+        }
+        func_decl* decl = (*decls)[idx];
+        decl = dt_util.get_constructor_recognizer(decl);
+        mk_c(c)->save_ast_trail(decl);
+        RETURN_Z3(of_func_decl(decl));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_func_decl Z3_API Z3_get_datatype_sort_constructor_accessor(Z3_context c, Z3_sort t, unsigned idx_c, unsigned idx_a) {
+        Z3_TRY;
+        LOG_Z3_get_datatype_sort_constructor_accessor(c, t, idx_c, idx_a);
+        RESET_ERROR_CODE();  
+        sort * _t = to_sort(t);
+        datatype_util dt_util(mk_c(c)->m());
+        
+        if (!dt_util.is_datatype(_t)) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);            
+        }
+        ptr_vector<func_decl> const * decls = dt_util.get_datatype_constructors(_t);
+        if (!decls || idx_c >= decls->size()) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);                        
+        }
+        func_decl* decl = (*decls)[idx_c];
+        if (decl->get_arity() <= idx_a) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);                        
+        }
+        ptr_vector<func_decl> const * accs = dt_util.get_constructor_accessors(decl);
+        SASSERT(accs && accs->size() == decl->get_arity());
+        if (!accs || accs->size() <= idx_a) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);                        
+        }
+        decl = (*accs)[idx_a];
+        mk_c(c)->save_ast_trail(decl);
+        RETURN_Z3(of_func_decl(decl)); 
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_func_decl Z3_API Z3_get_tuple_sort_mk_decl(Z3_context c, Z3_sort t) {
+        Z3_TRY;
+        LOG_Z3_get_tuple_sort_mk_decl(c, t);
+        RESET_ERROR_CODE();  
+        sort * tuple = to_sort(t);
+        datatype_util dt_util(mk_c(c)->m());
+        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);
+        }
+        Z3_func_decl r = get_datatype_sort_constructor_core(c, t, 0);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    unsigned Z3_API Z3_get_tuple_sort_num_fields(Z3_context c, Z3_sort t) {
+        Z3_TRY;
+        LOG_Z3_get_tuple_sort_num_fields(c, t);
+        RESET_ERROR_CODE();   
+        sort * tuple = to_sort(t);
+        datatype_util dt_util(mk_c(c)->m());
+        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 0;            
+        }
+        ptr_vector<func_decl> const * decls = dt_util.get_datatype_constructors(tuple);
+        if (!decls || decls->size() != 1) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return 0;                        
+        }
+        ptr_vector<func_decl> const * accs = dt_util.get_constructor_accessors((*decls)[0]);
+        if (!accs) {
+            return 0;                        
+        }
+        return accs->size();
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_func_decl Z3_API Z3_get_tuple_sort_field_decl(Z3_context c, Z3_sort t, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_get_tuple_sort_field_decl(c, t, i);
+        RESET_ERROR_CODE();  
+        sort * tuple = to_sort(t);
+        datatype_util dt_util(mk_c(c)->m());
+        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);
+        }
+        ptr_vector<func_decl> const * decls = dt_util.get_datatype_constructors(tuple);
+        if (!decls || decls->size() != 1) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        ptr_vector<func_decl> const * accs = dt_util.get_constructor_accessors((*decls)[0]);
+        if (!accs) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        if (accs->size() <= i) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        func_decl* acc = (*accs)[i];
+        mk_c(c)->save_ast_trail(acc);
+        RETURN_Z3(of_func_decl(acc));
+        Z3_CATCH_RETURN(0);
+    }
+
+};

src/api/api_goal.cpp

@@ -0,0 +1,181 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_goal.cpp
+
+Abstract:
+    API for creating goals
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-06.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_goal.h"
+#include"ast_translation.h"
+
+extern "C" {
+
+    Z3_goal Z3_API Z3_mk_goal(Z3_context c, Z3_bool models, Z3_bool unsat_cores, Z3_bool proofs) {
+        Z3_TRY;
+        LOG_Z3_mk_goal(c, models, unsat_cores, proofs);
+        RESET_ERROR_CODE();
+        if (proofs != 0 && !mk_c(c)->m().proofs_enabled()) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        Z3_goal_ref * g = alloc(Z3_goal_ref);
+        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);
+    }
+
+    void Z3_API Z3_goal_inc_ref(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_inc_ref(c, g);
+        RESET_ERROR_CODE();
+        to_goal(g)->inc_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_goal_dec_ref(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_dec_ref(c, g);
+        RESET_ERROR_CODE();
+        to_goal(g)->dec_ref();
+        Z3_CATCH;
+    }
+
+    Z3_goal_prec Z3_API Z3_goal_precision(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_precision(c, g);
+        RESET_ERROR_CODE();
+        switch (to_goal_ref(g)->prec()) {
+        case goal::PRECISE: return Z3_GOAL_PRECISE;
+        case goal::UNDER:   return Z3_GOAL_UNDER;
+        case goal::OVER:    return Z3_GOAL_OVER;
+        case goal::UNDER_OVER: return Z3_GOAL_UNDER_OVER;
+        default:
+            UNREACHABLE();
+            return Z3_GOAL_UNDER_OVER;
+        }
+        Z3_CATCH_RETURN(Z3_GOAL_UNDER_OVER);
+    }
+
+    void Z3_API Z3_goal_assert(Z3_context c, Z3_goal g, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_goal_assert(c, g, a);
+        RESET_ERROR_CODE();
+        CHECK_FORMULA(a,);        
+        to_goal_ref(g)->assert_expr(to_expr(a));
+        Z3_CATCH;
+    }
+
+    Z3_bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_inconsistent(c, g);
+        RESET_ERROR_CODE();
+        return to_goal_ref(g)->inconsistent();
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    unsigned Z3_API Z3_goal_depth(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_depth(c, g);
+        RESET_ERROR_CODE();
+        return to_goal_ref(g)->depth();
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_goal_reset(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_reset(c, g);
+        RESET_ERROR_CODE();
+        to_goal_ref(g)->reset();
+        Z3_CATCH;
+    }
+
+    unsigned Z3_API Z3_goal_size(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_size(c, g);
+        RESET_ERROR_CODE();
+        return to_goal_ref(g)->size();
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_ast Z3_API Z3_goal_formula(Z3_context c, Z3_goal g, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_goal_formula(c, g, idx);
+        RESET_ERROR_CODE();
+        if (idx >= to_goal_ref(g)->size()) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        expr * result = to_goal_ref(g)->form(idx);
+        mk_c(c)->save_ast_trail(result);
+        RETURN_Z3(of_ast(result));
+        Z3_CATCH_RETURN(0);
+    }
+    
+    unsigned Z3_API Z3_goal_num_exprs(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_num_exprs(c, g);
+        RESET_ERROR_CODE();
+        return to_goal_ref(g)->num_exprs();
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_bool Z3_API Z3_goal_is_decided_sat(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_is_decided_sat(c, g);
+        RESET_ERROR_CODE();
+        return to_goal_ref(g)->is_decided_sat();
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+    
+    Z3_bool Z3_API Z3_goal_is_decided_unsat(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_is_decided_unsat(c, g);
+        RESET_ERROR_CODE();
+        return to_goal_ref(g)->is_decided_unsat();
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    Z3_goal Z3_API Z3_goal_translate(Z3_context c, Z3_goal g, Z3_context target) {
+        Z3_TRY;
+        LOG_Z3_goal_translate(c, g, target);
+        RESET_ERROR_CODE();
+        ast_translation translator(mk_c(c)->m(), mk_c(target)->m());
+        Z3_goal_ref * _r = alloc(Z3_goal_ref);
+        _r->m_goal       = to_goal_ref(g)->translate(translator);
+        mk_c(target)->save_object(_r);
+        Z3_goal r = of_goal(_r);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_string Z3_API Z3_goal_to_string(Z3_context c, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_goal_to_string(c, g);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        to_goal_ref(g)->display(buffer);
+        // Hack for removing the trailing '\n'
+        std::string result = buffer.str();
+        SASSERT(result.size() > 0);
+        result.resize(result.size()-1);
+        return mk_c(c)->mk_external_string(result);
+        Z3_CATCH_RETURN("");
+    }
+
+};

src/api/api_goal.h

@@ -0,0 +1,33 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_goal.h
+
+Abstract:
+    API for creating goals
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-06.
+
+Revision History:
+
+--*/
+#ifndef _API_GOAL_H_
+#define _API_GOAL_H_
+
+#include"api_util.h"
+#include"goal.h"
+
+struct Z3_goal_ref : public api::object {
+    goal_ref m_goal;
+    virtual ~Z3_goal_ref() {}
+};
+
+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; }
+
+#endif

src/api/api_log.cpp

@@ -0,0 +1,54 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_log.cpp
+
+Abstract:
+    API for creating logs
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include<fstream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"util.h"
+
+std::ostream * g_z3_log = 0;
+bool g_z3_log_enabled   = false;
+
+extern "C" {
+    Z3_bool Z3_API Z3_open_log(Z3_string filename) {
+        if (g_z3_log != 0)
+            Z3_close_log();
+        g_z3_log = alloc(std::ofstream, filename);
+        g_z3_log_enabled = true;
+        if (g_z3_log->bad() || g_z3_log->fail()) {
+            dealloc(g_z3_log);
+            g_z3_log = 0;
+            return Z3_FALSE;
+        }
+        return Z3_TRUE;
+    }
+
+    void Z3_API Z3_append_log(Z3_string str) {
+        if (g_z3_log == 0)
+            return;
+        _Z3_append_log(static_cast<char const *>(str));
+    }
+
+    void Z3_API Z3_close_log() {
+        if (g_z3_log != 0) {
+            dealloc(g_z3_log);
+            g_z3_log_enabled = false;
+            g_z3_log = 0;
+        }
+    }
+}

src/api/api_log_macros.h

@@ -0,0 +1,989 @@
+// Automatically generated file, generator: update_api.py
+#include"z3.h"
+extern std::ostream * g_z3_log;
+extern bool           g_z3_log_enabled;
+class z3_log_ctx { bool m_prev; public: z3_log_ctx():m_prev(g_z3_log_enabled) { g_z3_log_enabled = false; } ~z3_log_ctx() { g_z3_log_enabled = m_prev; } bool enabled() const { return m_prev; } };
+inline void SetR(void * obj) { *g_z3_log << "= " << obj << "\n"; }
+inline void SetO(void * obj, unsigned pos) { *g_z3_log << "* " << obj << " " << pos << "\n"; } 
+inline void SetAO(void * obj, unsigned pos, unsigned idx) { *g_z3_log << "@ " << obj << " " << pos << " " << idx << "\n"; }
+#define RETURN_Z3(Z3RES) if (_LOG_CTX.enabled()) { SetR(Z3RES); } return Z3RES
+void _Z3_append_log(char const * msg);
+void log_Z3_mk_config();
+#define LOG_Z3_mk_config() z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_config(); }
+void log_Z3_del_config(Z3_config a0);
+#define LOG_Z3_del_config(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_del_config(_ARG0); }
+void log_Z3_set_param_value(Z3_config a0, Z3_string a1, Z3_string a2);
+#define LOG_Z3_set_param_value(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_set_param_value(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_context(Z3_config a0);
+#define LOG_Z3_mk_context(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_context(_ARG0); }
+void log_Z3_mk_context_rc(Z3_config a0);
+#define LOG_Z3_mk_context_rc(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_context_rc(_ARG0); }
+void log_Z3_del_context(Z3_context a0);
+#define LOG_Z3_del_context(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_del_context(_ARG0); }
+void log_Z3_inc_ref(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_inc_ref(_ARG0, _ARG1); }
+void log_Z3_dec_ref(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_dec_ref(_ARG0, _ARG1); }
+void log_Z3_update_param_value(Z3_context a0, Z3_string a1, Z3_string a2);
+#define LOG_Z3_update_param_value(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_update_param_value(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_param_value(Z3_context a0, Z3_string a1, Z3_string* a2);
+#define LOG_Z3_get_param_value(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_param_value(_ARG0, _ARG1, _ARG2); }
+void log_Z3_interrupt(Z3_context a0);
+#define LOG_Z3_interrupt(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_interrupt(_ARG0); }
+void log_Z3_mk_params(Z3_context a0);
+#define LOG_Z3_mk_params(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_params(_ARG0); }
+void log_Z3_params_inc_ref(Z3_context a0, Z3_params a1);
+#define LOG_Z3_params_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_params_inc_ref(_ARG0, _ARG1); }
+void log_Z3_params_dec_ref(Z3_context a0, Z3_params a1);
+#define LOG_Z3_params_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_params_dec_ref(_ARG0, _ARG1); }
+void log_Z3_params_set_bool(Z3_context a0, Z3_params a1, Z3_symbol a2, Z3_bool a3);
+#define LOG_Z3_params_set_bool(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_params_set_bool(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_params_set_uint(Z3_context a0, Z3_params a1, Z3_symbol a2, unsigned a3);
+#define LOG_Z3_params_set_uint(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_params_set_uint(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_params_set_double(Z3_context a0, Z3_params a1, Z3_symbol a2, double a3);
+#define LOG_Z3_params_set_double(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_params_set_double(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_params_set_symbol(Z3_context a0, Z3_params a1, Z3_symbol a2, Z3_symbol a3);
+#define LOG_Z3_params_set_symbol(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_params_set_symbol(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_params_to_string(Z3_context a0, Z3_params a1);
+#define LOG_Z3_params_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_params_to_string(_ARG0, _ARG1); }
+void log_Z3_params_validate(Z3_context a0, Z3_params a1, Z3_param_descrs a2);
+#define LOG_Z3_params_validate(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_params_validate(_ARG0, _ARG1, _ARG2); }
+void log_Z3_param_descrs_inc_ref(Z3_context a0, Z3_param_descrs a1);
+#define LOG_Z3_param_descrs_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_param_descrs_inc_ref(_ARG0, _ARG1); }
+void log_Z3_param_descrs_dec_ref(Z3_context a0, Z3_param_descrs a1);
+#define LOG_Z3_param_descrs_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_param_descrs_dec_ref(_ARG0, _ARG1); }
+void log_Z3_param_descrs_get_kind(Z3_context a0, Z3_param_descrs a1, Z3_symbol a2);
+#define LOG_Z3_param_descrs_get_kind(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_param_descrs_get_kind(_ARG0, _ARG1, _ARG2); }
+void log_Z3_param_descrs_size(Z3_context a0, Z3_param_descrs a1);
+#define LOG_Z3_param_descrs_size(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_param_descrs_size(_ARG0, _ARG1); }
+void log_Z3_param_descrs_get_name(Z3_context a0, Z3_param_descrs a1, unsigned a2);
+#define LOG_Z3_param_descrs_get_name(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_param_descrs_get_name(_ARG0, _ARG1, _ARG2); }
+void log_Z3_param_descrs_to_string(Z3_context a0, Z3_param_descrs a1);
+#define LOG_Z3_param_descrs_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_param_descrs_to_string(_ARG0, _ARG1); }
+void log_Z3_mk_int_symbol(Z3_context a0, int a1);
+#define LOG_Z3_mk_int_symbol(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_int_symbol(_ARG0, _ARG1); }
+void log_Z3_mk_string_symbol(Z3_context a0, Z3_string a1);
+#define LOG_Z3_mk_string_symbol(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_string_symbol(_ARG0, _ARG1); }
+void log_Z3_mk_uninterpreted_sort(Z3_context a0, Z3_symbol a1);
+#define LOG_Z3_mk_uninterpreted_sort(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_uninterpreted_sort(_ARG0, _ARG1); }
+void log_Z3_mk_bool_sort(Z3_context a0);
+#define LOG_Z3_mk_bool_sort(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bool_sort(_ARG0); }
+void log_Z3_mk_int_sort(Z3_context a0);
+#define LOG_Z3_mk_int_sort(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_int_sort(_ARG0); }
+void log_Z3_mk_real_sort(Z3_context a0);
+#define LOG_Z3_mk_real_sort(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_real_sort(_ARG0); }
+void log_Z3_mk_bv_sort(Z3_context a0, unsigned a1);
+#define LOG_Z3_mk_bv_sort(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bv_sort(_ARG0, _ARG1); }
+void log_Z3_mk_finite_domain_sort(Z3_context a0, Z3_symbol a1, __uint64 a2);
+#define LOG_Z3_mk_finite_domain_sort(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_finite_domain_sort(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_array_sort(Z3_context a0, Z3_sort a1, Z3_sort a2);
+#define LOG_Z3_mk_array_sort(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_array_sort(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_tuple_sort(Z3_context a0, Z3_symbol a1, unsigned a2, Z3_symbol const * a3, Z3_sort const * a4, Z3_func_decl* a5, Z3_func_decl* a6);
+#define LOG_Z3_mk_tuple_sort(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6) z3_log_ctx _LOG_CTX; Z3_func_decl* Z3ARG5; unsigned Z3ARG2; Z3_func_decl* Z3ARG6; if (_LOG_CTX.enabled()) { log_Z3_mk_tuple_sort(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6); Z3ARG5 = _ARG5; Z3ARG2 = _ARG2; Z3ARG6 = _ARG6; }
+#define RETURN_Z3_mk_tuple_sort(Z3RES) if (_LOG_CTX.enabled()) { SetR(Z3RES); SetO((Z3ARG5 == 0 ? 0 : *Z3ARG5), 5); for (unsigned i = 0; i < Z3ARG2; i++) { SetAO(Z3ARG6[i], 6, i); } } return Z3RES
+void log_Z3_mk_enumeration_sort(Z3_context a0, Z3_symbol a1, unsigned a2, Z3_symbol const * a3, Z3_func_decl* a4, Z3_func_decl* a5);
+#define LOG_Z3_mk_enumeration_sort(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5) z3_log_ctx _LOG_CTX; unsigned Z3ARG2; Z3_func_decl* Z3ARG4; Z3_func_decl* Z3ARG5; if (_LOG_CTX.enabled()) { log_Z3_mk_enumeration_sort(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5); Z3ARG2 = _ARG2; Z3ARG4 = _ARG4; Z3ARG5 = _ARG5; }
+#define RETURN_Z3_mk_enumeration_sort(Z3RES) if (_LOG_CTX.enabled()) { SetR(Z3RES); for (unsigned i = 0; i < Z3ARG2; i++) { SetAO(Z3ARG4[i], 4, i); } for (unsigned i = 0; i < Z3ARG2; i++) { SetAO(Z3ARG5[i], 5, i); } } return Z3RES
+void log_Z3_mk_list_sort(Z3_context a0, Z3_symbol a1, Z3_sort a2, Z3_func_decl* a3, Z3_func_decl* a4, Z3_func_decl* a5, Z3_func_decl* a6, Z3_func_decl* a7, Z3_func_decl* a8);
+#define LOG_Z3_mk_list_sort(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7, _ARG8) z3_log_ctx _LOG_CTX; Z3_func_decl* Z3ARG3; Z3_func_decl* Z3ARG4; Z3_func_decl* Z3ARG5; Z3_func_decl* Z3ARG6; Z3_func_decl* Z3ARG7; Z3_func_decl* Z3ARG8; if (_LOG_CTX.enabled()) { log_Z3_mk_list_sort(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7, _ARG8); Z3ARG3 = _ARG3; Z3ARG4 = _ARG4; Z3ARG5 = _ARG5; Z3ARG6 = _ARG6; Z3ARG7 = _ARG7; Z3ARG8 = _ARG8; }
+#define RETURN_Z3_mk_list_sort(Z3RES) if (_LOG_CTX.enabled()) { SetR(Z3RES); SetO((Z3ARG3 == 0 ? 0 : *Z3ARG3), 3); SetO((Z3ARG4 == 0 ? 0 : *Z3ARG4), 4); SetO((Z3ARG5 == 0 ? 0 : *Z3ARG5), 5); SetO((Z3ARG6 == 0 ? 0 : *Z3ARG6), 6); SetO((Z3ARG7 == 0 ? 0 : *Z3ARG7), 7); SetO((Z3ARG8 == 0 ? 0 : *Z3ARG8), 8); } return Z3RES
+void log_Z3_mk_constructor(Z3_context a0, Z3_symbol a1, Z3_symbol a2, unsigned a3, Z3_symbol const * a4, Z3_sort const * a5, unsigned const * a6);
+#define LOG_Z3_mk_constructor(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_constructor(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6); }
+void log_Z3_del_constructor(Z3_context a0, Z3_constructor a1);
+#define LOG_Z3_del_constructor(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_del_constructor(_ARG0, _ARG1); }
+void log_Z3_mk_datatype(Z3_context a0, Z3_symbol a1, unsigned a2, Z3_constructor* a3);
+#define LOG_Z3_mk_datatype(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; unsigned Z3ARG2; Z3_constructor* Z3ARG3; if (_LOG_CTX.enabled()) { log_Z3_mk_datatype(_ARG0, _ARG1, _ARG2, _ARG3); Z3ARG2 = _ARG2; Z3ARG3 = _ARG3; }
+#define RETURN_Z3_mk_datatype(Z3RES) if (_LOG_CTX.enabled()) { SetR(Z3RES); for (unsigned i = 0; i < Z3ARG2; i++) { SetAO(Z3ARG3[i], 3, i); } } return Z3RES
+void log_Z3_mk_constructor_list(Z3_context a0, unsigned a1, Z3_constructor const * a2);
+#define LOG_Z3_mk_constructor_list(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_constructor_list(_ARG0, _ARG1, _ARG2); }
+void log_Z3_del_constructor_list(Z3_context a0, Z3_constructor_list a1);
+#define LOG_Z3_del_constructor_list(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_del_constructor_list(_ARG0, _ARG1); }
+void log_Z3_mk_datatypes(Z3_context a0, unsigned a1, Z3_symbol const * a2, Z3_sort* a3, Z3_constructor_list* a4);
+#define LOG_Z3_mk_datatypes(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4) z3_log_ctx _LOG_CTX; unsigned Z3ARG1; Z3_sort* Z3ARG3; Z3_constructor_list* Z3ARG4; if (_LOG_CTX.enabled()) { log_Z3_mk_datatypes(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4); Z3ARG1 = _ARG1; Z3ARG3 = _ARG3; Z3ARG4 = _ARG4; }
+#define RETURN_Z3_mk_datatypes if (_LOG_CTX.enabled()) { for (unsigned i = 0; i < Z3ARG1; i++) { SetAO(Z3ARG3[i], 3, i); } for (unsigned i = 0; i < Z3ARG1; i++) { SetAO(Z3ARG4[i], 4, i); } } return
+void log_Z3_query_constructor(Z3_context a0, Z3_constructor a1, unsigned a2, Z3_func_decl* a3, Z3_func_decl* a4, Z3_func_decl* a5);
+#define LOG_Z3_query_constructor(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5) z3_log_ctx _LOG_CTX; Z3_func_decl* Z3ARG3; Z3_func_decl* Z3ARG4; unsigned Z3ARG2; Z3_func_decl* Z3ARG5; if (_LOG_CTX.enabled()) { log_Z3_query_constructor(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5); Z3ARG3 = _ARG3; Z3ARG4 = _ARG4; Z3ARG2 = _ARG2; Z3ARG5 = _ARG5; }
+#define RETURN_Z3_query_constructor if (_LOG_CTX.enabled()) { SetO((Z3ARG3 == 0 ? 0 : *Z3ARG3), 3); SetO((Z3ARG4 == 0 ? 0 : *Z3ARG4), 4); for (unsigned i = 0; i < Z3ARG2; i++) { SetAO(Z3ARG5[i], 5, i); } } return
+void log_Z3_mk_func_decl(Z3_context a0, Z3_symbol a1, unsigned a2, Z3_sort const * a3, Z3_sort a4);
+#define LOG_Z3_mk_func_decl(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_func_decl(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4); }
+void log_Z3_mk_app(Z3_context a0, Z3_func_decl a1, unsigned a2, Z3_ast const * a3);
+#define LOG_Z3_mk_app(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_app(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_mk_const(Z3_context a0, Z3_symbol a1, Z3_sort a2);
+#define LOG_Z3_mk_const(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_const(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_fresh_func_decl(Z3_context a0, Z3_string a1, unsigned a2, Z3_sort const * a3, Z3_sort a4);
+#define LOG_Z3_mk_fresh_func_decl(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_fresh_func_decl(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4); }
+void log_Z3_mk_fresh_const(Z3_context a0, Z3_string a1, Z3_sort a2);
+#define LOG_Z3_mk_fresh_const(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_fresh_const(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_true(Z3_context a0);
+#define LOG_Z3_mk_true(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_true(_ARG0); }
+void log_Z3_mk_false(Z3_context a0);
+#define LOG_Z3_mk_false(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_false(_ARG0); }
+void log_Z3_mk_eq(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_eq(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_eq(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_distinct(Z3_context a0, unsigned a1, Z3_ast const * a2);
+#define LOG_Z3_mk_distinct(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_distinct(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_not(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_not(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_not(_ARG0, _ARG1); }
+void log_Z3_mk_ite(Z3_context a0, Z3_ast a1, Z3_ast a2, Z3_ast a3);
+#define LOG_Z3_mk_ite(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_ite(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_mk_iff(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_iff(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_iff(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_implies(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_implies(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_implies(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_xor(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_xor(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_xor(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_and(Z3_context a0, unsigned a1, Z3_ast const * a2);
+#define LOG_Z3_mk_and(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_and(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_or(Z3_context a0, unsigned a1, Z3_ast const * a2);
+#define LOG_Z3_mk_or(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_or(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_add(Z3_context a0, unsigned a1, Z3_ast const * a2);
+#define LOG_Z3_mk_add(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_add(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_mul(Z3_context a0, unsigned a1, Z3_ast const * a2);
+#define LOG_Z3_mk_mul(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_mul(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_sub(Z3_context a0, unsigned a1, Z3_ast const * a2);
+#define LOG_Z3_mk_sub(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_sub(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_unary_minus(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_unary_minus(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_unary_minus(_ARG0, _ARG1); }
+void log_Z3_mk_div(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_div(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_div(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_mod(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_mod(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_mod(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_rem(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_rem(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_rem(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_power(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_power(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_power(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_lt(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_lt(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_lt(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_le(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_le(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_le(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_gt(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_gt(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_gt(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_ge(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_ge(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_ge(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_int2real(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_int2real(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_int2real(_ARG0, _ARG1); }
+void log_Z3_mk_real2int(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_real2int(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_real2int(_ARG0, _ARG1); }
+void log_Z3_mk_is_int(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_is_int(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_is_int(_ARG0, _ARG1); }
+void log_Z3_mk_bvnot(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_bvnot(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvnot(_ARG0, _ARG1); }
+void log_Z3_mk_bvredand(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_bvredand(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvredand(_ARG0, _ARG1); }
+void log_Z3_mk_bvredor(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_bvredor(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvredor(_ARG0, _ARG1); }
+void log_Z3_mk_bvand(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvand(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvand(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvor(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvor(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvor(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvxor(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvxor(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvxor(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvnand(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvnand(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvnand(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvnor(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvnor(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvnor(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvxnor(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvxnor(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvxnor(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvneg(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_bvneg(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvneg(_ARG0, _ARG1); }
+void log_Z3_mk_bvadd(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvadd(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvadd(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvsub(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvsub(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvsub(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvmul(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvmul(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvmul(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvudiv(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvudiv(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvudiv(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvsdiv(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvsdiv(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvsdiv(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvurem(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvurem(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvurem(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvsrem(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvsrem(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvsrem(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvsmod(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvsmod(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvsmod(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvult(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvult(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvult(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvslt(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvslt(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvslt(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvule(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvule(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvule(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvsle(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvsle(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvsle(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvuge(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvuge(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvuge(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvsge(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvsge(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvsge(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvugt(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvugt(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvugt(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvsgt(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvsgt(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvsgt(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_concat(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_concat(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_concat(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_extract(Z3_context a0, unsigned a1, unsigned a2, Z3_ast a3);
+#define LOG_Z3_mk_extract(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_extract(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_mk_sign_ext(Z3_context a0, unsigned a1, Z3_ast a2);
+#define LOG_Z3_mk_sign_ext(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_sign_ext(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_zero_ext(Z3_context a0, unsigned a1, Z3_ast a2);
+#define LOG_Z3_mk_zero_ext(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_zero_ext(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_repeat(Z3_context a0, unsigned a1, Z3_ast a2);
+#define LOG_Z3_mk_repeat(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_repeat(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvshl(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvshl(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvshl(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvlshr(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvlshr(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvlshr(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvashr(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvashr(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvashr(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_rotate_left(Z3_context a0, unsigned a1, Z3_ast a2);
+#define LOG_Z3_mk_rotate_left(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_rotate_left(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_rotate_right(Z3_context a0, unsigned a1, Z3_ast a2);
+#define LOG_Z3_mk_rotate_right(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_rotate_right(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_ext_rotate_left(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_ext_rotate_left(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_ext_rotate_left(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_ext_rotate_right(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_ext_rotate_right(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_ext_rotate_right(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_int2bv(Z3_context a0, unsigned a1, Z3_ast a2);
+#define LOG_Z3_mk_int2bv(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_int2bv(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bv2int(Z3_context a0, Z3_ast a1, Z3_bool a2);
+#define LOG_Z3_mk_bv2int(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bv2int(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvadd_no_overflow(Z3_context a0, Z3_ast a1, Z3_ast a2, Z3_bool a3);
+#define LOG_Z3_mk_bvadd_no_overflow(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvadd_no_overflow(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_mk_bvadd_no_underflow(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvadd_no_underflow(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvadd_no_underflow(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvsub_no_overflow(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvsub_no_overflow(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvsub_no_overflow(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvsub_no_underflow(Z3_context a0, Z3_ast a1, Z3_ast a2, Z3_bool a3);
+#define LOG_Z3_mk_bvsub_no_underflow(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvsub_no_underflow(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_mk_bvsdiv_no_overflow(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvsdiv_no_overflow(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvsdiv_no_overflow(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bvneg_no_overflow(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_bvneg_no_overflow(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvneg_no_overflow(_ARG0, _ARG1); }
+void log_Z3_mk_bvmul_no_overflow(Z3_context a0, Z3_ast a1, Z3_ast a2, Z3_bool a3);
+#define LOG_Z3_mk_bvmul_no_overflow(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvmul_no_overflow(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_mk_bvmul_no_underflow(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_bvmul_no_underflow(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bvmul_no_underflow(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_select(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_select(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_select(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_store(Z3_context a0, Z3_ast a1, Z3_ast a2, Z3_ast a3);
+#define LOG_Z3_mk_store(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_store(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_mk_const_array(Z3_context a0, Z3_sort a1, Z3_ast a2);
+#define LOG_Z3_mk_const_array(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_const_array(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_map(Z3_context a0, Z3_func_decl a1, unsigned a2, Z3_ast const * a3);
+#define LOG_Z3_mk_map(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_map(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_mk_array_default(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_array_default(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_array_default(_ARG0, _ARG1); }
+void log_Z3_mk_set_sort(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_mk_set_sort(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_set_sort(_ARG0, _ARG1); }
+void log_Z3_mk_empty_set(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_mk_empty_set(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_empty_set(_ARG0, _ARG1); }
+void log_Z3_mk_full_set(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_mk_full_set(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_full_set(_ARG0, _ARG1); }
+void log_Z3_mk_set_add(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_set_add(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_set_add(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_set_del(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_set_del(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_set_del(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_set_union(Z3_context a0, unsigned a1, Z3_ast const * a2);
+#define LOG_Z3_mk_set_union(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_set_union(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_set_intersect(Z3_context a0, unsigned a1, Z3_ast const * a2);
+#define LOG_Z3_mk_set_intersect(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_set_intersect(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_set_difference(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_set_difference(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_set_difference(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_set_complement(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_mk_set_complement(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_set_complement(_ARG0, _ARG1); }
+void log_Z3_mk_set_member(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_set_member(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_set_member(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_set_subset(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_mk_set_subset(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_set_subset(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_numeral(Z3_context a0, Z3_string a1, Z3_sort a2);
+#define LOG_Z3_mk_numeral(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_numeral(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_real(Z3_context a0, int a1, int a2);
+#define LOG_Z3_mk_real(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_real(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_int(Z3_context a0, int a1, Z3_sort a2);
+#define LOG_Z3_mk_int(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_int(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_unsigned_int(Z3_context a0, unsigned a1, Z3_sort a2);
+#define LOG_Z3_mk_unsigned_int(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_unsigned_int(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_int64(Z3_context a0, __int64 a1, Z3_sort a2);
+#define LOG_Z3_mk_int64(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_int64(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_unsigned_int64(Z3_context a0, __uint64 a1, Z3_sort a2);
+#define LOG_Z3_mk_unsigned_int64(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_unsigned_int64(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_pattern(Z3_context a0, unsigned a1, Z3_ast const * a2);
+#define LOG_Z3_mk_pattern(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_pattern(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_bound(Z3_context a0, unsigned a1, Z3_sort a2);
+#define LOG_Z3_mk_bound(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_bound(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_forall(Z3_context a0, unsigned a1, unsigned a2, Z3_pattern const * a3, unsigned a4, Z3_sort const * a5, Z3_symbol const * a6, Z3_ast a7);
+#define LOG_Z3_mk_forall(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_forall(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7); }
+void log_Z3_mk_exists(Z3_context a0, unsigned a1, unsigned a2, Z3_pattern const * a3, unsigned a4, Z3_sort const * a5, Z3_symbol const * a6, Z3_ast a7);
+#define LOG_Z3_mk_exists(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_exists(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7); }
+void log_Z3_mk_quantifier(Z3_context a0, Z3_bool a1, unsigned a2, unsigned a3, Z3_pattern const * a4, unsigned a5, Z3_sort const * a6, Z3_symbol const * a7, Z3_ast a8);
+#define LOG_Z3_mk_quantifier(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7, _ARG8) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_quantifier(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7, _ARG8); }
+void log_Z3_mk_quantifier_ex(Z3_context a0, Z3_bool a1, unsigned a2, Z3_symbol a3, Z3_symbol a4, unsigned a5, Z3_pattern const * a6, unsigned a7, Z3_ast const * a8, unsigned a9, Z3_sort const * a10, Z3_symbol const * a11, Z3_ast a12);
+#define LOG_Z3_mk_quantifier_ex(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7, _ARG8, _ARG9, _ARG10, _ARG11, _ARG12) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_quantifier_ex(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7, _ARG8, _ARG9, _ARG10, _ARG11, _ARG12); }
+void log_Z3_mk_forall_const(Z3_context a0, unsigned a1, unsigned a2, Z3_app const * a3, unsigned a4, Z3_pattern const * a5, Z3_ast a6);
+#define LOG_Z3_mk_forall_const(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_forall_const(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6); }
+void log_Z3_mk_exists_const(Z3_context a0, unsigned a1, unsigned a2, Z3_app const * a3, unsigned a4, Z3_pattern const * a5, Z3_ast a6);
+#define LOG_Z3_mk_exists_const(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_exists_const(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6); }
+void log_Z3_mk_quantifier_const(Z3_context a0, Z3_bool a1, unsigned a2, unsigned a3, Z3_app const * a4, unsigned a5, Z3_pattern const * a6, Z3_ast a7);
+#define LOG_Z3_mk_quantifier_const(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_quantifier_const(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7); }
+void log_Z3_mk_quantifier_const_ex(Z3_context a0, Z3_bool a1, unsigned a2, Z3_symbol a3, Z3_symbol a4, unsigned a5, Z3_app const * a6, unsigned a7, Z3_pattern const * a8, unsigned a9, Z3_ast const * a10, Z3_ast a11);
+#define LOG_Z3_mk_quantifier_const_ex(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7, _ARG8, _ARG9, _ARG10, _ARG11) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_quantifier_const_ex(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7, _ARG8, _ARG9, _ARG10, _ARG11); }
+void log_Z3_get_symbol_kind(Z3_context a0, Z3_symbol a1);
+#define LOG_Z3_get_symbol_kind(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_symbol_kind(_ARG0, _ARG1); }
+void log_Z3_get_symbol_int(Z3_context a0, Z3_symbol a1);
+#define LOG_Z3_get_symbol_int(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_symbol_int(_ARG0, _ARG1); }
+void log_Z3_get_symbol_string(Z3_context a0, Z3_symbol a1);
+#define LOG_Z3_get_symbol_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_symbol_string(_ARG0, _ARG1); }
+void log_Z3_get_sort_name(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_get_sort_name(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_sort_name(_ARG0, _ARG1); }
+void log_Z3_get_sort_id(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_get_sort_id(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_sort_id(_ARG0, _ARG1); }
+void log_Z3_sort_to_ast(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_sort_to_ast(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_sort_to_ast(_ARG0, _ARG1); }
+void log_Z3_is_eq_sort(Z3_context a0, Z3_sort a1, Z3_sort a2);
+#define LOG_Z3_is_eq_sort(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_is_eq_sort(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_sort_kind(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_get_sort_kind(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_sort_kind(_ARG0, _ARG1); }
+void log_Z3_get_bv_sort_size(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_get_bv_sort_size(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_bv_sort_size(_ARG0, _ARG1); }
+void log_Z3_get_finite_domain_sort_size(Z3_context a0, Z3_sort a1, __uint64* a2);
+#define LOG_Z3_get_finite_domain_sort_size(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_finite_domain_sort_size(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_array_sort_domain(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_get_array_sort_domain(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_array_sort_domain(_ARG0, _ARG1); }
+void log_Z3_get_array_sort_range(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_get_array_sort_range(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_array_sort_range(_ARG0, _ARG1); }
+void log_Z3_get_tuple_sort_mk_decl(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_get_tuple_sort_mk_decl(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_tuple_sort_mk_decl(_ARG0, _ARG1); }
+void log_Z3_get_tuple_sort_num_fields(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_get_tuple_sort_num_fields(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_tuple_sort_num_fields(_ARG0, _ARG1); }
+void log_Z3_get_tuple_sort_field_decl(Z3_context a0, Z3_sort a1, unsigned a2);
+#define LOG_Z3_get_tuple_sort_field_decl(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_tuple_sort_field_decl(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_datatype_sort_num_constructors(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_get_datatype_sort_num_constructors(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_datatype_sort_num_constructors(_ARG0, _ARG1); }
+void log_Z3_get_datatype_sort_constructor(Z3_context a0, Z3_sort a1, unsigned a2);
+#define LOG_Z3_get_datatype_sort_constructor(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_datatype_sort_constructor(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_datatype_sort_recognizer(Z3_context a0, Z3_sort a1, unsigned a2);
+#define LOG_Z3_get_datatype_sort_recognizer(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_datatype_sort_recognizer(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_datatype_sort_constructor_accessor(Z3_context a0, Z3_sort a1, unsigned a2, unsigned a3);
+#define LOG_Z3_get_datatype_sort_constructor_accessor(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_datatype_sort_constructor_accessor(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_get_relation_arity(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_get_relation_arity(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_relation_arity(_ARG0, _ARG1); }
+void log_Z3_get_relation_column(Z3_context a0, Z3_sort a1, unsigned a2);
+#define LOG_Z3_get_relation_column(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_relation_column(_ARG0, _ARG1, _ARG2); }
+void log_Z3_func_decl_to_ast(Z3_context a0, Z3_func_decl a1);
+#define LOG_Z3_func_decl_to_ast(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_decl_to_ast(_ARG0, _ARG1); }
+void log_Z3_is_eq_func_decl(Z3_context a0, Z3_func_decl a1, Z3_func_decl a2);
+#define LOG_Z3_is_eq_func_decl(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_is_eq_func_decl(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_func_decl_id(Z3_context a0, Z3_func_decl a1);
+#define LOG_Z3_get_func_decl_id(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_func_decl_id(_ARG0, _ARG1); }
+void log_Z3_get_decl_name(Z3_context a0, Z3_func_decl a1);
+#define LOG_Z3_get_decl_name(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_name(_ARG0, _ARG1); }
+void log_Z3_get_decl_kind(Z3_context a0, Z3_func_decl a1);
+#define LOG_Z3_get_decl_kind(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_kind(_ARG0, _ARG1); }
+void log_Z3_get_domain_size(Z3_context a0, Z3_func_decl a1);
+#define LOG_Z3_get_domain_size(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_domain_size(_ARG0, _ARG1); }
+void log_Z3_get_arity(Z3_context a0, Z3_func_decl a1);
+#define LOG_Z3_get_arity(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_arity(_ARG0, _ARG1); }
+void log_Z3_get_domain(Z3_context a0, Z3_func_decl a1, unsigned a2);
+#define LOG_Z3_get_domain(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_domain(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_range(Z3_context a0, Z3_func_decl a1);
+#define LOG_Z3_get_range(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_range(_ARG0, _ARG1); }
+void log_Z3_get_decl_num_parameters(Z3_context a0, Z3_func_decl a1);
+#define LOG_Z3_get_decl_num_parameters(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_num_parameters(_ARG0, _ARG1); }
+void log_Z3_get_decl_parameter_kind(Z3_context a0, Z3_func_decl a1, unsigned a2);
+#define LOG_Z3_get_decl_parameter_kind(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_parameter_kind(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_decl_int_parameter(Z3_context a0, Z3_func_decl a1, unsigned a2);
+#define LOG_Z3_get_decl_int_parameter(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_int_parameter(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_decl_double_parameter(Z3_context a0, Z3_func_decl a1, unsigned a2);
+#define LOG_Z3_get_decl_double_parameter(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_double_parameter(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_decl_symbol_parameter(Z3_context a0, Z3_func_decl a1, unsigned a2);
+#define LOG_Z3_get_decl_symbol_parameter(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_symbol_parameter(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_decl_sort_parameter(Z3_context a0, Z3_func_decl a1, unsigned a2);
+#define LOG_Z3_get_decl_sort_parameter(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_sort_parameter(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_decl_ast_parameter(Z3_context a0, Z3_func_decl a1, unsigned a2);
+#define LOG_Z3_get_decl_ast_parameter(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_ast_parameter(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_decl_func_decl_parameter(Z3_context a0, Z3_func_decl a1, unsigned a2);
+#define LOG_Z3_get_decl_func_decl_parameter(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_func_decl_parameter(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_decl_rational_parameter(Z3_context a0, Z3_func_decl a1, unsigned a2);
+#define LOG_Z3_get_decl_rational_parameter(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_decl_rational_parameter(_ARG0, _ARG1, _ARG2); }
+void log_Z3_app_to_ast(Z3_context a0, Z3_app a1);
+#define LOG_Z3_app_to_ast(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_app_to_ast(_ARG0, _ARG1); }
+void log_Z3_get_app_decl(Z3_context a0, Z3_app a1);
+#define LOG_Z3_get_app_decl(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_app_decl(_ARG0, _ARG1); }
+void log_Z3_get_app_num_args(Z3_context a0, Z3_app a1);
+#define LOG_Z3_get_app_num_args(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_app_num_args(_ARG0, _ARG1); }
+void log_Z3_get_app_arg(Z3_context a0, Z3_app a1, unsigned a2);
+#define LOG_Z3_get_app_arg(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_app_arg(_ARG0, _ARG1, _ARG2); }
+void log_Z3_is_eq_ast(Z3_context a0, Z3_ast a1, Z3_ast a2);
+#define LOG_Z3_is_eq_ast(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_is_eq_ast(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_ast_id(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_ast_id(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_ast_id(_ARG0, _ARG1); }
+void log_Z3_get_ast_hash(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_ast_hash(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_ast_hash(_ARG0, _ARG1); }
+void log_Z3_get_sort(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_sort(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_sort(_ARG0, _ARG1); }
+void log_Z3_is_well_sorted(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_is_well_sorted(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_is_well_sorted(_ARG0, _ARG1); }
+void log_Z3_get_bool_value(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_bool_value(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_bool_value(_ARG0, _ARG1); }
+void log_Z3_get_ast_kind(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_ast_kind(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_ast_kind(_ARG0, _ARG1); }
+void log_Z3_is_app(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_is_app(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_is_app(_ARG0, _ARG1); }
+void log_Z3_is_numeral_ast(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_is_numeral_ast(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_is_numeral_ast(_ARG0, _ARG1); }
+void log_Z3_is_algebraic_number(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_is_algebraic_number(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_is_algebraic_number(_ARG0, _ARG1); }
+void log_Z3_to_app(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_to_app(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_to_app(_ARG0, _ARG1); }
+void log_Z3_to_func_decl(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_to_func_decl(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_to_func_decl(_ARG0, _ARG1); }
+void log_Z3_get_numeral_string(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_numeral_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_numeral_string(_ARG0, _ARG1); }
+void log_Z3_get_numeral_decimal_string(Z3_context a0, Z3_ast a1, unsigned a2);
+#define LOG_Z3_get_numeral_decimal_string(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_numeral_decimal_string(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_numerator(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_numerator(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_numerator(_ARG0, _ARG1); }
+void log_Z3_get_denominator(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_denominator(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_denominator(_ARG0, _ARG1); }
+void log_Z3_get_numeral_small(Z3_context a0, Z3_ast a1, __int64* a2, __int64* a3);
+#define LOG_Z3_get_numeral_small(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_numeral_small(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_get_numeral_int(Z3_context a0, Z3_ast a1, int* a2);
+#define LOG_Z3_get_numeral_int(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_numeral_int(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_numeral_uint(Z3_context a0, Z3_ast a1, unsigned* a2);
+#define LOG_Z3_get_numeral_uint(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_numeral_uint(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_numeral_uint64(Z3_context a0, Z3_ast a1, __uint64* a2);
+#define LOG_Z3_get_numeral_uint64(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_numeral_uint64(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_numeral_int64(Z3_context a0, Z3_ast a1, __int64* a2);
+#define LOG_Z3_get_numeral_int64(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_numeral_int64(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_numeral_rational_int64(Z3_context a0, Z3_ast a1, __int64* a2, __int64* a3);
+#define LOG_Z3_get_numeral_rational_int64(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_numeral_rational_int64(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_get_algebraic_number_lower(Z3_context a0, Z3_ast a1, unsigned a2);
+#define LOG_Z3_get_algebraic_number_lower(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_algebraic_number_lower(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_algebraic_number_upper(Z3_context a0, Z3_ast a1, unsigned a2);
+#define LOG_Z3_get_algebraic_number_upper(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_algebraic_number_upper(_ARG0, _ARG1, _ARG2); }
+void log_Z3_pattern_to_ast(Z3_context a0, Z3_pattern a1);
+#define LOG_Z3_pattern_to_ast(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_pattern_to_ast(_ARG0, _ARG1); }
+void log_Z3_get_pattern_num_terms(Z3_context a0, Z3_pattern a1);
+#define LOG_Z3_get_pattern_num_terms(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_pattern_num_terms(_ARG0, _ARG1); }
+void log_Z3_get_pattern(Z3_context a0, Z3_pattern a1, unsigned a2);
+#define LOG_Z3_get_pattern(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_pattern(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_index_value(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_index_value(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_index_value(_ARG0, _ARG1); }
+void log_Z3_is_quantifier_forall(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_is_quantifier_forall(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_is_quantifier_forall(_ARG0, _ARG1); }
+void log_Z3_get_quantifier_weight(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_quantifier_weight(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_quantifier_weight(_ARG0, _ARG1); }
+void log_Z3_get_quantifier_num_patterns(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_quantifier_num_patterns(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_quantifier_num_patterns(_ARG0, _ARG1); }
+void log_Z3_get_quantifier_pattern_ast(Z3_context a0, Z3_ast a1, unsigned a2);
+#define LOG_Z3_get_quantifier_pattern_ast(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_quantifier_pattern_ast(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_quantifier_num_no_patterns(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_quantifier_num_no_patterns(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_quantifier_num_no_patterns(_ARG0, _ARG1); }
+void log_Z3_get_quantifier_no_pattern_ast(Z3_context a0, Z3_ast a1, unsigned a2);
+#define LOG_Z3_get_quantifier_no_pattern_ast(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_quantifier_no_pattern_ast(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_quantifier_num_bound(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_quantifier_num_bound(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_quantifier_num_bound(_ARG0, _ARG1); }
+void log_Z3_get_quantifier_bound_name(Z3_context a0, Z3_ast a1, unsigned a2);
+#define LOG_Z3_get_quantifier_bound_name(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_quantifier_bound_name(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_quantifier_bound_sort(Z3_context a0, Z3_ast a1, unsigned a2);
+#define LOG_Z3_get_quantifier_bound_sort(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_quantifier_bound_sort(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_quantifier_body(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_quantifier_body(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_quantifier_body(_ARG0, _ARG1); }
+void log_Z3_simplify(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_simplify(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_simplify(_ARG0, _ARG1); }
+void log_Z3_simplify_ex(Z3_context a0, Z3_ast a1, Z3_params a2);
+#define LOG_Z3_simplify_ex(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_simplify_ex(_ARG0, _ARG1, _ARG2); }
+void log_Z3_simplify_get_help(Z3_context a0);
+#define LOG_Z3_simplify_get_help(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_simplify_get_help(_ARG0); }
+void log_Z3_simplify_get_param_descrs(Z3_context a0);
+#define LOG_Z3_simplify_get_param_descrs(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_simplify_get_param_descrs(_ARG0); }
+void log_Z3_update_term(Z3_context a0, Z3_ast a1, unsigned a2, Z3_ast const * a3);
+#define LOG_Z3_update_term(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_update_term(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_substitute(Z3_context a0, Z3_ast a1, unsigned a2, Z3_ast const * a3, Z3_ast const * a4);
+#define LOG_Z3_substitute(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_substitute(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4); }
+void log_Z3_substitute_vars(Z3_context a0, Z3_ast a1, unsigned a2, Z3_ast const * a3);
+#define LOG_Z3_substitute_vars(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_substitute_vars(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_translate(Z3_context a0, Z3_ast a1, Z3_context a2);
+#define LOG_Z3_translate(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_translate(_ARG0, _ARG1, _ARG2); }
+void log_Z3_model_inc_ref(Z3_context a0, Z3_model a1);
+#define LOG_Z3_model_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_inc_ref(_ARG0, _ARG1); }
+void log_Z3_model_dec_ref(Z3_context a0, Z3_model a1);
+#define LOG_Z3_model_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_dec_ref(_ARG0, _ARG1); }
+void log_Z3_model_eval(Z3_context a0, Z3_model a1, Z3_ast a2, Z3_bool a3, Z3_ast* a4);
+#define LOG_Z3_model_eval(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4) z3_log_ctx _LOG_CTX; Z3_ast* Z3ARG4; if (_LOG_CTX.enabled()) { log_Z3_model_eval(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4); Z3ARG4 = _ARG4; }
+#define RETURN_Z3_model_eval if (_LOG_CTX.enabled()) { SetO((Z3ARG4 == 0 ? 0 : *Z3ARG4), 4); } return
+void log_Z3_model_get_const_interp(Z3_context a0, Z3_model a1, Z3_func_decl a2);
+#define LOG_Z3_model_get_const_interp(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_get_const_interp(_ARG0, _ARG1, _ARG2); }
+void log_Z3_model_get_func_interp(Z3_context a0, Z3_model a1, Z3_func_decl a2);
+#define LOG_Z3_model_get_func_interp(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_get_func_interp(_ARG0, _ARG1, _ARG2); }
+void log_Z3_model_get_num_consts(Z3_context a0, Z3_model a1);
+#define LOG_Z3_model_get_num_consts(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_get_num_consts(_ARG0, _ARG1); }
+void log_Z3_model_get_const_decl(Z3_context a0, Z3_model a1, unsigned a2);
+#define LOG_Z3_model_get_const_decl(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_get_const_decl(_ARG0, _ARG1, _ARG2); }
+void log_Z3_model_get_num_funcs(Z3_context a0, Z3_model a1);
+#define LOG_Z3_model_get_num_funcs(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_get_num_funcs(_ARG0, _ARG1); }
+void log_Z3_model_get_func_decl(Z3_context a0, Z3_model a1, unsigned a2);
+#define LOG_Z3_model_get_func_decl(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_get_func_decl(_ARG0, _ARG1, _ARG2); }
+void log_Z3_model_get_num_sorts(Z3_context a0, Z3_model a1);
+#define LOG_Z3_model_get_num_sorts(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_get_num_sorts(_ARG0, _ARG1); }
+void log_Z3_model_get_sort(Z3_context a0, Z3_model a1, unsigned a2);
+#define LOG_Z3_model_get_sort(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_get_sort(_ARG0, _ARG1, _ARG2); }
+void log_Z3_model_get_sort_universe(Z3_context a0, Z3_model a1, Z3_sort a2);
+#define LOG_Z3_model_get_sort_universe(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_get_sort_universe(_ARG0, _ARG1, _ARG2); }
+void log_Z3_is_as_array(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_is_as_array(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_is_as_array(_ARG0, _ARG1); }
+void log_Z3_get_as_array_func_decl(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_get_as_array_func_decl(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_as_array_func_decl(_ARG0, _ARG1); }
+void log_Z3_func_interp_inc_ref(Z3_context a0, Z3_func_interp a1);
+#define LOG_Z3_func_interp_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_interp_inc_ref(_ARG0, _ARG1); }
+void log_Z3_func_interp_dec_ref(Z3_context a0, Z3_func_interp a1);
+#define LOG_Z3_func_interp_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_interp_dec_ref(_ARG0, _ARG1); }
+void log_Z3_func_interp_get_num_entries(Z3_context a0, Z3_func_interp a1);
+#define LOG_Z3_func_interp_get_num_entries(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_interp_get_num_entries(_ARG0, _ARG1); }
+void log_Z3_func_interp_get_entry(Z3_context a0, Z3_func_interp a1, unsigned a2);
+#define LOG_Z3_func_interp_get_entry(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_interp_get_entry(_ARG0, _ARG1, _ARG2); }
+void log_Z3_func_interp_get_else(Z3_context a0, Z3_func_interp a1);
+#define LOG_Z3_func_interp_get_else(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_interp_get_else(_ARG0, _ARG1); }
+void log_Z3_func_interp_get_arity(Z3_context a0, Z3_func_interp a1);
+#define LOG_Z3_func_interp_get_arity(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_interp_get_arity(_ARG0, _ARG1); }
+void log_Z3_func_entry_inc_ref(Z3_context a0, Z3_func_entry a1);
+#define LOG_Z3_func_entry_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_entry_inc_ref(_ARG0, _ARG1); }
+void log_Z3_func_entry_dec_ref(Z3_context a0, Z3_func_entry a1);
+#define LOG_Z3_func_entry_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_entry_dec_ref(_ARG0, _ARG1); }
+void log_Z3_func_entry_get_value(Z3_context a0, Z3_func_entry a1);
+#define LOG_Z3_func_entry_get_value(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_entry_get_value(_ARG0, _ARG1); }
+void log_Z3_func_entry_get_num_args(Z3_context a0, Z3_func_entry a1);
+#define LOG_Z3_func_entry_get_num_args(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_entry_get_num_args(_ARG0, _ARG1); }
+void log_Z3_func_entry_get_arg(Z3_context a0, Z3_func_entry a1, unsigned a2);
+#define LOG_Z3_func_entry_get_arg(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_entry_get_arg(_ARG0, _ARG1, _ARG2); }
+void log_Z3_toggle_warning_messages(Z3_bool a0);
+#define LOG_Z3_toggle_warning_messages(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_toggle_warning_messages(_ARG0); }
+void log_Z3_set_ast_print_mode(Z3_context a0, Z3_ast_print_mode a1);
+#define LOG_Z3_set_ast_print_mode(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_set_ast_print_mode(_ARG0, _ARG1); }
+void log_Z3_ast_to_string(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_ast_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_to_string(_ARG0, _ARG1); }
+void log_Z3_pattern_to_string(Z3_context a0, Z3_pattern a1);
+#define LOG_Z3_pattern_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_pattern_to_string(_ARG0, _ARG1); }
+void log_Z3_sort_to_string(Z3_context a0, Z3_sort a1);
+#define LOG_Z3_sort_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_sort_to_string(_ARG0, _ARG1); }
+void log_Z3_func_decl_to_string(Z3_context a0, Z3_func_decl a1);
+#define LOG_Z3_func_decl_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_func_decl_to_string(_ARG0, _ARG1); }
+void log_Z3_model_to_string(Z3_context a0, Z3_model a1);
+#define LOG_Z3_model_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_model_to_string(_ARG0, _ARG1); }
+void log_Z3_benchmark_to_smtlib_string(Z3_context a0, Z3_string a1, Z3_string a2, Z3_string a3, Z3_string a4, unsigned a5, Z3_ast const * a6, Z3_ast a7);
+#define LOG_Z3_benchmark_to_smtlib_string(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_benchmark_to_smtlib_string(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7); }
+void log_Z3_parse_smtlib2_string(Z3_context a0, Z3_string a1, unsigned a2, Z3_symbol const * a3, Z3_sort const * a4, unsigned a5, Z3_symbol const * a6, Z3_func_decl const * a7);
+#define LOG_Z3_parse_smtlib2_string(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_parse_smtlib2_string(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7); }
+void log_Z3_parse_smtlib2_file(Z3_context a0, Z3_string a1, unsigned a2, Z3_symbol const * a3, Z3_sort const * a4, unsigned a5, Z3_symbol const * a6, Z3_func_decl const * a7);
+#define LOG_Z3_parse_smtlib2_file(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_parse_smtlib2_file(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7); }
+void log_Z3_parse_smtlib_string(Z3_context a0, Z3_string a1, unsigned a2, Z3_symbol const * a3, Z3_sort const * a4, unsigned a5, Z3_symbol const * a6, Z3_func_decl const * a7);
+#define LOG_Z3_parse_smtlib_string(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_parse_smtlib_string(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7); }
+void log_Z3_parse_smtlib_file(Z3_context a0, Z3_string a1, unsigned a2, Z3_symbol const * a3, Z3_sort const * a4, unsigned a5, Z3_symbol const * a6, Z3_func_decl const * a7);
+#define LOG_Z3_parse_smtlib_file(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_parse_smtlib_file(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6, _ARG7); }
+void log_Z3_get_smtlib_num_formulas(Z3_context a0);
+#define LOG_Z3_get_smtlib_num_formulas(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_smtlib_num_formulas(_ARG0); }
+void log_Z3_get_smtlib_formula(Z3_context a0, unsigned a1);
+#define LOG_Z3_get_smtlib_formula(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_smtlib_formula(_ARG0, _ARG1); }
+void log_Z3_get_smtlib_num_assumptions(Z3_context a0);
+#define LOG_Z3_get_smtlib_num_assumptions(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_smtlib_num_assumptions(_ARG0); }
+void log_Z3_get_smtlib_assumption(Z3_context a0, unsigned a1);
+#define LOG_Z3_get_smtlib_assumption(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_smtlib_assumption(_ARG0, _ARG1); }
+void log_Z3_get_smtlib_num_decls(Z3_context a0);
+#define LOG_Z3_get_smtlib_num_decls(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_smtlib_num_decls(_ARG0); }
+void log_Z3_get_smtlib_decl(Z3_context a0, unsigned a1);
+#define LOG_Z3_get_smtlib_decl(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_smtlib_decl(_ARG0, _ARG1); }
+void log_Z3_get_smtlib_num_sorts(Z3_context a0);
+#define LOG_Z3_get_smtlib_num_sorts(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_smtlib_num_sorts(_ARG0); }
+void log_Z3_get_smtlib_sort(Z3_context a0, unsigned a1);
+#define LOG_Z3_get_smtlib_sort(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_smtlib_sort(_ARG0, _ARG1); }
+void log_Z3_get_smtlib_error(Z3_context a0);
+#define LOG_Z3_get_smtlib_error(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_smtlib_error(_ARG0); }
+void log_Z3_parse_z3_string(Z3_context a0, Z3_string a1);
+#define LOG_Z3_parse_z3_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_parse_z3_string(_ARG0, _ARG1); }
+void log_Z3_parse_z3_file(Z3_context a0, Z3_string a1);
+#define LOG_Z3_parse_z3_file(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_parse_z3_file(_ARG0, _ARG1); }
+void log_Z3_get_error_code(Z3_context a0);
+#define LOG_Z3_get_error_code(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_error_code(_ARG0); }
+void log_Z3_set_error(Z3_context a0, Z3_error_code a1);
+#define LOG_Z3_set_error(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_set_error(_ARG0, _ARG1); }
+void log_Z3_get_error_msg(Z3_error_code a0);
+#define LOG_Z3_get_error_msg(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_error_msg(_ARG0); }
+void log_Z3_get_error_msg_ex(Z3_context a0, Z3_error_code a1);
+#define LOG_Z3_get_error_msg_ex(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_error_msg_ex(_ARG0, _ARG1); }
+void log_Z3_get_version(unsigned* a0, unsigned* a1, unsigned* a2, unsigned* a3);
+#define LOG_Z3_get_version(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_version(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_reset_memory();
+#define LOG_Z3_reset_memory() z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_reset_memory(); }
+void log_Z3_mk_fixedpoint(Z3_context a0);
+#define LOG_Z3_mk_fixedpoint(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_fixedpoint(_ARG0); }
+void log_Z3_fixedpoint_inc_ref(Z3_context a0, Z3_fixedpoint a1);
+#define LOG_Z3_fixedpoint_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_inc_ref(_ARG0, _ARG1); }
+void log_Z3_fixedpoint_dec_ref(Z3_context a0, Z3_fixedpoint a1);
+#define LOG_Z3_fixedpoint_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_dec_ref(_ARG0, _ARG1); }
+void log_Z3_fixedpoint_add_rule(Z3_context a0, Z3_fixedpoint a1, Z3_ast a2, Z3_symbol a3);
+#define LOG_Z3_fixedpoint_add_rule(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_add_rule(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_fixedpoint_add_fact(Z3_context a0, Z3_fixedpoint a1, Z3_func_decl a2, unsigned a3, unsigned const * a4);
+#define LOG_Z3_fixedpoint_add_fact(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_add_fact(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4); }
+void log_Z3_fixedpoint_assert(Z3_context a0, Z3_fixedpoint a1, Z3_ast a2);
+#define LOG_Z3_fixedpoint_assert(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_assert(_ARG0, _ARG1, _ARG2); }
+void log_Z3_fixedpoint_query(Z3_context a0, Z3_fixedpoint a1, Z3_ast a2);
+#define LOG_Z3_fixedpoint_query(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_query(_ARG0, _ARG1, _ARG2); }
+void log_Z3_fixedpoint_query_relations(Z3_context a0, Z3_fixedpoint a1, unsigned a2, Z3_func_decl const * a3);
+#define LOG_Z3_fixedpoint_query_relations(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_query_relations(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_fixedpoint_get_answer(Z3_context a0, Z3_fixedpoint a1);
+#define LOG_Z3_fixedpoint_get_answer(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_get_answer(_ARG0, _ARG1); }
+void log_Z3_fixedpoint_get_reason_unknown(Z3_context a0, Z3_fixedpoint a1);
+#define LOG_Z3_fixedpoint_get_reason_unknown(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_get_reason_unknown(_ARG0, _ARG1); }
+void log_Z3_fixedpoint_update_rule(Z3_context a0, Z3_fixedpoint a1, Z3_ast a2, Z3_symbol a3);
+#define LOG_Z3_fixedpoint_update_rule(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_update_rule(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_fixedpoint_get_num_levels(Z3_context a0, Z3_fixedpoint a1, Z3_func_decl a2);
+#define LOG_Z3_fixedpoint_get_num_levels(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_get_num_levels(_ARG0, _ARG1, _ARG2); }
+void log_Z3_fixedpoint_get_cover_delta(Z3_context a0, Z3_fixedpoint a1, int a2, Z3_func_decl a3);
+#define LOG_Z3_fixedpoint_get_cover_delta(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_get_cover_delta(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_fixedpoint_add_cover(Z3_context a0, Z3_fixedpoint a1, int a2, Z3_func_decl a3, Z3_ast a4);
+#define LOG_Z3_fixedpoint_add_cover(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_add_cover(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4); }
+void log_Z3_fixedpoint_get_statistics(Z3_context a0, Z3_fixedpoint a1);
+#define LOG_Z3_fixedpoint_get_statistics(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_get_statistics(_ARG0, _ARG1); }
+void log_Z3_fixedpoint_register_relation(Z3_context a0, Z3_fixedpoint a1, Z3_func_decl a2);
+#define LOG_Z3_fixedpoint_register_relation(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_register_relation(_ARG0, _ARG1, _ARG2); }
+void log_Z3_fixedpoint_set_predicate_representation(Z3_context a0, Z3_fixedpoint a1, Z3_func_decl a2, unsigned a3, Z3_symbol const * a4);
+#define LOG_Z3_fixedpoint_set_predicate_representation(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_set_predicate_representation(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4); }
+void log_Z3_fixedpoint_simplify_rules(Z3_context a0, Z3_fixedpoint a1, unsigned a2, Z3_ast const * a3, unsigned a4, Z3_func_decl const * a5);
+#define LOG_Z3_fixedpoint_simplify_rules(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_simplify_rules(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5); }
+void log_Z3_fixedpoint_set_params(Z3_context a0, Z3_fixedpoint a1, Z3_params a2);
+#define LOG_Z3_fixedpoint_set_params(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_set_params(_ARG0, _ARG1, _ARG2); }
+void log_Z3_fixedpoint_get_help(Z3_context a0, Z3_fixedpoint a1);
+#define LOG_Z3_fixedpoint_get_help(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_get_help(_ARG0, _ARG1); }
+void log_Z3_fixedpoint_get_param_descrs(Z3_context a0, Z3_fixedpoint a1);
+#define LOG_Z3_fixedpoint_get_param_descrs(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_get_param_descrs(_ARG0, _ARG1); }
+void log_Z3_fixedpoint_to_string(Z3_context a0, Z3_fixedpoint a1, unsigned a2, Z3_ast const * a3);
+#define LOG_Z3_fixedpoint_to_string(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_to_string(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_fixedpoint_push(Z3_context a0, Z3_fixedpoint a1);
+#define LOG_Z3_fixedpoint_push(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_push(_ARG0, _ARG1); }
+void log_Z3_fixedpoint_pop(Z3_context a0, Z3_fixedpoint a1);
+#define LOG_Z3_fixedpoint_pop(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_fixedpoint_pop(_ARG0, _ARG1); }
+void log_Z3_mk_ast_vector(Z3_context a0);
+#define LOG_Z3_mk_ast_vector(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_ast_vector(_ARG0); }
+void log_Z3_ast_vector_inc_ref(Z3_context a0, Z3_ast_vector a1);
+#define LOG_Z3_ast_vector_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_vector_inc_ref(_ARG0, _ARG1); }
+void log_Z3_ast_vector_dec_ref(Z3_context a0, Z3_ast_vector a1);
+#define LOG_Z3_ast_vector_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_vector_dec_ref(_ARG0, _ARG1); }
+void log_Z3_ast_vector_size(Z3_context a0, Z3_ast_vector a1);
+#define LOG_Z3_ast_vector_size(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_vector_size(_ARG0, _ARG1); }
+void log_Z3_ast_vector_get(Z3_context a0, Z3_ast_vector a1, unsigned a2);
+#define LOG_Z3_ast_vector_get(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_vector_get(_ARG0, _ARG1, _ARG2); }
+void log_Z3_ast_vector_set(Z3_context a0, Z3_ast_vector a1, unsigned a2, Z3_ast a3);
+#define LOG_Z3_ast_vector_set(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_vector_set(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_ast_vector_resize(Z3_context a0, Z3_ast_vector a1, unsigned a2);
+#define LOG_Z3_ast_vector_resize(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_vector_resize(_ARG0, _ARG1, _ARG2); }
+void log_Z3_ast_vector_push(Z3_context a0, Z3_ast_vector a1, Z3_ast a2);
+#define LOG_Z3_ast_vector_push(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_vector_push(_ARG0, _ARG1, _ARG2); }
+void log_Z3_ast_vector_translate(Z3_context a0, Z3_ast_vector a1, Z3_context a2);
+#define LOG_Z3_ast_vector_translate(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_vector_translate(_ARG0, _ARG1, _ARG2); }
+void log_Z3_ast_vector_to_string(Z3_context a0, Z3_ast_vector a1);
+#define LOG_Z3_ast_vector_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_vector_to_string(_ARG0, _ARG1); }
+void log_Z3_mk_ast_map(Z3_context a0);
+#define LOG_Z3_mk_ast_map(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_ast_map(_ARG0); }
+void log_Z3_ast_map_inc_ref(Z3_context a0, Z3_ast_map a1);
+#define LOG_Z3_ast_map_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_map_inc_ref(_ARG0, _ARG1); }
+void log_Z3_ast_map_dec_ref(Z3_context a0, Z3_ast_map a1);
+#define LOG_Z3_ast_map_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_map_dec_ref(_ARG0, _ARG1); }
+void log_Z3_ast_map_contains(Z3_context a0, Z3_ast_map a1, Z3_ast a2);
+#define LOG_Z3_ast_map_contains(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_map_contains(_ARG0, _ARG1, _ARG2); }
+void log_Z3_ast_map_find(Z3_context a0, Z3_ast_map a1, Z3_ast a2);
+#define LOG_Z3_ast_map_find(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_map_find(_ARG0, _ARG1, _ARG2); }
+void log_Z3_ast_map_insert(Z3_context a0, Z3_ast_map a1, Z3_ast a2, Z3_ast a3);
+#define LOG_Z3_ast_map_insert(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_map_insert(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_ast_map_erase(Z3_context a0, Z3_ast_map a1, Z3_ast a2);
+#define LOG_Z3_ast_map_erase(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_map_erase(_ARG0, _ARG1, _ARG2); }
+void log_Z3_ast_map_reset(Z3_context a0, Z3_ast_map a1);
+#define LOG_Z3_ast_map_reset(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_map_reset(_ARG0, _ARG1); }
+void log_Z3_ast_map_size(Z3_context a0, Z3_ast_map a1);
+#define LOG_Z3_ast_map_size(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_map_size(_ARG0, _ARG1); }
+void log_Z3_ast_map_keys(Z3_context a0, Z3_ast_map a1);
+#define LOG_Z3_ast_map_keys(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_map_keys(_ARG0, _ARG1); }
+void log_Z3_ast_map_to_string(Z3_context a0, Z3_ast_map a1);
+#define LOG_Z3_ast_map_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_ast_map_to_string(_ARG0, _ARG1); }
+void log_Z3_mk_goal(Z3_context a0, Z3_bool a1, Z3_bool a2, Z3_bool a3);
+#define LOG_Z3_mk_goal(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_goal(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_goal_inc_ref(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_inc_ref(_ARG0, _ARG1); }
+void log_Z3_goal_dec_ref(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_dec_ref(_ARG0, _ARG1); }
+void log_Z3_goal_precision(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_precision(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_precision(_ARG0, _ARG1); }
+void log_Z3_goal_assert(Z3_context a0, Z3_goal a1, Z3_ast a2);
+#define LOG_Z3_goal_assert(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_assert(_ARG0, _ARG1, _ARG2); }
+void log_Z3_goal_inconsistent(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_inconsistent(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_inconsistent(_ARG0, _ARG1); }
+void log_Z3_goal_depth(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_depth(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_depth(_ARG0, _ARG1); }
+void log_Z3_goal_reset(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_reset(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_reset(_ARG0, _ARG1); }
+void log_Z3_goal_size(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_size(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_size(_ARG0, _ARG1); }
+void log_Z3_goal_formula(Z3_context a0, Z3_goal a1, unsigned a2);
+#define LOG_Z3_goal_formula(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_formula(_ARG0, _ARG1, _ARG2); }
+void log_Z3_goal_num_exprs(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_num_exprs(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_num_exprs(_ARG0, _ARG1); }
+void log_Z3_goal_is_decided_sat(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_is_decided_sat(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_is_decided_sat(_ARG0, _ARG1); }
+void log_Z3_goal_is_decided_unsat(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_is_decided_unsat(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_is_decided_unsat(_ARG0, _ARG1); }
+void log_Z3_goal_translate(Z3_context a0, Z3_goal a1, Z3_context a2);
+#define LOG_Z3_goal_translate(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_translate(_ARG0, _ARG1, _ARG2); }
+void log_Z3_goal_to_string(Z3_context a0, Z3_goal a1);
+#define LOG_Z3_goal_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_goal_to_string(_ARG0, _ARG1); }
+void log_Z3_mk_tactic(Z3_context a0, Z3_string a1);
+#define LOG_Z3_mk_tactic(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_tactic(_ARG0, _ARG1); }
+void log_Z3_tactic_inc_ref(Z3_context a0, Z3_tactic a1);
+#define LOG_Z3_tactic_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_inc_ref(_ARG0, _ARG1); }
+void log_Z3_tactic_dec_ref(Z3_context a0, Z3_tactic a1);
+#define LOG_Z3_tactic_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_dec_ref(_ARG0, _ARG1); }
+void log_Z3_mk_probe(Z3_context a0, Z3_string a1);
+#define LOG_Z3_mk_probe(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_probe(_ARG0, _ARG1); }
+void log_Z3_probe_inc_ref(Z3_context a0, Z3_probe a1);
+#define LOG_Z3_probe_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_inc_ref(_ARG0, _ARG1); }
+void log_Z3_probe_dec_ref(Z3_context a0, Z3_probe a1);
+#define LOG_Z3_probe_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_dec_ref(_ARG0, _ARG1); }
+void log_Z3_tactic_and_then(Z3_context a0, Z3_tactic a1, Z3_tactic a2);
+#define LOG_Z3_tactic_and_then(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_and_then(_ARG0, _ARG1, _ARG2); }
+void log_Z3_tactic_or_else(Z3_context a0, Z3_tactic a1, Z3_tactic a2);
+#define LOG_Z3_tactic_or_else(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_or_else(_ARG0, _ARG1, _ARG2); }
+void log_Z3_tactic_par_or(Z3_context a0, unsigned a1, Z3_tactic const * a2);
+#define LOG_Z3_tactic_par_or(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_par_or(_ARG0, _ARG1, _ARG2); }
+void log_Z3_tactic_par_and_then(Z3_context a0, Z3_tactic a1, Z3_tactic a2);
+#define LOG_Z3_tactic_par_and_then(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_par_and_then(_ARG0, _ARG1, _ARG2); }
+void log_Z3_tactic_try_for(Z3_context a0, Z3_tactic a1, unsigned a2);
+#define LOG_Z3_tactic_try_for(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_try_for(_ARG0, _ARG1, _ARG2); }
+void log_Z3_tactic_when(Z3_context a0, Z3_probe a1, Z3_tactic a2);
+#define LOG_Z3_tactic_when(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_when(_ARG0, _ARG1, _ARG2); }
+void log_Z3_tactic_cond(Z3_context a0, Z3_probe a1, Z3_tactic a2, Z3_tactic a3);
+#define LOG_Z3_tactic_cond(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_cond(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_tactic_repeat(Z3_context a0, Z3_tactic a1, unsigned a2);
+#define LOG_Z3_tactic_repeat(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_repeat(_ARG0, _ARG1, _ARG2); }
+void log_Z3_tactic_skip(Z3_context a0);
+#define LOG_Z3_tactic_skip(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_skip(_ARG0); }
+void log_Z3_tactic_fail(Z3_context a0);
+#define LOG_Z3_tactic_fail(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_fail(_ARG0); }
+void log_Z3_tactic_fail_if(Z3_context a0, Z3_probe a1);
+#define LOG_Z3_tactic_fail_if(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_fail_if(_ARG0, _ARG1); }
+void log_Z3_tactic_fail_if_not_decided(Z3_context a0);
+#define LOG_Z3_tactic_fail_if_not_decided(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_fail_if_not_decided(_ARG0); }
+void log_Z3_tactic_using_params(Z3_context a0, Z3_tactic a1, Z3_params a2);
+#define LOG_Z3_tactic_using_params(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_using_params(_ARG0, _ARG1, _ARG2); }
+void log_Z3_probe_const(Z3_context a0, double a1);
+#define LOG_Z3_probe_const(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_const(_ARG0, _ARG1); }
+void log_Z3_probe_lt(Z3_context a0, Z3_probe a1, Z3_probe a2);
+#define LOG_Z3_probe_lt(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_lt(_ARG0, _ARG1, _ARG2); }
+void log_Z3_probe_gt(Z3_context a0, Z3_probe a1, Z3_probe a2);
+#define LOG_Z3_probe_gt(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_gt(_ARG0, _ARG1, _ARG2); }
+void log_Z3_probe_le(Z3_context a0, Z3_probe a1, Z3_probe a2);
+#define LOG_Z3_probe_le(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_le(_ARG0, _ARG1, _ARG2); }
+void log_Z3_probe_ge(Z3_context a0, Z3_probe a1, Z3_probe a2);
+#define LOG_Z3_probe_ge(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_ge(_ARG0, _ARG1, _ARG2); }
+void log_Z3_probe_eq(Z3_context a0, Z3_probe a1, Z3_probe a2);
+#define LOG_Z3_probe_eq(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_eq(_ARG0, _ARG1, _ARG2); }
+void log_Z3_probe_and(Z3_context a0, Z3_probe a1, Z3_probe a2);
+#define LOG_Z3_probe_and(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_and(_ARG0, _ARG1, _ARG2); }
+void log_Z3_probe_or(Z3_context a0, Z3_probe a1, Z3_probe a2);
+#define LOG_Z3_probe_or(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_or(_ARG0, _ARG1, _ARG2); }
+void log_Z3_probe_not(Z3_context a0, Z3_probe a1);
+#define LOG_Z3_probe_not(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_not(_ARG0, _ARG1); }
+void log_Z3_get_num_tactics(Z3_context a0);
+#define LOG_Z3_get_num_tactics(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_num_tactics(_ARG0); }
+void log_Z3_get_tactic_name(Z3_context a0, unsigned a1);
+#define LOG_Z3_get_tactic_name(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_tactic_name(_ARG0, _ARG1); }
+void log_Z3_get_num_probes(Z3_context a0);
+#define LOG_Z3_get_num_probes(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_num_probes(_ARG0); }
+void log_Z3_get_probe_name(Z3_context a0, unsigned a1);
+#define LOG_Z3_get_probe_name(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_probe_name(_ARG0, _ARG1); }
+void log_Z3_tactic_get_help(Z3_context a0, Z3_tactic a1);
+#define LOG_Z3_tactic_get_help(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_get_help(_ARG0, _ARG1); }
+void log_Z3_tactic_get_param_descrs(Z3_context a0, Z3_tactic a1);
+#define LOG_Z3_tactic_get_param_descrs(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_get_param_descrs(_ARG0, _ARG1); }
+void log_Z3_tactic_get_descr(Z3_context a0, Z3_string a1);
+#define LOG_Z3_tactic_get_descr(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_get_descr(_ARG0, _ARG1); }
+void log_Z3_probe_get_descr(Z3_context a0, Z3_string a1);
+#define LOG_Z3_probe_get_descr(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_get_descr(_ARG0, _ARG1); }
+void log_Z3_probe_apply(Z3_context a0, Z3_probe a1, Z3_goal a2);
+#define LOG_Z3_probe_apply(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_probe_apply(_ARG0, _ARG1, _ARG2); }
+void log_Z3_tactic_apply(Z3_context a0, Z3_tactic a1, Z3_goal a2);
+#define LOG_Z3_tactic_apply(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_apply(_ARG0, _ARG1, _ARG2); }
+void log_Z3_tactic_apply_ex(Z3_context a0, Z3_tactic a1, Z3_goal a2, Z3_params a3);
+#define LOG_Z3_tactic_apply_ex(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_tactic_apply_ex(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_apply_result_inc_ref(Z3_context a0, Z3_apply_result a1);
+#define LOG_Z3_apply_result_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_apply_result_inc_ref(_ARG0, _ARG1); }
+void log_Z3_apply_result_dec_ref(Z3_context a0, Z3_apply_result a1);
+#define LOG_Z3_apply_result_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_apply_result_dec_ref(_ARG0, _ARG1); }
+void log_Z3_apply_result_to_string(Z3_context a0, Z3_apply_result a1);
+#define LOG_Z3_apply_result_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_apply_result_to_string(_ARG0, _ARG1); }
+void log_Z3_apply_result_get_num_subgoals(Z3_context a0, Z3_apply_result a1);
+#define LOG_Z3_apply_result_get_num_subgoals(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_apply_result_get_num_subgoals(_ARG0, _ARG1); }
+void log_Z3_apply_result_get_subgoal(Z3_context a0, Z3_apply_result a1, unsigned a2);
+#define LOG_Z3_apply_result_get_subgoal(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_apply_result_get_subgoal(_ARG0, _ARG1, _ARG2); }
+void log_Z3_apply_result_convert_model(Z3_context a0, Z3_apply_result a1, unsigned a2, Z3_model a3);
+#define LOG_Z3_apply_result_convert_model(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_apply_result_convert_model(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_mk_solver(Z3_context a0);
+#define LOG_Z3_mk_solver(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_solver(_ARG0); }
+void log_Z3_mk_simple_solver(Z3_context a0);
+#define LOG_Z3_mk_simple_solver(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_simple_solver(_ARG0); }
+void log_Z3_mk_solver_for_logic(Z3_context a0, Z3_symbol a1);
+#define LOG_Z3_mk_solver_for_logic(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_solver_for_logic(_ARG0, _ARG1); }
+void log_Z3_mk_solver_from_tactic(Z3_context a0, Z3_tactic a1);
+#define LOG_Z3_mk_solver_from_tactic(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_solver_from_tactic(_ARG0, _ARG1); }
+void log_Z3_solver_get_help(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_get_help(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_get_help(_ARG0, _ARG1); }
+void log_Z3_solver_get_param_descrs(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_get_param_descrs(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_get_param_descrs(_ARG0, _ARG1); }
+void log_Z3_solver_set_params(Z3_context a0, Z3_solver a1, Z3_params a2);
+#define LOG_Z3_solver_set_params(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_set_params(_ARG0, _ARG1, _ARG2); }
+void log_Z3_solver_inc_ref(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_inc_ref(_ARG0, _ARG1); }
+void log_Z3_solver_dec_ref(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_dec_ref(_ARG0, _ARG1); }
+void log_Z3_solver_push(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_push(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_push(_ARG0, _ARG1); }
+void log_Z3_solver_pop(Z3_context a0, Z3_solver a1, unsigned a2);
+#define LOG_Z3_solver_pop(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_pop(_ARG0, _ARG1, _ARG2); }
+void log_Z3_solver_reset(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_reset(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_reset(_ARG0, _ARG1); }
+void log_Z3_solver_get_num_scopes(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_get_num_scopes(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_get_num_scopes(_ARG0, _ARG1); }
+void log_Z3_solver_assert(Z3_context a0, Z3_solver a1, Z3_ast a2);
+#define LOG_Z3_solver_assert(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_assert(_ARG0, _ARG1, _ARG2); }
+void log_Z3_solver_get_assertions(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_get_assertions(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_get_assertions(_ARG0, _ARG1); }
+void log_Z3_solver_check(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_check(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_check(_ARG0, _ARG1); }
+void log_Z3_solver_check_assumptions(Z3_context a0, Z3_solver a1, unsigned a2, Z3_ast const * a3);
+#define LOG_Z3_solver_check_assumptions(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_check_assumptions(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_solver_get_model(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_get_model(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_get_model(_ARG0, _ARG1); }
+void log_Z3_solver_get_proof(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_get_proof(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_get_proof(_ARG0, _ARG1); }
+void log_Z3_solver_get_unsat_core(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_get_unsat_core(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_get_unsat_core(_ARG0, _ARG1); }
+void log_Z3_solver_get_reason_unknown(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_get_reason_unknown(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_get_reason_unknown(_ARG0, _ARG1); }
+void log_Z3_solver_get_statistics(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_get_statistics(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_get_statistics(_ARG0, _ARG1); }
+void log_Z3_solver_to_string(Z3_context a0, Z3_solver a1);
+#define LOG_Z3_solver_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_solver_to_string(_ARG0, _ARG1); }
+void log_Z3_stats_to_string(Z3_context a0, Z3_stats a1);
+#define LOG_Z3_stats_to_string(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_stats_to_string(_ARG0, _ARG1); }
+void log_Z3_stats_inc_ref(Z3_context a0, Z3_stats a1);
+#define LOG_Z3_stats_inc_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_stats_inc_ref(_ARG0, _ARG1); }
+void log_Z3_stats_dec_ref(Z3_context a0, Z3_stats a1);
+#define LOG_Z3_stats_dec_ref(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_stats_dec_ref(_ARG0, _ARG1); }
+void log_Z3_stats_size(Z3_context a0, Z3_stats a1);
+#define LOG_Z3_stats_size(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_stats_size(_ARG0, _ARG1); }
+void log_Z3_stats_get_key(Z3_context a0, Z3_stats a1, unsigned a2);
+#define LOG_Z3_stats_get_key(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_stats_get_key(_ARG0, _ARG1, _ARG2); }
+void log_Z3_stats_is_uint(Z3_context a0, Z3_stats a1, unsigned a2);
+#define LOG_Z3_stats_is_uint(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_stats_is_uint(_ARG0, _ARG1, _ARG2); }
+void log_Z3_stats_is_double(Z3_context a0, Z3_stats a1, unsigned a2);
+#define LOG_Z3_stats_is_double(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_stats_is_double(_ARG0, _ARG1, _ARG2); }
+void log_Z3_stats_get_uint_value(Z3_context a0, Z3_stats a1, unsigned a2);
+#define LOG_Z3_stats_get_uint_value(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_stats_get_uint_value(_ARG0, _ARG1, _ARG2); }
+void log_Z3_stats_get_double_value(Z3_context a0, Z3_stats a1, unsigned a2);
+#define LOG_Z3_stats_get_double_value(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_stats_get_double_value(_ARG0, _ARG1, _ARG2); }
+void log_Z3_mk_injective_function(Z3_context a0, Z3_symbol a1, unsigned a2, Z3_sort const * a3, Z3_sort a4);
+#define LOG_Z3_mk_injective_function(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_injective_function(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4); }
+void log_Z3_set_logic(Z3_context a0, Z3_string a1);
+#define LOG_Z3_set_logic(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_set_logic(_ARG0, _ARG1); }
+void log_Z3_push(Z3_context a0);
+#define LOG_Z3_push(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_push(_ARG0); }
+void log_Z3_pop(Z3_context a0, unsigned a1);
+#define LOG_Z3_pop(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_pop(_ARG0, _ARG1); }
+void log_Z3_get_num_scopes(Z3_context a0);
+#define LOG_Z3_get_num_scopes(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_num_scopes(_ARG0); }
+void log_Z3_persist_ast(Z3_context a0, Z3_ast a1, unsigned a2);
+#define LOG_Z3_persist_ast(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_persist_ast(_ARG0, _ARG1, _ARG2); }
+void log_Z3_assert_cnstr(Z3_context a0, Z3_ast a1);
+#define LOG_Z3_assert_cnstr(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_assert_cnstr(_ARG0, _ARG1); }
+void log_Z3_check_and_get_model(Z3_context a0, Z3_model* a1);
+#define LOG_Z3_check_and_get_model(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; Z3_model* Z3ARG1; if (_LOG_CTX.enabled()) { log_Z3_check_and_get_model(_ARG0, _ARG1); Z3ARG1 = _ARG1; }
+#define RETURN_Z3_check_and_get_model if (_LOG_CTX.enabled()) { SetO((Z3ARG1 == 0 ? 0 : *Z3ARG1), 1); } return
+void log_Z3_check(Z3_context a0);
+#define LOG_Z3_check(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_check(_ARG0); }
+void log_Z3_check_assumptions(Z3_context a0, unsigned a1, Z3_ast const * a2, Z3_model* a3, Z3_ast* a4, unsigned* a5, Z3_ast* a6);
+#define LOG_Z3_check_assumptions(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6) z3_log_ctx _LOG_CTX; Z3_model* Z3ARG3; Z3_ast* Z3ARG4; unsigned Z3ARG1; unsigned * Z3ARG5; Z3_ast* Z3ARG6; if (_LOG_CTX.enabled()) { log_Z3_check_assumptions(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6); Z3ARG3 = _ARG3; Z3ARG4 = _ARG4; Z3ARG1 = _ARG1; Z3ARG5 = _ARG5; Z3ARG6 = _ARG6; }
+#define RETURN_Z3_check_assumptions if (_LOG_CTX.enabled()) { SetO((Z3ARG3 == 0 ? 0 : *Z3ARG3), 3); SetO((Z3ARG4 == 0 ? 0 : *Z3ARG4), 4); for (unsigned i = 0; Z3ARG5 && i < *Z3ARG5; i++) { SetAO(Z3ARG6[i], 6, i); } } return
+void log_Z3_get_implied_equalities(Z3_context a0, unsigned a1, Z3_ast const * a2, unsigned* a3);
+#define LOG_Z3_get_implied_equalities(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_implied_equalities(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_del_model(Z3_context a0, Z3_model a1);
+#define LOG_Z3_del_model(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_del_model(_ARG0, _ARG1); }
+void log_Z3_soft_check_cancel(Z3_context a0);
+#define LOG_Z3_soft_check_cancel(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_soft_check_cancel(_ARG0); }
+void log_Z3_get_search_failure(Z3_context a0);
+#define LOG_Z3_get_search_failure(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_search_failure(_ARG0); }
+void log_Z3_mk_label(Z3_context a0, Z3_symbol a1, Z3_bool a2, Z3_ast a3);
+#define LOG_Z3_mk_label(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_label(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_get_relevant_labels(Z3_context a0);
+#define LOG_Z3_get_relevant_labels(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_relevant_labels(_ARG0); }
+void log_Z3_get_relevant_literals(Z3_context a0);
+#define LOG_Z3_get_relevant_literals(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_relevant_literals(_ARG0); }
+void log_Z3_get_guessed_literals(Z3_context a0);
+#define LOG_Z3_get_guessed_literals(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_guessed_literals(_ARG0); }
+void log_Z3_del_literals(Z3_context a0, Z3_literals a1);
+#define LOG_Z3_del_literals(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_del_literals(_ARG0, _ARG1); }
+void log_Z3_get_num_literals(Z3_context a0, Z3_literals a1);
+#define LOG_Z3_get_num_literals(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_num_literals(_ARG0, _ARG1); }
+void log_Z3_get_label_symbol(Z3_context a0, Z3_literals a1, unsigned a2);
+#define LOG_Z3_get_label_symbol(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_label_symbol(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_literal(Z3_context a0, Z3_literals a1, unsigned a2);
+#define LOG_Z3_get_literal(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_literal(_ARG0, _ARG1, _ARG2); }
+void log_Z3_disable_literal(Z3_context a0, Z3_literals a1, unsigned a2);
+#define LOG_Z3_disable_literal(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_disable_literal(_ARG0, _ARG1, _ARG2); }
+void log_Z3_block_literals(Z3_context a0, Z3_literals a1);
+#define LOG_Z3_block_literals(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_block_literals(_ARG0, _ARG1); }
+void log_Z3_get_model_num_constants(Z3_context a0, Z3_model a1);
+#define LOG_Z3_get_model_num_constants(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_model_num_constants(_ARG0, _ARG1); }
+void log_Z3_get_model_constant(Z3_context a0, Z3_model a1, unsigned a2);
+#define LOG_Z3_get_model_constant(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_model_constant(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_model_num_funcs(Z3_context a0, Z3_model a1);
+#define LOG_Z3_get_model_num_funcs(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_model_num_funcs(_ARG0, _ARG1); }
+void log_Z3_get_model_func_decl(Z3_context a0, Z3_model a1, unsigned a2);
+#define LOG_Z3_get_model_func_decl(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_model_func_decl(_ARG0, _ARG1, _ARG2); }
+void log_Z3_eval_func_decl(Z3_context a0, Z3_model a1, Z3_func_decl a2, Z3_ast* a3);
+#define LOG_Z3_eval_func_decl(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; Z3_ast* Z3ARG3; if (_LOG_CTX.enabled()) { log_Z3_eval_func_decl(_ARG0, _ARG1, _ARG2, _ARG3); Z3ARG3 = _ARG3; }
+#define RETURN_Z3_eval_func_decl if (_LOG_CTX.enabled()) { SetO((Z3ARG3 == 0 ? 0 : *Z3ARG3), 3); } return
+void log_Z3_is_array_value(Z3_context a0, Z3_model a1, Z3_ast a2, unsigned* a3);
+#define LOG_Z3_is_array_value(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_is_array_value(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_get_array_value(Z3_context a0, Z3_model a1, Z3_ast a2, unsigned a3, Z3_ast* a4, Z3_ast* a5, Z3_ast* a6);
+#define LOG_Z3_get_array_value(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6) z3_log_ctx _LOG_CTX; unsigned Z3ARG3; Z3_ast* Z3ARG4; Z3_ast* Z3ARG5; Z3_ast* Z3ARG6; if (_LOG_CTX.enabled()) { log_Z3_get_array_value(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5, _ARG6); Z3ARG3 = _ARG3; Z3ARG4 = _ARG4; Z3ARG5 = _ARG5; Z3ARG6 = _ARG6; }
+#define RETURN_Z3_get_array_value if (_LOG_CTX.enabled()) { for (unsigned i = 0; i < Z3ARG3; i++) { SetAO(Z3ARG4[i], 4, i); } for (unsigned i = 0; i < Z3ARG3; i++) { SetAO(Z3ARG5[i], 5, i); } SetO((Z3ARG6 == 0 ? 0 : *Z3ARG6), 6); } return
+void log_Z3_get_model_func_else(Z3_context a0, Z3_model a1, unsigned a2);
+#define LOG_Z3_get_model_func_else(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_model_func_else(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_model_func_num_entries(Z3_context a0, Z3_model a1, unsigned a2);
+#define LOG_Z3_get_model_func_num_entries(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_model_func_num_entries(_ARG0, _ARG1, _ARG2); }
+void log_Z3_get_model_func_entry_num_args(Z3_context a0, Z3_model a1, unsigned a2, unsigned a3);
+#define LOG_Z3_get_model_func_entry_num_args(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_model_func_entry_num_args(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_get_model_func_entry_arg(Z3_context a0, Z3_model a1, unsigned a2, unsigned a3, unsigned a4);
+#define LOG_Z3_get_model_func_entry_arg(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_model_func_entry_arg(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4); }
+void log_Z3_get_model_func_entry_value(Z3_context a0, Z3_model a1, unsigned a2, unsigned a3);
+#define LOG_Z3_get_model_func_entry_value(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_model_func_entry_value(_ARG0, _ARG1, _ARG2, _ARG3); }
+void log_Z3_eval(Z3_context a0, Z3_model a1, Z3_ast a2, Z3_ast* a3);
+#define LOG_Z3_eval(_ARG0, _ARG1, _ARG2, _ARG3) z3_log_ctx _LOG_CTX; Z3_ast* Z3ARG3; if (_LOG_CTX.enabled()) { log_Z3_eval(_ARG0, _ARG1, _ARG2, _ARG3); Z3ARG3 = _ARG3; }
+#define RETURN_Z3_eval if (_LOG_CTX.enabled()) { SetO((Z3ARG3 == 0 ? 0 : *Z3ARG3), 3); } return
+void log_Z3_eval_decl(Z3_context a0, Z3_model a1, Z3_func_decl a2, unsigned a3, Z3_ast const * a4, Z3_ast* a5);
+#define LOG_Z3_eval_decl(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5) z3_log_ctx _LOG_CTX; Z3_ast* Z3ARG5; if (_LOG_CTX.enabled()) { log_Z3_eval_decl(_ARG0, _ARG1, _ARG2, _ARG3, _ARG4, _ARG5); Z3ARG5 = _ARG5; }
+#define RETURN_Z3_eval_decl if (_LOG_CTX.enabled()) { SetO((Z3ARG5 == 0 ? 0 : *Z3ARG5), 5); } return
+void log_Z3_context_to_string(Z3_context a0);
+#define LOG_Z3_context_to_string(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_context_to_string(_ARG0); }
+void log_Z3_statistics_to_string(Z3_context a0);
+#define LOG_Z3_statistics_to_string(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_statistics_to_string(_ARG0); }
+void log_Z3_get_context_assignment(Z3_context a0);
+#define LOG_Z3_get_context_assignment(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_get_context_assignment(_ARG0); }
+void log_Z3_mk_polynomial_manager(Z3_context a0);
+#define LOG_Z3_mk_polynomial_manager(_ARG0) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_polynomial_manager(_ARG0); }
+void log_Z3_del_polynomial_manager(Z3_context a0, Z3_polynomial_manager a1);
+#define LOG_Z3_del_polynomial_manager(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_del_polynomial_manager(_ARG0, _ARG1); }
+void log_Z3_mk_zero_polynomial(Z3_context a0, Z3_polynomial_manager a1);
+#define LOG_Z3_mk_zero_polynomial(_ARG0, _ARG1) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_mk_zero_polynomial(_ARG0, _ARG1); }
+void log_Z3_polynomial_inc_ref(Z3_context a0, Z3_polynomial_manager a1, Z3_polynomial a2);
+#define LOG_Z3_polynomial_inc_ref(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_polynomial_inc_ref(_ARG0, _ARG1, _ARG2); }
+void log_Z3_polynomial_dec_ref(Z3_context a0, Z3_polynomial_manager a1, Z3_polynomial a2);
+#define LOG_Z3_polynomial_dec_ref(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_polynomial_dec_ref(_ARG0, _ARG1, _ARG2); }
+void log_Z3_polynomial_to_string(Z3_context a0, Z3_polynomial_manager a1, Z3_polynomial a2);
+#define LOG_Z3_polynomial_to_string(_ARG0, _ARG1, _ARG2) z3_log_ctx _LOG_CTX; if (_LOG_CTX.enabled()) { log_Z3_polynomial_to_string(_ARG0, _ARG1, _ARG2); }

src/api/api_model.cpp

@@ -0,0 +1,670 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_quant.cpp
+
+Abstract:
+    API for models
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_model.h"
+#include"api_ast_vector.h"
+#include"array_decl_plugin.h"
+#include"model.h"
+#include"model_v2_pp.h"
+#include"model_smt2_pp.h"
+
+extern "C" {
+
+    void Z3_API Z3_model_inc_ref(Z3_context c, Z3_model m) {
+        Z3_TRY;
+        LOG_Z3_model_inc_ref(c, m);
+        RESET_ERROR_CODE();
+        if (m) {
+            to_model(m)->inc_ref();
+        }
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_model_dec_ref(Z3_context c, Z3_model m) {
+        Z3_TRY;
+        LOG_Z3_model_dec_ref(c, m);
+        RESET_ERROR_CODE();
+        if (m) {
+            to_model(m)->dec_ref();
+        }
+        Z3_CATCH;
+    }
+
+    Z3_ast Z3_API Z3_model_get_const_interp(Z3_context c, Z3_model m, Z3_func_decl a) {
+        Z3_TRY;
+        LOG_Z3_model_get_const_interp(c, m, a);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        expr * r = to_model_ref(m)->get_const_interp(to_func_decl(a));
+        if (!r) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        RETURN_Z3(of_expr(r));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_func_interp Z3_API Z3_model_get_func_interp(Z3_context c, Z3_model m, Z3_func_decl f) {
+        Z3_TRY;
+        LOG_Z3_model_get_func_interp(c, m, f);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        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);
+        }
+        Z3_func_interp_ref * fi = alloc(Z3_func_interp_ref, 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);
+    }
+
+    unsigned Z3_API Z3_model_get_num_consts(Z3_context c, Z3_model m) {
+        Z3_TRY;
+        LOG_Z3_model_get_num_consts(c, m);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        return to_model_ref(m)->get_num_constants();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_func_decl Z3_API Z3_model_get_const_decl(Z3_context c, Z3_model m, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_model_get_const_decl(c, m, i);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        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);
+        }
+        Z3_CATCH_RETURN(0);
+    }
+    
+    unsigned Z3_API Z3_model_get_num_funcs(Z3_context c, Z3_model m) {
+        Z3_TRY;
+        LOG_Z3_model_get_num_funcs(c, m);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        return to_model_ref(m)->get_num_functions();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_func_decl get_model_func_decl_core(Z3_context c, Z3_model m, unsigned i) {
+        CHECK_NON_NULL(m, 0);
+        model * _m = to_model_ref(m);
+        if (i >= _m->get_num_functions()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return 0;
+        }
+        return of_func_decl(_m->get_function(i));
+    }
+    
+    Z3_func_decl Z3_API Z3_model_get_func_decl(Z3_context c, Z3_model m, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_get_model_func_decl(c, m, i);
+        RESET_ERROR_CODE();
+        Z3_func_decl r = get_model_func_decl_core(c, m, i);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    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;
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, Z3_FALSE);
+        model * _m = to_model_ref(m);
+        expr_ref result(mk_c(c)->m());
+        _m->eval(to_expr(t), result, model_completion == Z3_TRUE);
+        mk_c(c)->save_ast_trail(result.get());
+        *v = of_ast(result.get());
+        RETURN_Z3_model_eval Z3_TRUE;
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_API Z3_model_get_num_sorts(Z3_context c, Z3_model m) {
+        Z3_TRY;
+        LOG_Z3_model_get_num_sorts(c, m);
+        RESET_ERROR_CODE();
+        return to_model_ref(m)->get_num_uninterpreted_sorts();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_sort Z3_API Z3_model_get_sort(Z3_context c, Z3_model m, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_model_get_sort(c, m, i);
+        RESET_ERROR_CODE();
+        if (i >= to_model_ref(m)->get_num_uninterpreted_sorts()) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        sort * s = to_model_ref(m)->get_uninterpreted_sort(i);
+        RETURN_Z3(of_sort(s));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast_vector Z3_API Z3_model_get_sort_universe(Z3_context c, Z3_model m, Z3_sort s) {
+        Z3_TRY;
+        LOG_Z3_model_get_sort_universe(c, m, s);
+        RESET_ERROR_CODE();
+        if (!to_model_ref(m)->has_uninterpreted_sort(to_sort(s))) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        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)->m());
+        mk_c(c)->save_object(v);
+        unsigned sz = universe.size();
+        for (unsigned i = 0; i < sz; i++) {
+            v->m_ast_vector.push_back(universe[i]);
+        }
+        RETURN_Z3(of_ast_vector(v));
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_is_as_array(c, a);
+        RESET_ERROR_CODE();
+        return is_expr(to_ast(a)) && is_app_of(to_expr(a), mk_c(c)->get_array_fid(), OP_AS_ARRAY);
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+    
+    Z3_func_decl Z3_API Z3_get_as_array_func_decl(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_get_as_array_func_decl(c, a);
+        RESET_ERROR_CODE();
+        if (is_expr(to_ast(a)) && is_app_of(to_expr(a), mk_c(c)->get_array_fid(), OP_AS_ARRAY)) {
+            return of_func_decl(to_func_decl(to_app(a)->get_decl()->get_parameter(0).get_ast()));
+        }
+        else {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_func_interp_inc_ref(Z3_context c, Z3_func_interp f) {
+        Z3_TRY;
+        LOG_Z3_func_interp_inc_ref(c, f);
+        RESET_ERROR_CODE();
+        if (f) {
+            to_func_interp(f)->inc_ref();
+        }
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_func_interp_dec_ref(Z3_context c, Z3_func_interp f) {
+        Z3_TRY;
+        LOG_Z3_func_interp_dec_ref(c, f);
+        RESET_ERROR_CODE();
+        if (f) {
+            to_func_interp(f)->dec_ref();
+        }
+        Z3_CATCH;
+    }
+    
+    unsigned Z3_API Z3_func_interp_get_num_entries(Z3_context c, Z3_func_interp f) {
+        Z3_TRY;
+        LOG_Z3_func_interp_get_num_entries(c, f);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(f, 0);
+        return to_func_interp_ref(f)->num_entries();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_func_entry Z3_API Z3_func_interp_get_entry(Z3_context c, Z3_func_interp f, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_func_interp_get_entry(c, f, i);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(f, 0);
+        if (i >= to_func_interp_ref(f)->num_entries()) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        Z3_func_entry_ref * e = alloc(Z3_func_entry_ref, 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_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);
+        expr * e = to_func_interp_ref(f)->get_else();
+        RETURN_Z3(of_expr(e));
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_API Z3_func_interp_get_arity(Z3_context c, Z3_func_interp f) {
+        Z3_TRY;
+        LOG_Z3_func_interp_get_arity(c, f);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(f, 0);
+        return to_func_interp_ref(f)->get_arity();
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_func_entry_inc_ref(Z3_context c, Z3_func_entry e) {
+        Z3_TRY;
+        LOG_Z3_func_entry_inc_ref(c, e);
+        RESET_ERROR_CODE();
+        if (e) {
+            to_func_entry(e)->inc_ref();
+        }
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_func_entry_dec_ref(Z3_context c, Z3_func_entry e) {
+        Z3_TRY;
+        LOG_Z3_func_entry_dec_ref(c, e);
+        RESET_ERROR_CODE();
+        if (e) {
+            to_func_entry(e)->dec_ref();
+        }
+        Z3_CATCH;
+    }
+    
+    Z3_ast Z3_API Z3_func_entry_get_value(Z3_context c, Z3_func_entry e) {
+        Z3_TRY;
+        LOG_Z3_func_entry_get_value(c, e);
+        RESET_ERROR_CODE();
+        expr * v = to_func_entry_ref(e)->get_result();
+        RETURN_Z3(of_expr(v));
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_API Z3_func_entry_get_num_args(Z3_context c, Z3_func_entry e) {
+        Z3_TRY;
+        LOG_Z3_func_entry_get_num_args(c, e);
+        RESET_ERROR_CODE();
+        return to_func_entry(e)->m_func_interp->get_arity();
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_ast Z3_API Z3_func_entry_get_arg(Z3_context c, Z3_func_entry e, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_func_entry_get_arg(c, e, i);
+        RESET_ERROR_CODE();
+        if (i >= to_func_entry(e)->m_func_interp->get_arity()) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        expr * r = to_func_entry(e)->m_func_entry->get_arg(i);
+        RETURN_Z3(of_expr(r));
+        Z3_CATCH_RETURN(0);
+    }
+   
+    // ----------------------------
+    //
+    // DEPRECATED API
+    //
+    // ----------------------------
+
+    void Z3_API Z3_del_model(Z3_context c, Z3_model  m) {
+        Z3_model_dec_ref(c, m);
+    }
+
+    unsigned Z3_API Z3_get_model_num_constants(Z3_context c, Z3_model m) {
+        return Z3_model_get_num_consts(c, m);
+    }
+
+    Z3_func_decl Z3_API Z3_get_model_constant(Z3_context c, Z3_model m, unsigned i) {
+        return Z3_model_get_const_decl(c, m, i);
+    }
+
+    unsigned Z3_API Z3_get_model_num_funcs(Z3_context c, Z3_model m) {
+        return Z3_model_get_num_funcs(c, m);
+    }
+
+    Z3_func_decl Z3_API Z3_get_model_func_decl(Z3_context c, Z3_model m, unsigned i) {
+        return Z3_model_get_func_decl(c, m, i);
+    }
+    
+    Z3_ast Z3_API Z3_get_model_func_else(Z3_context c, Z3_model m, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_get_model_func_else(c, m, i);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        Z3_func_decl d = get_model_func_decl_core(c, m, i);
+        if (d) {
+            model * _m = to_model_ref(m);            
+            func_interp * g = _m->get_func_interp(to_func_decl(d));
+            if (g) {
+                expr * e = g->get_else();
+                mk_c(c)->save_ast_trail(e);
+                RETURN_Z3(of_ast(e));
+            }
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        RETURN_Z3(0);
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned get_model_func_num_entries_core(Z3_context c, Z3_model m, unsigned i) {
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        Z3_func_decl d = get_model_func_decl_core(c, m, i);
+        if (d) {
+            model * _m = to_model_ref(m);            
+            func_interp * g = _m->get_func_interp(to_func_decl(d));
+            if (g) {
+                return g->num_entries();
+            }
+            SET_ERROR_CODE(Z3_IOB);
+            return 0;
+        }
+        return 0;
+    }
+    
+    unsigned Z3_API Z3_get_model_func_num_entries(Z3_context c, Z3_model m, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_get_model_func_num_entries(c, m, i);
+        return get_model_func_num_entries_core(c, m, i);
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned get_model_func_entry_num_args_core(Z3_context c,
+                                                Z3_model m,
+                                                unsigned i,
+                                                unsigned j) {
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        if (j >= get_model_func_num_entries_core(c, m, i)) {
+            SET_ERROR_CODE(Z3_IOB);
+            return 0;
+        }
+        Z3_func_decl d = get_model_func_decl_core(c, m, i);
+        if (d) {
+            model * _m = to_model_ref(m);
+            func_interp * g = _m->get_func_interp(to_func_decl(d));
+            return g->get_arity();
+        }
+        return 0;
+    }
+    
+    unsigned Z3_API Z3_get_model_func_entry_num_args(Z3_context c,
+                                                     Z3_model m,
+                                                     unsigned i,
+                                                     unsigned j) {
+        Z3_TRY;
+        LOG_Z3_get_model_func_entry_num_args(c, m, i, j);
+        return get_model_func_entry_num_args_core(c, m, i, j);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_get_model_func_entry_arg(Z3_context c,
+                                                Z3_model m,
+                                                unsigned i,
+                                                unsigned j,
+                                                unsigned k) {
+        Z3_TRY;
+        LOG_Z3_get_model_func_entry_arg(c, m, i, j, k);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        if (j >= get_model_func_num_entries_core(c, m, i) || k >= get_model_func_entry_num_args_core(c, m, i, j)) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        Z3_func_decl d = get_model_func_decl_core(c, m, i);
+        if (d) {
+            model * _m = to_model_ref(m);            
+            func_interp * g = _m->get_func_interp(to_func_decl(d));
+            if (g && j < g->num_entries()) {
+                func_entry const * e = g->get_entry(j);
+                if (k < g->get_arity()) {
+                    expr * a = e->get_arg(k);
+                    mk_c(c)->save_ast_trail(a);
+                    RETURN_Z3(of_ast(a));
+                }
+            }
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        RETURN_Z3(0);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_get_model_func_entry_value(Z3_context c,
+                                                Z3_model m,
+                                                unsigned i,
+                                                unsigned j) {
+        Z3_TRY;
+        LOG_Z3_get_model_func_entry_value(c, m, i, j);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        if (j >= get_model_func_num_entries_core(c, m, i)) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        Z3_func_decl d = get_model_func_decl_core(c, m, i);
+        if (d) {
+            model * _m = to_model_ref(m);            
+            func_interp * g = _m->get_func_interp(to_func_decl(d));
+            if (g && j < g->num_entries()) {
+                func_entry const* e = g->get_entry(j);
+                expr* a = e->get_result();
+                mk_c(c)->save_ast_trail(a);
+                RETURN_Z3(of_ast(a));
+            }
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        RETURN_Z3(0);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_bool Z3_API Z3_eval(Z3_context c,
+                           Z3_model m,
+                           Z3_ast t,
+                           Z3_ast * v) {
+        return Z3_model_eval(c, m, t, mk_c(c)->fparams().m_model_completion, v);
+    }
+
+    Z3_bool Z3_API Z3_eval_func_decl(Z3_context c, 
+                                     Z3_model m, 
+                                     Z3_func_decl decl,
+                                     Z3_ast* v) {
+        Z3_TRY;
+        LOG_Z3_eval_func_decl(c, m, decl, v);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, Z3_FALSE);
+        ast_manager & mgr = mk_c(c)->m();
+        model * _m = to_model_ref(m);
+        expr_ref result(mgr);
+        if( _m->eval(to_func_decl(decl), result)) {
+            mk_c(c)->save_ast_trail(result.get());
+            *v = of_ast(result.get());
+            RETURN_Z3_eval_func_decl Z3_TRUE;
+        }
+        else {
+            return Z3_FALSE;
+        }      
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+
+    Z3_bool Z3_API Z3_is_array_value(Z3_context c, Z3_model _m, Z3_ast _v, unsigned* size) {
+        Z3_TRY;
+        LOG_Z3_is_array_value(c, _m, _v, size);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(_v, Z3_FALSE);
+        CHECK_NON_NULL(_m, Z3_FALSE);
+        model * m = to_model_ref(_m);
+        expr * v = to_expr(_v);
+        ast_manager& mgr = mk_c(c)->m();
+        family_id afid = mk_c(c)->get_array_fid();
+        unsigned sz = 0;
+        array_util pl(mgr);
+        if (pl.is_as_array(v)) {
+            func_decl* f = pl.get_as_array_func_decl(to_app(v));
+            func_interp* g = m->get_func_interp(f);
+            sz = g->num_entries();
+            if (sz > 0 && g->get_arity() != 1) {
+                return Z3_FALSE;
+            }
+        }
+        else {
+            while (pl.is_store(v)) {
+                if (to_app(v)->get_num_args() != 3) {
+                    return Z3_FALSE;
+                }
+                v = to_app(v)->get_arg(0);
+                ++sz;
+            }
+            if (!is_app_of(v, afid, OP_CONST_ARRAY)) {
+                return Z3_FALSE;
+            }
+        }
+        if (size) {
+            *size = sz;
+        }
+        return Z3_TRUE;
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+
+    void Z3_API Z3_get_array_value(Z3_context c, 
+                                   Z3_model _m,
+                                   Z3_ast _v,
+                                   unsigned num_entries,
+                                   Z3_ast indices[],
+                                   Z3_ast values[],
+                                   Z3_ast* else_value) {
+        Z3_TRY;
+        LOG_Z3_get_array_value(c, _m, _v, num_entries, indices, values, else_value);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(_m, );
+        model * m = to_model_ref(_m);
+
+        expr* v = to_expr(_v);
+        family_id afid = mk_c(c)->get_array_fid();
+        ast_manager& mgr = mk_c(c)->m();
+        array_util pl(mgr);
+
+        //
+        // note: _v is already reference counted.
+        // saving the trail for the returned values 
+        // is redundant.
+        //
+        unsigned sz = 0;
+        if (pl.is_as_array(v)) {
+            func_decl* f = pl.get_as_array_func_decl(to_app(v));
+            func_interp* g = m->get_func_interp(f);
+            sz = g->num_entries();
+            if (g->get_arity() != 1) {
+                SET_ERROR_CODE(Z3_INVALID_ARG);
+                return;
+            }
+            for (unsigned i = 0; i < sz && i < num_entries; ++i) {
+                indices[i] = of_ast(g->get_entry(i)->get_arg(0));
+                values[i] = of_ast(g->get_entry(i)->get_result());                
+            }
+            if (else_value) {
+                *else_value = of_ast(g->get_else());
+            }                       
+        }
+        else {
+            while (sz <= num_entries && is_app_of(v, afid, OP_STORE)) {
+                app* a = to_app(v);
+                if (a->get_num_args() != 3) {
+                    SET_ERROR_CODE(Z3_INVALID_ARG);
+                    return;
+                }
+                expr* idx = a->get_arg(1);
+                expr* val = a->get_arg(2);
+                indices[sz] = of_ast(idx);
+                values[sz] = of_ast(val);
+                v = to_app(v)->get_arg(0);   
+                ++sz;
+            }
+        
+            if (is_app_of(v, afid, OP_CONST_ARRAY)) {
+                if (else_value) {
+                    *else_value = of_ast(to_app(v)->get_arg(0));
+                }
+            }
+            else {
+                SET_ERROR_CODE(Z3_INVALID_ARG);
+                return;
+            }
+        }
+        RETURN_Z3_get_array_value;
+        Z3_CATCH;
+    }
+
+    Z3_bool Z3_API Z3_eval_decl(Z3_context c, 
+                                Z3_model m, 
+                                Z3_func_decl d, 
+                                unsigned num_args,
+                                Z3_ast const args[],
+                                Z3_ast* v) {
+        Z3_TRY;
+        LOG_Z3_eval_decl(c, m, d, num_args, args, v);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, Z3_FALSE);
+        ast_manager & mgr = mk_c(c)->m();
+        model * _m = to_model_ref(m);
+        app_ref app(mgr);
+        app = mgr.mk_app(to_func_decl(d), num_args, to_exprs(args));
+        expr_ref result(mgr);
+        _m->eval(app.get(), result);
+        mk_c(c)->save_ast_trail(result.get());
+        *v = of_ast(result.get());
+        RETURN_Z3_eval_decl Z3_TRUE;
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    char const * Z3_API Z3_model_to_string(Z3_context c, Z3_model m) {
+        Z3_TRY;
+        LOG_Z3_model_to_string(c, m);
+        RESET_ERROR_CODE();
+        CHECK_NON_NULL(m, 0);
+        std::ostringstream buffer;
+        std::string result;
+        if (mk_c(c)->get_print_mode() == Z3_PRINT_SMTLIB2_COMPLIANT) {
+            model_smt2_pp(buffer, mk_c(c)->m(), *(to_model_ref(m)), 0);
+            // Hack for removing the trailing '\n'
+            result = buffer.str();
+            if (result.size() != 0)
+                result.resize(result.size()-1);
+        }
+        else {
+            model_v2_pp(buffer, *(to_model_ref(m)), mk_c(c)->fparams().m_model_partial);
+            result = buffer.str();
+        }
+        return mk_c(c)->mk_external_string(result);
+        Z3_CATCH_RETURN(0);
+    }
+
+};

src/api/api_model.h

@@ -0,0 +1,58 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_model.h
+
+Abstract:
+    API for models
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-08.
+
+Revision History:
+
+--*/
+#ifndef _API_MODEL_H_
+#define _API_MODEL_H_
+
+#include"api_util.h"
+#include"model.h"
+
+struct Z3_model_ref : public api::object {
+    model_ref  m_model;
+    Z3_model_ref() {}
+    virtual ~Z3_model_ref() {}
+};
+
+inline Z3_model_ref * to_model(Z3_model s) { return reinterpret_cast<Z3_model_ref *>(s); }
+inline Z3_model of_model(Z3_model_ref * s) { return reinterpret_cast<Z3_model>(s); }
+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(model * m):m_model(m), m_func_interp(0) {}
+    virtual ~Z3_func_interp_ref() {}
+};
+
+inline Z3_func_interp_ref * to_func_interp(Z3_func_interp s) { return reinterpret_cast<Z3_func_interp_ref *>(s); }
+inline Z3_func_interp of_func_interp(Z3_func_interp_ref * s) { return reinterpret_cast<Z3_func_interp>(s); }
+inline func_interp * to_func_interp_ref(Z3_func_interp s) { return to_func_interp(s)->m_func_interp; }
+
+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(model * m):m_model(m), m_func_interp(0), m_func_entry(0) {}
+    virtual ~Z3_func_entry_ref() {}
+};
+
+inline Z3_func_entry_ref * to_func_entry(Z3_func_entry s) { return reinterpret_cast<Z3_func_entry_ref *>(s); }
+inline Z3_func_entry of_func_entry(Z3_func_entry_ref * s) { return reinterpret_cast<Z3_func_entry>(s); }
+inline func_entry const * to_func_entry_ref(Z3_func_entry s) { return to_func_entry(s)->m_func_entry; }
+
+
+#endif

src/api/api_numeral.cpp

@@ -0,0 +1,340 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_numeral.cpp
+
+Abstract:
+    API for handling numerals in Z3
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"arith_decl_plugin.h"
+#include"bv_decl_plugin.h"
+#include"algebraic_numbers.h"
+
+extern "C" {
+
+    bool is_numeral_sort(Z3_context c, Z3_sort ty) {
+        sort * _ty = to_sort(ty);
+        family_id fid  = _ty->get_family_id();
+        if (fid != mk_c(c)->get_arith_fid() && 
+            fid != mk_c(c)->get_bv_fid() &&
+            fid != mk_c(c)->get_datalog_fid()) {
+            return false;
+        }
+        return true;
+    }
+
+    bool check_numeral_sort(Z3_context c, Z3_sort ty) {
+        bool is_num = is_numeral_sort(c, ty);
+        if (!is_num) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+        }
+        return is_num;
+    }
+
+    Z3_ast Z3_API Z3_mk_numeral(Z3_context c, const char* n, Z3_sort ty) {
+        Z3_TRY;
+        LOG_Z3_mk_numeral(c, n, ty);
+        RESET_ERROR_CODE();          
+        if (!check_numeral_sort(c, ty)) {
+            RETURN_Z3(0);
+        }
+        if (!n) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        std::string fixed_num;
+        char const* m = n;
+        while (*m) {
+            if (!(('0' <= *m && *m <= '9') ||
+                  ('/' == *m) || ('-' == *m) ||
+                  (' ' == *m) || ('\n' == *m) ||
+                  ('.' == *m) || ('e' == *m) ||
+                  ('E' == *m))) {
+                SET_ERROR_CODE(Z3_PARSER_ERROR);
+                return 0;
+            }
+            ++m;
+        }
+        ast * a = mk_c(c)->mk_numeral_core(rational(n), to_sort(ty));
+        RETURN_Z3(of_ast(a));
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_ast Z3_API Z3_mk_int(Z3_context c, int value, Z3_sort ty) {
+        Z3_TRY;
+        LOG_Z3_mk_int(c, value, ty);
+        RESET_ERROR_CODE();  
+        if (!check_numeral_sort(c, ty)) {
+            RETURN_Z3(0);
+        }
+        ast * a = mk_c(c)->mk_numeral_core(rational(value), to_sort(ty));
+        RETURN_Z3(of_ast(a)); 
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_ast Z3_API Z3_mk_unsigned_int(Z3_context c, unsigned value, Z3_sort ty) {
+        Z3_TRY;
+        LOG_Z3_mk_unsigned_int(c, value, ty);
+        RESET_ERROR_CODE();   
+        if (!check_numeral_sort(c, ty)) {
+            RETURN_Z3(0);
+        }
+        ast * a = mk_c(c)->mk_numeral_core(rational(value), to_sort(ty));
+        RETURN_Z3(of_ast(a));
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_ast Z3_API Z3_mk_int64(Z3_context c, long long value, Z3_sort ty) {
+        Z3_TRY;
+        LOG_Z3_mk_int64(c, value, ty);
+        RESET_ERROR_CODE();  
+        if (!check_numeral_sort(c, ty)) {
+            RETURN_Z3(0);
+        }
+        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_ast Z3_API Z3_mk_unsigned_int64(Z3_context c, unsigned long long value, Z3_sort ty) {
+        Z3_TRY;
+        LOG_Z3_mk_unsigned_int64(c, value, ty);
+        RESET_ERROR_CODE(); 
+        if (!check_numeral_sort(c, ty)) {
+            RETURN_Z3(0);
+        }
+        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_bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_is_numeral_ast(c, a);
+        RESET_ERROR_CODE();
+        expr* e = to_expr(a);
+        return 
+            mk_c(c)->autil().is_numeral(e) ||
+            mk_c(c)->bvutil().is_numeral(e);
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    Z3_bool Z3_API Z3_get_numeral_rational(Z3_context c, Z3_ast a, rational& r) {
+        Z3_TRY;
+        // This function is not part of the public API
+        RESET_ERROR_CODE();
+        expr* e = to_expr(a);
+        if (!e) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return Z3_FALSE;            
+        }
+        if (mk_c(c)->autil().is_numeral(e, r)) {
+            return Z3_TRUE;
+        }
+        unsigned bv_size;
+        if (mk_c(c)->bvutil().is_numeral(e, r, bv_size)) {
+            return Z3_TRUE;
+        }
+        uint64 v;
+        if (mk_c(c)->datalog_util().is_numeral(e, v)) {
+            r = rational(v, rational::ui64());
+            return Z3_TRUE;
+        }
+        return Z3_FALSE;            
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    
+    Z3_string Z3_API Z3_get_numeral_string(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object.
+        LOG_Z3_get_numeral_string(c, a);
+        RESET_ERROR_CODE();
+        rational r;
+        Z3_bool ok = Z3_get_numeral_rational(c, a, r);
+        if (ok == Z3_TRUE) {
+            return mk_c(c)->mk_external_string(r.to_string());
+        }
+        else {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return "";
+        }
+        Z3_CATCH_RETURN("");
+    }
+
+    Z3_string Z3_API Z3_get_numeral_decimal_string(Z3_context c, Z3_ast a, unsigned precision) {
+        Z3_TRY;
+        LOG_Z3_get_numeral_decimal_string(c, a, precision);
+        RESET_ERROR_CODE();
+        expr* e = to_expr(a);
+        if (!e) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return "";
+        }
+        rational r;
+        arith_util & u = mk_c(c)->autil();
+        if (u.is_numeral(e, r) && !r.is_int()) {
+            std::ostringstream buffer;
+            r.display_decimal(buffer, precision);
+            return mk_c(c)->mk_external_string(buffer.str());
+        }
+        if (u.is_irrational_algebraic_numeral(e)) {
+            algebraic_numbers::anum const & n = u.to_irrational_algebraic_numeral(e);
+            algebraic_numbers::manager & am   = u.am();
+            std::ostringstream buffer;
+            am.display_decimal(buffer, n, precision);
+            return mk_c(c)->mk_external_string(buffer.str());
+        }
+        Z3_bool ok = Z3_get_numeral_rational(c, a, r);
+        if (ok == Z3_TRUE) {
+            return mk_c(c)->mk_external_string(r.to_string());
+        }
+        else {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return "";
+        }
+        Z3_CATCH_RETURN("");
+    }
+
+    Z3_bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, long long* num, long long* den) {
+        Z3_TRY;
+        // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. 
+        LOG_Z3_get_numeral_small(c, a, num, den);
+        RESET_ERROR_CODE();
+        rational r;
+        Z3_bool ok = Z3_get_numeral_rational(c, a, r);
+        if (ok == Z3_TRUE) {
+            rational n = numerator(r);
+            rational d = denominator(r);
+            if (n.is_int64() && d.is_int64()) {
+                *num = n.get_int64();
+                *den = d.get_int64();
+                return Z3_TRUE;
+            }
+            else {
+                return Z3_FALSE;
+            }
+        }
+        SET_ERROR_CODE(Z3_INVALID_ARG);
+        return Z3_FALSE;
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+
+    Z3_bool Z3_API Z3_get_numeral_int(Z3_context c, Z3_ast v, int* i) {
+        Z3_TRY;
+        // This function invokes Z3_get_numeral_int64, but it is still ok to add LOG command here because it does not return a Z3 object.
+        LOG_Z3_get_numeral_int(c, v, i);
+        RESET_ERROR_CODE();
+        if (!i) { 
+            SET_ERROR_CODE(Z3_INVALID_ARG);          
+            return Z3_FALSE;
+        }
+        long long l;
+        if (Z3_get_numeral_int64(c, v, &l) && l >= INT_MIN && l <= INT_MAX) {
+            *i = static_cast<int>(l);
+            return Z3_TRUE;
+        }
+        return Z3_FALSE;
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+    
+    Z3_bool Z3_API Z3_get_numeral_uint(Z3_context c, Z3_ast v, unsigned* u) {
+        Z3_TRY;
+        // This function invokes Z3_get_numeral_uint64, but it is still ok to add LOG command here because it does not return a Z3 object.
+        LOG_Z3_get_numeral_uint(c, v, u);
+        RESET_ERROR_CODE();
+        if (!u) { 
+            SET_ERROR_CODE(Z3_INVALID_ARG);          
+            return Z3_FALSE;
+        }
+        unsigned long long l;        
+        if (Z3_get_numeral_uint64(c, v, &l) && (l <= 0xFFFFFFFF)) {
+            *u = static_cast<unsigned>(l);
+            return Z3_TRUE;
+        }
+        return Z3_FALSE;
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+    
+    Z3_bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, unsigned long long* u) {
+        Z3_TRY;
+        // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object.
+        LOG_Z3_get_numeral_uint64(c, v, u);
+        RESET_ERROR_CODE();
+        if (!u) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return Z3_FALSE;
+        }
+        rational r;
+        Z3_bool ok = Z3_get_numeral_rational(c, v, r);
+        SASSERT(u);
+        if (ok == Z3_TRUE && r.is_uint64()) {
+            *u = r.get_uint64();
+            return ok;
+        }
+        return Z3_FALSE;
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+    
+    Z3_bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, long long* i) {
+        Z3_TRY;
+        // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object.
+        LOG_Z3_get_numeral_int64(c, v, i);
+        RESET_ERROR_CODE();
+        if (!i) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return Z3_FALSE;
+        }
+        rational r;
+        Z3_bool ok = Z3_get_numeral_rational(c, v, r);
+        if (ok == Z3_TRUE && r.is_int64()) {
+            *i = r.get_int64();
+            return ok;
+        }
+        return Z3_FALSE;
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    Z3_bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, long long* num, long long* den) {
+        Z3_TRY;
+        // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object.
+        LOG_Z3_get_numeral_rational_int64(c, v, num, den);
+        RESET_ERROR_CODE();
+        if (!num || !den) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return Z3_FALSE;
+        }
+        rational r;
+        Z3_bool ok = Z3_get_numeral_rational(c, v, r);
+        if (ok != Z3_TRUE) {
+            return ok;
+        }
+        rational n = numerator(r);
+        rational d = denominator(r);
+        if (n.is_int64() && d.is_int64()) {
+            *num = n.get_int64();
+            *den = d.get_int64();
+            return ok;
+        }
+        return Z3_FALSE;
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+};

src/api/api_params.cpp

@@ -0,0 +1,199 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_params.cpp
+
+Abstract:
+    API for creating parameter sets.
+    
+    This is essentially a wrapper for params_ref.
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-05.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"params.h"
+
+extern "C" {
+    
+    Z3_params Z3_API Z3_mk_params(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_mk_params(c);
+        RESET_ERROR_CODE();
+        Z3_params_ref * p = alloc(Z3_params_ref);
+        mk_c(c)->save_object(p);
+        Z3_params r = of_params(p);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    /**
+       \brief Increment the reference counter of the given parameter set.
+    */
+    void Z3_API Z3_params_inc_ref(Z3_context c, Z3_params p) {
+        Z3_TRY;
+        LOG_Z3_params_inc_ref(c, p);
+        RESET_ERROR_CODE();
+        to_params(p)->inc_ref();
+        Z3_CATCH;
+    }
+
+    /**
+       \brief Decrement the reference counter of the given parameter set.
+    */
+    void Z3_API Z3_params_dec_ref(Z3_context c, Z3_params p) {
+        Z3_TRY;
+        LOG_Z3_params_dec_ref(c, p);
+        RESET_ERROR_CODE();
+        to_params(p)->dec_ref();
+        Z3_CATCH;
+    }
+
+    /**
+       \brief Add a Boolean parameter \c k with value \c v to the parameter set \c p.
+    */
+    void Z3_API Z3_params_set_bool(Z3_context c, Z3_params p, Z3_symbol k, Z3_bool v) {
+        Z3_TRY;
+        LOG_Z3_params_set_bool(c, p, k, v);
+        RESET_ERROR_CODE();
+        to_params(p)->m_params.set_bool(to_symbol(k), v != 0);
+        Z3_CATCH;
+    }
+
+    /**
+       \brief Add a unsigned parameter \c k with value \c v to the parameter set \c p.
+    */
+    void Z3_API Z3_params_set_uint(Z3_context c, Z3_params p, Z3_symbol k, unsigned v) {
+        Z3_TRY;
+        LOG_Z3_params_set_uint(c, p, k, v);
+        RESET_ERROR_CODE();
+        to_params(p)->m_params.set_uint(to_symbol(k), v);
+        Z3_CATCH;
+    }
+
+    /**
+       \brief Add a double parameter \c k with value \c v to the parameter set \c p.
+    */
+    void Z3_API Z3_params_set_double(Z3_context c, Z3_params p, Z3_symbol k, double v) {
+        Z3_TRY;
+        LOG_Z3_params_set_double(c, p, k, v);
+        RESET_ERROR_CODE();
+        to_params(p)->m_params.set_double(to_symbol(k), v);
+        Z3_CATCH;
+    }
+
+    /**
+       \brief Add a symbol parameter \c k with value \c v to the parameter set \c p.
+    */
+    void Z3_API Z3_params_set_symbol(Z3_context c, Z3_params p, Z3_symbol k, Z3_symbol v) {
+        Z3_TRY;
+        LOG_Z3_params_set_symbol(c, p, k, v);
+        RESET_ERROR_CODE();
+        to_params(p)->m_params.set_sym(to_symbol(k), to_symbol(v));
+        Z3_CATCH;
+    }
+    
+    /**
+       \brief Convert a parameter set into a string. This function is mainly used for printing the
+       contents of a parameter set.
+    */
+    Z3_string Z3_API Z3_params_to_string(Z3_context c, Z3_params p) {
+        Z3_TRY;
+        LOG_Z3_params_to_string(c, p);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        to_params(p)->m_params.display(buffer);
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN("");
+    }
+
+    void Z3_API Z3_params_validate(Z3_context c, Z3_params p, Z3_param_descrs d) {
+        Z3_TRY;
+        LOG_Z3_params_validate(c, p, d);
+        RESET_ERROR_CODE();
+        to_params(p)->m_params.validate(*to_param_descrs_ptr(d));
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_param_descrs_inc_ref(Z3_context c, Z3_param_descrs p) {
+        Z3_TRY;
+        LOG_Z3_param_descrs_inc_ref(c, p);
+        RESET_ERROR_CODE();
+        to_param_descrs(p)->inc_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_param_descrs_dec_ref(Z3_context c, Z3_param_descrs p) {
+        Z3_TRY;
+        LOG_Z3_param_descrs_dec_ref(c, p);
+        RESET_ERROR_CODE();
+        to_param_descrs(p)->dec_ref();
+        Z3_CATCH;
+    }
+
+    Z3_param_kind Z3_API Z3_param_descrs_get_kind(Z3_context c, Z3_param_descrs p, Z3_symbol n) {
+        Z3_TRY;
+        LOG_Z3_param_descrs_get_kind(c, p, n);
+        RESET_ERROR_CODE();
+        param_kind k = to_param_descrs_ptr(p)->get_kind(to_symbol(n));
+        switch (k) {
+        case CPK_UINT:    return Z3_PK_UINT;
+        case CPK_BOOL:    return Z3_PK_BOOL;
+        case CPK_DOUBLE:  return Z3_PK_DOUBLE;
+        case CPK_STRING:  return Z3_PK_STRING;
+        case CPK_SYMBOL:  return Z3_PK_SYMBOL;
+        case CPK_INVALID: return Z3_PK_INVALID;
+        default:          return Z3_PK_OTHER;
+        }
+        Z3_CATCH_RETURN(Z3_PK_INVALID);
+    }
+    
+    unsigned Z3_API Z3_param_descrs_size(Z3_context c, Z3_param_descrs p) {
+        Z3_TRY;
+        LOG_Z3_param_descrs_size(c, p);
+        RESET_ERROR_CODE();
+        return to_param_descrs_ptr(p)->size();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_symbol Z3_API Z3_param_descrs_get_name(Z3_context c, Z3_param_descrs p, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_param_descrs_get_name(c, p, i);
+        RESET_ERROR_CODE();
+        if (i >= to_param_descrs_ptr(p)->size()) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        Z3_symbol result = of_symbol(to_param_descrs_ptr(p)->get_param_name(i));
+        return result;
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_string Z3_API Z3_param_descrs_to_string(Z3_context c, Z3_param_descrs p) {
+        Z3_TRY;
+        LOG_Z3_param_descrs_to_string(c, p);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        buffer << "(";
+        unsigned sz = to_param_descrs_ptr(p)->size();
+        for (unsigned i = 0; i < sz; i++) {
+            if (i > 0) 
+                buffer << ", ";
+            buffer << to_param_descrs_ptr(p)->get_param_name(i);
+        }
+        buffer << ")";
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN("");
+    }
+
+};

src/api/api_parsers.cpp

@@ -0,0 +1,426 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_parsers.cpp
+
+Abstract:
+    API for parsing different formats
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"cmd_context.h"
+#include"smt2parser.h"
+#include"smtparser.h"
+#include"z3_solver.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);
+        std::ostringstream outs;
+        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();
+        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_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();
+        std::ostringstream outs;
+        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();
+        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);
+        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();
+        Z3_CATCH_RETURN("");
+    }
+    
+    Z3_ast parse_z3_stream(Z3_context c, std::istream& is) {
+        z3_solver parser(c, is, verbose_stream(), mk_c(c)->fparams(), false);
+        if (!parser.parse()) {
+            SET_ERROR_CODE(Z3_PARSER_ERROR);
+            return of_ast(mk_c(c)->m().mk_true());
+        }
+        expr_ref_vector assumptions(mk_c(c)->m());
+        parser.get_assumptions(assumptions);
+        return of_ast(mk_c(c)->mk_and(assumptions.size(), assumptions.c_ptr()));
+    }
+
+    Z3_ast Z3_API Z3_parse_z3_string(Z3_context c, Z3_string str) { 
+        Z3_TRY;
+        LOG_Z3_parse_z3_string(c, str);
+        std::string s(str);
+        std::istringstream is(s);
+        Z3_ast r = parse_z3_stream(c, is);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_parse_z3_file(Z3_context c, Z3_string file_name) {
+        Z3_TRY;
+        LOG_Z3_parse_z3_file(c, file_name);
+        std::ifstream is(file_name);
+        if (!is) {
+            SET_ERROR_CODE(Z3_PARSER_ERROR);
+            return 0;
+        }
+        Z3_ast r = parse_z3_stream(c, is);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    // ---------------
+    // Support for SMTLIB2
+
+    class z3_context_solver : public solver {
+        api::context & m_ctx;
+        smt::solver & ctx() const { return m_ctx.get_solver(); }
+    public:
+        virtual ~z3_context_solver() {}
+        z3_context_solver(api::context& c) : m_ctx(c) {}
+        virtual void init(ast_manager & m, symbol const & logic) {}
+        virtual void collect_statistics(statistics & st) const {}
+        virtual void reset() { ctx().reset(); }
+        virtual void assert_expr(expr * t) { ctx().assert_expr(t); }
+        virtual void push() { ctx().push(); }
+        virtual void pop(unsigned n) { ctx().pop(n); }
+        virtual unsigned get_scope_level() const { return ctx().get_scope_level(); }
+        virtual lbool check_sat(unsigned num_assumptions, expr * const * assumptions) {
+            return ctx().check(num_assumptions, assumptions);
+        }
+        virtual void get_unsat_core(ptr_vector<expr> & r) {
+            unsigned sz = ctx().get_unsat_core_size();
+            for (unsigned i = 0; i < sz; i++)
+                r.push_back(ctx().get_unsat_core_expr(i));            
+        }
+        virtual void get_model(model_ref & m) { ctx().get_model(m); }
+        virtual proof * get_proof() { return ctx().get_proof(); }
+        virtual std::string reason_unknown() const { return ctx().last_failure_as_string(); }
+        virtual void get_labels(svector<symbol> & r) {
+            buffer<symbol> tmp;
+            ctx().get_relevant_labels(0, tmp);
+            r.append(tmp.size(), tmp.c_ptr());            
+        }
+        
+        // These are controlled by the main API
+        virtual void set_cancel(bool f) { }
+        void cancel() { set_cancel(true); }
+        void reset_cancel() { set_cancel(false); }        
+        virtual void set_progress_callback(progress_callback * callback) {}        
+    };
+
+    Z3_ast parse_smtlib2_stream(bool exec, Z3_context c, std::istream& is,
+                                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;
+        cmd_context ctx(mk_c(c)->fparams(), false, &(mk_c(c)->m()));
+        ctx.set_ignore_check(true);
+        if (exec) {
+            ctx.set_solver(alloc(z3_context_solver, *mk_c(c)));
+        }
+        for (unsigned i = 0; i < num_decls; ++i) {
+           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));
+        }
+        if (!parse_smt2_commands(ctx, is)) {
+            SET_ERROR_CODE(Z3_PARSER_ERROR);
+            return of_ast(mk_c(c)->m().mk_true());
+        }
+        ptr_vector<expr>::const_iterator it  = ctx.begin_assertions();
+        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_ast Z3_API Z3_parse_smtlib2_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[]) {
+        Z3_TRY;
+        LOG_Z3_parse_smtlib2_string(c, str, num_sorts, sort_names, sorts, num_decls, decl_names, decls);
+        std::string s(str);
+        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_ast Z3_API Z3_parse_smtlib2_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[]) {
+        Z3_TRY;
+        LOG_Z3_parse_smtlib2_string(c, file_name, num_sorts, sort_names, sorts, num_decls, decl_names, decls);
+        std::ifstream is(file_name);
+        if (!is) {
+            SET_ERROR_CODE(Z3_PARSER_ERROR);
+            return 0;
+        }
+        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_ast Z3_API Z3_exec_smtlib2_string(Z3_context c, Z3_string str,
+                                         unsigned num_sorts,
+                                         Z3_symbol sort_names[],
+                                         Z3_sort sorts[],
+                                         unsigned num_decls,
+                                         Z3_symbol decl_names[],
+                                         Z3_func_decl decls[]) { 
+        Z3_TRY;
+        cmd_context ctx(mk_c(c)->fparams(), false, &(mk_c(c)->m()));
+        std::string s(str);
+        std::istringstream is(s);
+        // No logging for this one, since it private.
+        return parse_smtlib2_stream(true, c, is, num_sorts, sort_names, sorts, num_decls, decl_names, decls);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_exec_smtlib2_file(Z3_context c, Z3_string file_name,
+                                       unsigned num_sorts,
+                                       Z3_symbol sort_names[],
+                                       Z3_sort sorts[],
+                                       unsigned num_decls,
+                                       Z3_symbol decl_names[],
+                                       Z3_func_decl decls[]) { 
+        Z3_TRY;
+        std::ifstream is(file_name);
+        if (!is) {
+            SET_ERROR_CODE(Z3_PARSER_ERROR);
+            return 0;
+        }
+        // No logging for this one, since it private.
+        return parse_smtlib2_stream(true, c, is, num_sorts, sort_names, sorts, num_decls, decl_names, decls);
+        Z3_CATCH_RETURN(0);
+    }
+
+};

src/api/api_poly.cpp

@@ -0,0 +1,78 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_poly.cpp
+
+Abstract:
+
+    External API for polynomial package
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-10-18.
+
+Revision History:
+
+--*/
+#include"z3.h"
+#include"z3_internal.h"
+#include"api_context.h"
+#include"api_poly.h"
+#include"api_util.h"
+#include"api_log_macros.h"
+
+Z3_polynomial_manager Z3_mk_polynomial_manager(Z3_context c) {
+    Z3_TRY;
+    LOG_Z3_mk_polynomial_manager(c);
+    RESET_ERROR_CODE();
+    _Z3_polynomial_manager * m = alloc(_Z3_polynomial_manager);
+    RETURN_Z3(of_poly_manager(m));
+    Z3_CATCH_RETURN(0);
+}
+
+void Z3_del_polynomial_manager(Z3_context c, Z3_polynomial_manager m) {
+    Z3_TRY;
+    LOG_Z3_del_polynomial_manager(c, m);
+    RESET_ERROR_CODE();
+    dealloc(to_poly_manager(m));
+    Z3_CATCH;
+}
+
+Z3_polynomial Z3_mk_zero_polynomial(Z3_context c, Z3_polynomial_manager m) {
+    Z3_TRY;
+    LOG_Z3_mk_zero_polynomial(c, m);
+    RESET_ERROR_CODE();
+    polynomial::polynomial * r = to_poly_manager(m)->m_manager.mk_zero();
+    to_poly_manager(m)->m_result = r;
+    RETURN_Z3(of_poly(r));
+    Z3_CATCH_RETURN(0);
+}
+
+void Z3_polynomial_inc_ref(Z3_context c, Z3_polynomial_manager m, Z3_polynomial p) {
+    Z3_TRY;
+    LOG_Z3_polynomial_inc_ref(c, m, p);
+    RESET_ERROR_CODE();
+    to_poly_manager(m)->m_manager.inc_ref(to_poly(p));
+    Z3_CATCH;
+}
+
+void Z3_polynomial_dec_ref(Z3_context c, Z3_polynomial_manager m, Z3_polynomial p) {
+    Z3_TRY;
+    LOG_Z3_polynomial_inc_ref(c, m, p);
+    RESET_ERROR_CODE();
+    to_poly_manager(m)->m_manager.dec_ref(to_poly(p));
+    Z3_CATCH;
+}
+
+Z3_string Z3_polynomial_to_string(Z3_context c, Z3_polynomial_manager m, Z3_polynomial p) {
+    Z3_TRY;
+    LOG_Z3_polynomial_to_string(c, m, p);
+    RESET_ERROR_CODE();
+    std::ostringstream buffer;
+    to_poly_manager(m)->m_manager.display(buffer, to_poly(p));
+    return mk_c(c)->mk_external_string(buffer.str());
+    Z3_CATCH_RETURN("");
+}
+

src/api/api_poly.h

@@ -0,0 +1,40 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_poly.h
+
+Abstract:
+    External API for polynomial package
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-10-18.
+
+Revision History:
+
+--*/
+#ifndef _API_POLY_H_
+#define _API_POLY_H_
+
+#include"polynomial.h"
+
+struct _Z3_polynomial_manager {
+    unsynch_mpz_manager m_num_manager;
+    polynomial::manager m_manager;
+    polynomial_ref      m_result;
+
+    _Z3_polynomial_manager():
+        m_manager(m_num_manager),
+        m_result(m_manager) {
+    }
+};
+
+inline _Z3_polynomial_manager * to_poly_manager(Z3_polynomial_manager m) { return reinterpret_cast<_Z3_polynomial_manager*>(m); }
+inline Z3_polynomial_manager of_poly_manager(_Z3_polynomial_manager * m) { return reinterpret_cast<Z3_polynomial_manager>(m); }
+
+inline polynomial::polynomial * to_poly(Z3_polynomial p) { return reinterpret_cast<polynomial::polynomial*>(p); }
+inline Z3_polynomial of_poly(polynomial::polynomial * p) { return reinterpret_cast<Z3_polynomial>(p); }
+
+#endif

src/api/api_quant.cpp

@@ -0,0 +1,511 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_quant.cpp
+
+Abstract:
+    API for quantifiers
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"pattern_validation.h"
+#include"expr_abstract.h"
+
+extern "C" {
+
+    Z3_ast Z3_API Z3_mk_quantifier(
+        Z3_context c, 
+        Z3_bool is_forall, 
+        unsigned weight, 
+        unsigned num_patterns, Z3_pattern const patterns[], 
+        unsigned num_decls, Z3_sort const sorts[], 
+        Z3_symbol const decl_names[], 
+        Z3_ast body) 
+    {
+        return Z3_mk_quantifier_ex(
+            c, 
+            is_forall, 
+            weight,
+            0,
+            0,
+            num_patterns, patterns,
+            0, 0,
+            num_decls, sorts,
+            decl_names,
+            body
+            );
+
+    }
+
+    Z3_ast mk_quantifier_ex_core(
+        Z3_context c, 
+        Z3_bool is_forall, 
+        unsigned weight, 
+        Z3_symbol quantifier_id,
+        Z3_symbol skolem_id,
+        unsigned num_patterns, Z3_pattern const patterns[], 
+        unsigned num_no_patterns, Z3_ast const no_patterns[], 
+        unsigned num_decls, Z3_sort const sorts[], 
+        Z3_symbol const decl_names[], 
+        Z3_ast body) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        if (!mk_c(c)->m().is_bool(to_expr(body))) {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+        }
+        if (num_patterns > 0 && num_no_patterns > 0) {
+            SET_ERROR_CODE(Z3_INVALID_USAGE);
+        }
+        expr * const* ps = reinterpret_cast<expr * const*>(patterns);
+        expr * const* no_ps = reinterpret_cast<expr * const*>(no_patterns);
+        pattern_validator v(mk_c(c)->m());
+        for (unsigned i = 0; i < num_patterns; i++) {
+            if (!v(num_decls, ps[i])) {
+                SET_ERROR_CODE(Z3_INVALID_PATTERN);
+                return 0;
+            }
+        }
+
+        sort* const* ts = reinterpret_cast<sort * const*>(sorts);
+        svector<symbol> names;
+        for (unsigned i = 0; i < num_decls; ++i) {
+            names.push_back(to_symbol(decl_names[i]));
+        }
+        expr_ref result(mk_c(c)->m());
+        if (num_decls > 0) {
+            result = mk_c(c)->m().mk_quantifier(
+                (0 != is_forall), 
+                names.size(), ts, names.c_ptr(), to_expr(body),            
+                weight, 
+                to_symbol(quantifier_id),
+                to_symbol(skolem_id),
+                num_patterns, ps,
+                num_no_patterns, no_ps
+                );
+        }
+        else {
+            result = to_expr(body);
+        }
+        mk_c(c)->save_ast_trail(result.get());
+        return of_ast(result.get());
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_mk_quantifier_ex(
+        Z3_context c, 
+        Z3_bool is_forall, 
+        unsigned weight, 
+        Z3_symbol quantifier_id,
+        Z3_symbol skolem_id,
+        unsigned num_patterns, Z3_pattern const patterns[], 
+        unsigned num_no_patterns, Z3_ast const no_patterns[], 
+        unsigned num_decls, Z3_sort const sorts[], 
+        Z3_symbol const decl_names[], 
+        Z3_ast body)
+    {
+        LOG_Z3_mk_quantifier_ex(c, is_forall, weight, quantifier_id, skolem_id, num_patterns, patterns, 
+                                num_no_patterns, no_patterns, num_decls, sorts, decl_names, body);
+        Z3_ast r = mk_quantifier_ex_core(c, is_forall, weight, quantifier_id, skolem_id, num_patterns, patterns, 
+                                         num_no_patterns, no_patterns, num_decls, sorts, decl_names, body);
+        RETURN_Z3(r);
+    }
+    
+    Z3_ast Z3_API Z3_mk_forall(Z3_context c, 
+                               unsigned weight, 
+                               unsigned num_patterns, Z3_pattern const patterns[], 
+                               unsigned num_decls, Z3_sort const types[], 
+                               Z3_symbol const decl_names[], 
+                               Z3_ast body) {
+        return Z3_mk_quantifier(c, 1, weight, num_patterns, patterns, num_decls, types, decl_names, body);
+    }
+    
+    Z3_ast Z3_API Z3_mk_exists(Z3_context c, 
+                               unsigned weight, 
+                               unsigned num_patterns, Z3_pattern const patterns[], 
+                               unsigned num_decls, Z3_sort const types[], 
+                               Z3_symbol const decl_names[], 
+                               Z3_ast body) {
+        return Z3_mk_quantifier(c, 0, weight, num_patterns, patterns, num_decls, types, decl_names, body);
+    }
+
+
+    Z3_ast Z3_API Z3_mk_quantifier_const_ex(Z3_context c, 
+                                            Z3_bool is_forall,
+                                            unsigned weight,
+                                            Z3_symbol quantifier_id,
+                                            Z3_symbol skolem_id,
+                                            unsigned num_bound,
+                                            Z3_app const bound[],
+                                            unsigned num_patterns,
+                                            Z3_pattern const patterns[],
+                                            unsigned num_no_patterns,
+                                            Z3_ast const no_patterns[],
+                                            Z3_ast body) {
+        Z3_TRY;
+        LOG_Z3_mk_quantifier_const_ex(c, is_forall, weight, quantifier_id, skolem_id, num_bound, bound, num_patterns, patterns,
+                                      num_no_patterns, no_patterns, body);
+        RESET_ERROR_CODE();
+        svector<Z3_symbol> names;
+        svector<Z3_sort> types;
+        ptr_vector<expr> bound_asts;
+        if (num_patterns > 0 && num_no_patterns > 0) {
+            SET_ERROR_CODE(Z3_INVALID_USAGE);
+        }
+        for (unsigned i = 0; i < num_bound; ++i) {
+            app* a = to_app(bound[i]);
+            SASSERT(a->get_kind() == AST_APP);
+            symbol s(to_app(a)->get_decl()->get_name());
+            names.push_back(of_symbol(s));
+            types.push_back(of_sort(mk_c(c)->m().get_sort(a)));
+            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);
+            }
+        }
+        // Abstract patterns
+        svector<Z3_pattern> _patterns;
+        expr_ref_vector pinned(mk_c(c)->m());
+        for (unsigned i = 0; i < num_patterns; ++i) {
+            expr_ref result(mk_c(c)->m());
+            app* pat = to_pattern(patterns[i]);
+            SASSERT(mk_c(c)->m().is_pattern(pat));
+            expr_abstract(mk_c(c)->m(), 0, num_bound, bound_asts.c_ptr(), pat, result);
+            SASSERT(result.get()->get_kind() == AST_APP);        
+            pinned.push_back(result.get());
+            SASSERT(mk_c(c)->m().is_pattern(result.get()));
+            _patterns.push_back(of_pattern(result.get()));
+        }
+        svector<Z3_ast> _no_patterns;
+        for (unsigned i = 0; i < num_no_patterns; ++i) {
+            expr_ref result(mk_c(c)->m());
+            if (!is_app(to_expr(no_patterns[i]))) {
+                SET_ERROR_CODE(Z3_INVALID_ARG);
+                RETURN_Z3(0);
+            }
+            app* pat = to_app(to_expr(no_patterns[i]));
+            expr_abstract(mk_c(c)->m(), 0, num_bound, bound_asts.c_ptr(), pat, result);
+            SASSERT(result.get()->get_kind() == AST_APP);        
+            pinned.push_back(result.get());
+            _no_patterns.push_back(of_ast(result.get()));
+        }
+        expr_ref abs_body(mk_c(c)->m());
+        expr_abstract(mk_c(c)->m(), 0, num_bound, bound_asts.c_ptr(), to_expr(body), abs_body);
+
+        Z3_ast result = mk_quantifier_ex_core(c, is_forall, weight, 
+                                              quantifier_id,
+                                              skolem_id,
+                                              num_patterns, _patterns.c_ptr(), 
+                                              num_no_patterns, _no_patterns.c_ptr(),
+                                              names.size(), types.c_ptr(), names.c_ptr(), 
+                                              of_ast(abs_body.get()));
+        RETURN_Z3(result);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_mk_quantifier_const(Z3_context c, 
+                                         Z3_bool is_forall,
+                                         unsigned weight,
+                                         unsigned num_bound,
+                                         Z3_app const bound[],
+                                         unsigned num_patterns,
+                                         Z3_pattern const patterns[],
+                                         Z3_ast body) {
+        return Z3_mk_quantifier_const_ex(c, is_forall, weight, 0, 0, 
+                                         num_bound, bound, 
+                                         num_patterns, patterns,
+                                         0, 0,
+                                         body);
+    }
+
+    Z3_ast Z3_API Z3_mk_forall_const(Z3_context c, 
+                                     unsigned weight,
+                                     unsigned num_bound,
+                                     Z3_app const bound[],
+                                     unsigned num_patterns,
+                                     Z3_pattern const patterns[],
+                                     Z3_ast body) {
+        return Z3_mk_quantifier_const(c, true, weight, num_bound, bound, num_patterns, patterns, body);
+    }
+
+    Z3_ast Z3_API Z3_mk_exists_const(Z3_context c, 
+                                     unsigned weight,
+                                     unsigned num_bound,
+                                     Z3_app const bound[],
+                                     unsigned num_patterns,
+                                     Z3_pattern const patterns[],
+                                     Z3_ast body) {
+        return Z3_mk_quantifier_const(c, false, weight, num_bound, bound, num_patterns, patterns, body);
+    }
+    
+    Z3_pattern Z3_API Z3_mk_pattern(Z3_context c, unsigned num_patterns, Z3_ast const terms[]) {
+        Z3_TRY;
+        LOG_Z3_mk_pattern(c, num_patterns, terms);
+        RESET_ERROR_CODE();
+        for (unsigned i = 0; i < num_patterns; ++i) {
+            if (!is_app(to_expr(terms[i]))) {
+                SET_ERROR_CODE(Z3_INVALID_ARG);
+                RETURN_Z3(0);
+            }
+        }
+        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_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty) {
+        Z3_TRY;
+        LOG_Z3_mk_bound(c, index, ty);
+        RESET_ERROR_CODE();
+        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_bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_is_quantifier_forall(c, a);
+        RESET_ERROR_CODE();
+        ast * _a = to_ast(a);
+        if (_a->get_kind() == AST_QUANTIFIER) {
+            return to_quantifier(_a)->is_forall();
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            return Z3_FALSE;
+        }
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    unsigned Z3_API Z3_get_quantifier_weight(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_get_quantifier_weight(c, a);
+        RESET_ERROR_CODE();
+        ast * _a = to_ast(a);
+        if (_a->get_kind() == AST_QUANTIFIER) {
+            return to_quantifier(_a)->get_weight();
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            return 0;
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_API Z3_get_quantifier_num_patterns(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_get_quantifier_num_patterns(c, a);
+        RESET_ERROR_CODE();
+        ast * _a = to_ast(a);
+        if (_a->get_kind() == AST_QUANTIFIER) {
+            return to_quantifier(_a)->get_num_patterns();
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            return 0;
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_pattern Z3_API Z3_get_quantifier_pattern_ast(Z3_context c, Z3_ast a, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_get_quantifier_pattern_ast(c, a, i);
+        RESET_ERROR_CODE();
+        ast * _a = to_ast(a);
+        if (_a->get_kind() == AST_QUANTIFIER) {
+            Z3_pattern r = of_pattern(to_quantifier(_a)->get_patterns()[i]);
+            RETURN_Z3(r);
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            RETURN_Z3(0);
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+
+    unsigned Z3_API Z3_get_quantifier_num_no_patterns(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_get_quantifier_num_no_patterns(c, a);
+        RESET_ERROR_CODE();
+        ast * _a = to_ast(a);
+        if (_a->get_kind() == AST_QUANTIFIER) {
+            return to_quantifier(_a)->get_num_no_patterns();
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            return 0;
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_get_quantifier_no_pattern_ast(Z3_context c, Z3_ast a, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_get_quantifier_no_pattern_ast(c, a, i);
+        RESET_ERROR_CODE();
+        ast * _a = to_ast(a);
+        if (_a->get_kind() == AST_QUANTIFIER) {
+            Z3_ast r = of_ast(to_quantifier(_a)->get_no_pattern(i));
+            RETURN_Z3(r);
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            RETURN_Z3(0);
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_symbol Z3_API Z3_get_quantifier_bound_name(Z3_context c, Z3_ast a, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_get_quantifier_bound_name(c, a, i);
+        RESET_ERROR_CODE();
+        ast * _a = to_ast(a);
+        if (_a->get_kind() == AST_QUANTIFIER) {
+            return of_symbol(to_quantifier(_a)->get_decl_names()[i]);
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            return 0;
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_sort Z3_API Z3_get_quantifier_bound_sort(Z3_context c, Z3_ast a, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_get_quantifier_bound_sort(c, a, i);
+        RESET_ERROR_CODE();
+        ast * _a = to_ast(a);
+        if (_a->get_kind() == AST_QUANTIFIER) {
+            Z3_sort r = of_sort(to_quantifier(_a)->get_decl_sort(i));
+            RETURN_Z3(r);
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            RETURN_Z3(0);
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_get_quantifier_body(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_get_quantifier_body(c, a);
+        RESET_ERROR_CODE();
+        ast * _a = to_ast(a);
+        if (_a->get_kind() == AST_QUANTIFIER) {
+            Z3_ast r = of_ast(to_quantifier(_a)->get_expr());
+            RETURN_Z3(r);
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            RETURN_Z3(0);
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_API Z3_get_quantifier_num_bound(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_get_quantifier_num_bound(c, a);
+        RESET_ERROR_CODE();
+        ast * _a = to_ast(a);
+        if (_a->get_kind() == AST_QUANTIFIER) {
+
+            return to_quantifier(_a)->get_num_decls();
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            return 0;
+        }        
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_API Z3_get_pattern_num_terms(Z3_context c, Z3_pattern p) {
+        Z3_TRY;
+        LOG_Z3_get_pattern_num_terms(c, p);
+        RESET_ERROR_CODE();
+        app* _p = to_pattern(p);
+        if (mk_c(c)->m().is_pattern(_p)) {
+            return _p->get_num_args();
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            return 0;            
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_get_pattern(Z3_context c, Z3_pattern p, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_get_pattern(c, p, idx);
+        RESET_ERROR_CODE();
+        app* _p = to_pattern(p);
+        if (mk_c(c)->m().is_pattern(_p)) {
+            Z3_ast r = of_ast(_p->get_arg(idx));
+            RETURN_Z3(r);
+        }
+        else {
+            SET_ERROR_CODE(Z3_SORT_ERROR);
+            RETURN_Z3(0);
+        }
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_func_decl Z3_API Z3_mk_injective_function(Z3_context c, 
+                                                 Z3_symbol s, 
+                                                 unsigned domain_size, 
+                                                 Z3_sort const domain[],
+                                                 Z3_sort range) {
+        Z3_TRY;
+        LOG_Z3_mk_injective_function(c, s, domain_size, domain, range);
+        RESET_ERROR_CODE(); 
+        ast_manager & m = mk_c(c)->m();
+        mk_c(c)->reset_last_result();
+        sort* range_ = to_sort(range);
+        func_decl* d = m.mk_func_decl(to_symbol(s), domain_size, to_sorts(domain), range_);
+        expr_ref_vector args(m);
+        expr_ref fn(m), body(m);
+        vector<symbol> names;
+        for (unsigned i = 0; i < domain_size; ++i) {
+            unsigned idx = domain_size-i-1;
+            args.push_back(m.mk_var(idx, to_sort(domain[i])));
+            names.push_back(symbol(idx));
+        }
+        fn = m.mk_app(d, args.size(), args.c_ptr());
+
+        for (unsigned i = 0; i < domain_size; ++i) {
+            expr* arg = args[i].get();
+            sort* dom = m.get_sort(arg);
+            func_decl* inv = m.mk_fresh_func_decl(symbol("inv"), to_symbol(s), 1, &range_, dom);
+            body = m.mk_eq(m.mk_app(inv, fn.get()), arg);
+            body = m.mk_forall(args.size(), to_sorts(domain), names.c_ptr(), body.get());
+            mk_c(c)->save_multiple_ast_trail(body.get());
+            mk_c(c)->assert_cnstr(body.get());
+        }
+        mk_c(c)->save_multiple_ast_trail(d);       
+        RETURN_Z3(of_func_decl(d));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_pattern_to_ast(Z3_context c, Z3_pattern p) { 
+        RESET_ERROR_CODE();
+        return (Z3_ast)(p); 
+    }    
+
+    char const * Z3_API Z3_pattern_to_string(Z3_context c, Z3_pattern p) {
+        return Z3_ast_to_string(c, reinterpret_cast<Z3_ast>(p));
+    }
+    
+};

src/api/api_solver.cpp

@@ -0,0 +1,322 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_solver.cpp
+
+Abstract:
+    New solver API
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-07.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_tactic.h"
+#include"api_solver.h"
+#include"api_model.h"
+#include"api_stats.h"
+#include"api_ast_vector.h"
+#include"tactic2solver.h"
+#include"scoped_ctrl_c.h"
+#include"cancel_eh.h"
+#include"scoped_timer.h"
+#include"smt_strategic_solver.h"
+
+extern "C" {
+
+    Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_mk_simple_solver(c);
+        RESET_ERROR_CODE();
+        Z3_solver_ref * s = alloc(Z3_solver_ref);
+        s->m_solver       = mk_default_solver();
+        s->m_solver->set_front_end_params(mk_c(c)->fparams());
+        s->m_solver->init(mk_c(c)->m(), symbol::null);
+        mk_c(c)->save_object(s);
+        Z3_solver r = of_solver(s);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_solver Z3_API Z3_mk_solver(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_mk_solver(c);
+        RESET_ERROR_CODE();
+        Z3_solver_ref * s = alloc(Z3_solver_ref);
+        s->m_solver       = mk_smt_strategic_solver();
+        s->m_solver->set_front_end_params(mk_c(c)->fparams());
+        s->m_solver->init(mk_c(c)->m(), symbol::null);
+        mk_c(c)->save_object(s);
+        Z3_solver r = of_solver(s);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_solver Z3_API Z3_mk_solver_for_logic(Z3_context c, Z3_symbol logic) {
+        Z3_TRY;
+        LOG_Z3_mk_solver_for_logic(c, logic);
+        RESET_ERROR_CODE();
+        Z3_solver_ref * s = alloc(Z3_solver_ref);
+        s->m_solver       = mk_smt_strategic_solver(true /* force solver to use tactics even when auto_config is disabled */);
+        s->m_solver->set_front_end_params(mk_c(c)->fparams());
+        s->m_solver->init(mk_c(c)->m(), to_symbol(logic));
+        mk_c(c)->save_object(s);
+        Z3_solver r = of_solver(s);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_solver Z3_API Z3_mk_solver_from_tactic(Z3_context c, Z3_tactic t) {
+        Z3_TRY;
+        LOG_Z3_mk_solver_from_tactic(c, t);
+        RESET_ERROR_CODE();
+        Z3_solver_ref * s = alloc(Z3_solver_ref);
+        s->m_solver       = alloc(tactic2solver_api, to_tactic_ref(t));
+        s->m_solver->set_front_end_params(mk_c(c)->fparams());
+        s->m_solver->init(mk_c(c)->m(), symbol::null);
+        mk_c(c)->save_object(s);
+        Z3_solver r = of_solver(s);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_string Z3_API Z3_solver_get_help(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_get_help(c, s);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        param_descrs descrs;
+        to_solver_ref(s)->collect_param_descrs(descrs);
+        descrs.display(buffer);
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN("");
+    }
+
+    Z3_param_descrs Z3_API Z3_solver_get_param_descrs(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_get_param_descrs(c, s);
+        RESET_ERROR_CODE();
+        Z3_param_descrs_ref * d = alloc(Z3_param_descrs_ref);
+        mk_c(c)->save_object(d);
+        to_solver_ref(s)->collect_param_descrs(d->m_descrs);
+        Z3_param_descrs r = of_param_descrs(d);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_solver_set_params(Z3_context c, Z3_solver s, Z3_params p) {
+        Z3_TRY;
+        LOG_Z3_solver_set_params(c, s, p);
+        RESET_ERROR_CODE();
+        to_solver_ref(s)->updt_params(to_param_ref(p));
+        to_solver(s)->m_params = to_param_ref(p);
+        Z3_CATCH;
+    }
+    
+    void Z3_API Z3_solver_inc_ref(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_inc_ref(c, s);
+        RESET_ERROR_CODE();
+        to_solver(s)->inc_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_solver_dec_ref(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_dec_ref(c, s);
+        RESET_ERROR_CODE();
+        to_solver(s)->dec_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_solver_push(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_push(c, s);
+        RESET_ERROR_CODE();
+        to_solver_ref(s)->push();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_solver_pop(Z3_context c, Z3_solver s, unsigned n) {
+        Z3_TRY;
+        LOG_Z3_solver_pop(c, s, n);
+        RESET_ERROR_CODE();
+        if (n > to_solver_ref(s)->get_scope_level()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return;
+        }
+        if (n > 0)
+            to_solver_ref(s)->pop(n);
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_solver_reset(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_reset(c, s);
+        RESET_ERROR_CODE();
+        to_solver_ref(s)->reset();
+        to_solver_ref(s)->init(mk_c(c)->m(), symbol::null);
+        Z3_CATCH;
+    }
+    
+    unsigned Z3_API Z3_solver_get_num_scopes(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_get_num_scopes(c, s);
+        RESET_ERROR_CODE();
+        return to_solver_ref(s)->get_scope_level();
+        Z3_CATCH_RETURN(0);
+    }
+    
+    void Z3_API Z3_solver_assert(Z3_context c, Z3_solver s, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_solver_assert(c, s, a);
+        RESET_ERROR_CODE();
+        CHECK_FORMULA(a,);        
+        to_solver_ref(s)->assert_expr(to_expr(a));
+        Z3_CATCH;
+    }
+    
+    Z3_ast_vector Z3_API Z3_solver_get_assertions(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_get_assertions(c, s);
+        RESET_ERROR_CODE();
+        Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, mk_c(c)->m());
+        mk_c(c)->save_object(v);
+        unsigned sz = to_solver_ref(s)->get_num_assertions();
+        for (unsigned i = 0; i < sz; i++) {
+            v->m_ast_vector.push_back(to_solver_ref(s)->get_assertion(i));
+        }
+        RETURN_Z3(of_ast_vector(v));
+        Z3_CATCH_RETURN(0);
+    }
+
+    static Z3_lbool _solver_check(Z3_context c, Z3_solver s, unsigned num_assumptions, Z3_ast const assumptions[]) {
+        for (unsigned i = 0; i < num_assumptions; i++) {
+            if (!is_expr(to_ast(assumptions[i]))) {
+                SET_ERROR_CODE(Z3_INVALID_ARG);
+                return Z3_L_UNDEF;
+            }
+        }
+        expr * const * _assumptions = to_exprs(assumptions);
+        to_solver_ref(s)->set_produce_models(to_solver(s)->m_params.get_bool(":model", true));
+        to_solver_ref(s)->set_produce_proofs(mk_c(c)->m().proofs_enabled());
+        to_solver_ref(s)->set_produce_unsat_cores(num_assumptions > 0);
+        unsigned timeout     = to_solver(s)->m_params.get_uint(":timeout", UINT_MAX);
+        bool     use_ctrl_c  = to_solver(s)->m_params.get_bool(":ctrl-c", false);
+        cancel_eh<solver> eh(*to_solver_ref(s));
+        api::context::set_interruptable(*(mk_c(c)), eh);
+        lbool result;
+        {
+            scoped_ctrl_c ctrlc(eh, false, use_ctrl_c);
+            scoped_timer timer(timeout, &eh);
+            try {
+                result = to_solver_ref(s)->check_sat(num_assumptions, _assumptions);
+            }
+            catch (z3_exception & ex) {
+                mk_c(c)->handle_exception(ex);
+                return Z3_L_UNDEF;
+            }
+        }
+        return static_cast<Z3_lbool>(result);
+    }
+    
+    Z3_lbool Z3_API Z3_solver_check(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_check(c, s);
+        RESET_ERROR_CODE();
+        return _solver_check(c, s, 0, 0);
+        Z3_CATCH_RETURN(Z3_L_UNDEF);
+    }
+
+    Z3_lbool Z3_API Z3_solver_check_assumptions(Z3_context c, Z3_solver s, unsigned num_assumptions, Z3_ast const assumptions[]) {
+        Z3_TRY;
+        LOG_Z3_solver_check_assumptions(c, s, num_assumptions, assumptions);
+        RESET_ERROR_CODE();
+        return _solver_check(c, s, num_assumptions, assumptions);
+        Z3_CATCH_RETURN(Z3_L_UNDEF);
+    }
+    
+    Z3_model Z3_API Z3_solver_get_model(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_get_model(c, s);
+        RESET_ERROR_CODE();
+        model_ref _m;
+        to_solver_ref(s)->get_model(_m);
+        if (!_m) {
+            SET_ERROR_CODE(Z3_INVALID_USAGE);
+            RETURN_Z3(0);
+        }
+        Z3_model_ref * m_ref = alloc(Z3_model_ref); 
+        m_ref->m_model = _m;
+        mk_c(c)->save_object(m_ref);
+        RETURN_Z3(of_model(m_ref));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_solver_get_proof(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_get_proof(c, s);
+        RESET_ERROR_CODE();
+        proof * p = to_solver_ref(s)->get_proof();
+        if (!p) {
+            SET_ERROR_CODE(Z3_INVALID_USAGE);
+            RETURN_Z3(0);
+        }
+        mk_c(c)->save_ast_trail(p);
+        RETURN_Z3(of_ast(p));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast_vector Z3_API Z3_solver_get_unsat_core(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_get_unsat_core(c, s);
+        RESET_ERROR_CODE();
+        ptr_vector<expr> core;
+        to_solver_ref(s)->get_unsat_core(core);
+        Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, mk_c(c)->m());
+        mk_c(c)->save_object(v);
+        for (unsigned i = 0; i < core.size(); i++) {
+            v->m_ast_vector.push_back(core[i]);
+        }
+        RETURN_Z3(of_ast_vector(v));
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_string Z3_API Z3_solver_get_reason_unknown(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_get_reason_unknown(c, s);
+        RESET_ERROR_CODE();
+        return mk_c(c)->mk_external_string(to_solver_ref(s)->reason_unknown());
+        Z3_CATCH_RETURN("");
+    }
+    
+    Z3_stats Z3_API Z3_solver_get_statistics(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_get_statistics(c, s);
+        RESET_ERROR_CODE();
+        Z3_stats_ref * st = alloc(Z3_stats_ref);
+        to_solver_ref(s)->collect_statistics(st->m_stats);
+        mk_c(c)->save_object(st);
+        Z3_stats r = of_stats(st);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_string Z3_API Z3_solver_to_string(Z3_context c, Z3_solver s) {
+        Z3_TRY;
+        LOG_Z3_solver_to_string(c, s);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        to_solver_ref(s)->display(buffer);
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN("");
+    }
+};

src/api/api_solver.h

@@ -0,0 +1,35 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_solver.h
+
+Abstract:
+    New solver API
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-07.
+
+Revision History:
+
+--*/
+#ifndef _API_SOLVER_H_
+#define _API_SOLVER_H_
+
+#include"api_util.h"
+#include"solver.h"
+
+struct Z3_solver_ref : public api::object {
+    solver *   m_solver;
+    params_ref m_params;
+    Z3_solver_ref():m_solver(0) {}
+    virtual ~Z3_solver_ref() { dealloc(m_solver); }
+};
+
+inline Z3_solver_ref * to_solver(Z3_solver s) { return reinterpret_cast<Z3_solver_ref *>(s); }
+inline Z3_solver of_solver(Z3_solver_ref * s) { return reinterpret_cast<Z3_solver>(s); }
+inline solver * to_solver_ref(Z3_solver s) { return to_solver(s)->m_solver; }
+
+#endif

src/api/api_solver_old.cpp

@@ -0,0 +1,365 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_solver_old.cpp
+
+Abstract:
+    OLD API for using solvers.
+
+    This has been deprecated
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_model.h"
+#include"smt_implied_equalities.h"
+#include"cancel_eh.h"
+
+extern "C" {
+
+    void Z3_API Z3_push(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_push(c);
+        RESET_ERROR_CODE();
+        CHECK_SEARCHING(c);
+        mk_c(c)->push();
+        Z3_CATCH;
+    }
+        
+    void Z3_API Z3_pop(Z3_context c, unsigned num_scopes) {
+        Z3_TRY;
+        LOG_Z3_pop(c, num_scopes);
+        RESET_ERROR_CODE();
+        CHECK_SEARCHING(c);
+        if (num_scopes > mk_c(c)->get_solver().get_scope_level()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return;
+        }
+        if (num_scopes > 0) {
+            mk_c(c)->pop(num_scopes);
+        }
+        Z3_CATCH;
+    }
+
+    unsigned Z3_API Z3_get_num_scopes(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_get_num_scopes(c);
+        RESET_ERROR_CODE();
+        return mk_c(c)->get_num_scopes();
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_assert_cnstr(Z3_context c, Z3_ast a) {
+        Z3_TRY;
+        LOG_Z3_assert_cnstr(c, a);
+        RESET_ERROR_CODE();
+        CHECK_FORMULA(a,);        
+        mk_c(c)->assert_cnstr(to_expr(a));
+        Z3_CATCH;
+    }
+
+    Z3_lbool Z3_API Z3_check_and_get_model(Z3_context c, Z3_model * m) {
+        Z3_TRY;
+        LOG_Z3_check_and_get_model(c, m);
+        RESET_ERROR_CODE();
+        CHECK_SEARCHING(c);
+        cancel_eh<smt::solver> eh(mk_c(c)->get_solver());
+        api::context::set_interruptable(*(mk_c(c)), eh);
+        flet<bool> _model(mk_c(c)->fparams().m_model, true);
+        lbool result;
+        try {
+            model_ref _m;
+            result = mk_c(c)->check(_m);
+            if (m) {
+                if (_m) {
+                    Z3_model_ref * m_ref = alloc(Z3_model_ref); 
+                    m_ref->m_model = _m;
+                    // Must bump reference counter for backward compatibility reasons.
+                    // Don't need to invoke save_object, since the counter was bumped
+                    m_ref->inc_ref(); 
+                    *m = of_model(m_ref);
+                }
+                else {
+                    *m = 0;
+                }
+            }
+        }
+        catch (z3_exception & ex) {
+            mk_c(c)->handle_exception(ex);
+            RETURN_Z3_check_and_get_model static_cast<Z3_lbool>(l_undef);
+        }
+        RETURN_Z3_check_and_get_model static_cast<Z3_lbool>(result);
+        Z3_CATCH_RETURN(Z3_L_UNDEF);
+    }
+    
+    Z3_lbool Z3_API Z3_check(Z3_context c) {
+        Z3_TRY;
+        // This is just syntax sugar... 
+        RESET_ERROR_CODE();   
+        CHECK_SEARCHING(c);
+        Z3_lbool r = Z3_check_and_get_model(c, 0);
+        return r;
+        Z3_CATCH_RETURN(Z3_L_UNDEF);
+    }
+
+    Z3_lbool Z3_API Z3_get_implied_equalities(Z3_context c, 
+                                              unsigned num_terms,
+                                              Z3_ast const terms[],
+                                              unsigned class_ids[]) {
+        Z3_TRY;
+        LOG_Z3_get_implied_equalities(c, num_terms, terms, class_ids);
+        RESET_ERROR_CODE();
+        CHECK_SEARCHING(c);
+        lbool result = smt::implied_equalities(mk_c(c)->get_solver(), num_terms, to_exprs(terms), class_ids);
+        return static_cast<Z3_lbool>(result); 
+        Z3_CATCH_RETURN(Z3_L_UNDEF);
+    }
+
+    
+    Z3_lbool Z3_API Z3_check_assumptions(Z3_context c, 
+                                         unsigned num_assumptions, Z3_ast const assumptions[], 
+                                         Z3_model * m, Z3_ast* proof, 
+                                         unsigned* core_size, Z3_ast core[]) {
+        Z3_TRY;
+        LOG_Z3_check_assumptions(c, num_assumptions, assumptions, m, proof, core_size, core);
+        RESET_ERROR_CODE();
+        CHECK_SEARCHING(c);
+        expr * const* _assumptions = to_exprs(assumptions);
+        flet<bool> _model(mk_c(c)->fparams().m_model, true);
+        cancel_eh<smt::solver> eh(mk_c(c)->get_solver());
+        api::context::set_interruptable(*(mk_c(c)), eh);
+        lbool result;
+        result = mk_c(c)->get_solver().check(num_assumptions, _assumptions);
+        if (result != l_false && m) {
+            model_ref _m;
+            mk_c(c)->get_solver().get_model(_m);
+            if (_m) {
+                Z3_model_ref * m_ref = alloc(Z3_model_ref); 
+                m_ref->m_model = _m;
+                // Must bump reference counter for backward compatibility reasons.
+                // Don't need to invoke save_object, since the counter was bumped
+                m_ref->inc_ref(); 
+                *m = of_model(m_ref);
+            }
+            else {
+                *m = 0;
+            }
+        }
+        if (result == l_false && core_size) {
+            *core_size = mk_c(c)->get_solver().get_unsat_core_size();
+            if (*core_size > num_assumptions) {
+                SET_ERROR_CODE(Z3_INVALID_ARG);
+            }
+            for (unsigned i = 0; i < *core_size; ++i) {
+                core[i] = of_ast(mk_c(c)->get_solver().get_unsat_core_expr(i));
+            }
+        }
+        else if (core_size) {
+            *core_size = 0;
+        }
+        if (result == l_false && proof) {
+            *proof = of_ast(mk_c(c)->get_solver().get_proof());
+        }
+        else if (proof) {
+            *proof = 0; // breaks abstraction.
+        }
+        RETURN_Z3_check_assumptions static_cast<Z3_lbool>(result);         
+        Z3_CATCH_RETURN(Z3_L_UNDEF);
+    }
+
+    Z3_search_failure Z3_API Z3_get_search_failure(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_get_search_failure(c);
+        RESET_ERROR_CODE();
+        CHECK_SEARCHING(c);
+        smt::failure f = mk_c(c)->get_solver().last_failure();
+        return api::mk_Z3_search_failure(f);
+        Z3_CATCH_RETURN(Z3_UNKNOWN);
+    }
+
+    class labeled_literal {
+        expr_ref m_literal;
+        symbol   m_label;
+        bool     m_enabled;
+    public:
+        labeled_literal(ast_manager& m, expr* l, symbol const& n) : m_literal(l,m), m_label(n), m_enabled(true) {}
+        labeled_literal(ast_manager& m, expr* l) : m_literal(l,m), m_label(), m_enabled(true) {}
+        bool is_enabled() const { return m_enabled; }
+        void disable() { m_enabled = false; }
+        symbol const& get_label() const { return m_label; }
+        expr* get_literal() { return m_literal.get(); }
+    };
+    
+    typedef vector<labeled_literal> labels;
+
+    Z3_literals Z3_API Z3_get_relevant_labels(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_get_relevant_labels(c);
+        RESET_ERROR_CODE();
+        buffer<symbol> labl_syms;
+        ast_manager& m = mk_c(c)->m();
+        expr_ref_vector lits(m);
+        mk_c(c)->get_solver().get_relevant_labels(0, labl_syms);
+        mk_c(c)->get_solver().get_relevant_labeled_literals(mk_c(c)->fparams().m_at_labels_cex, lits);        
+        labels* lbls = alloc(labels);
+        SASSERT(labl_syms.size() == lits.size());
+        for (unsigned i = 0; i < lits.size(); ++i) {
+            lbls->push_back(labeled_literal(m,lits[i].get(), labl_syms[i]));
+        }
+        RETURN_Z3(reinterpret_cast<Z3_literals>(lbls));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_literals Z3_API Z3_get_relevant_literals(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_get_relevant_literals(c);
+        RESET_ERROR_CODE();
+        ast_manager& m = mk_c(c)->m();
+        expr_ref_vector lits(m);
+        mk_c(c)->get_solver().get_relevant_literals(lits);        
+        labels* lbls = alloc(labels);
+        for (unsigned i = 0; i < lits.size(); ++i) {
+            lbls->push_back(labeled_literal(m,lits[i].get()));
+        }
+        RETURN_Z3(reinterpret_cast<Z3_literals>(lbls));        
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_literals Z3_API Z3_get_guessed_literals(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_get_guessed_literals(c);
+        RESET_ERROR_CODE();
+        ast_manager& m = mk_c(c)->m();
+        expr_ref_vector lits(m);
+        mk_c(c)->get_solver().get_guessed_literals(lits);        
+        labels* lbls = alloc(labels);
+        for (unsigned i = 0; i < lits.size(); ++i) {
+            lbls->push_back(labeled_literal(m,lits[i].get()));
+        }
+        RETURN_Z3(reinterpret_cast<Z3_literals>(lbls));        
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_del_literals(Z3_context c, Z3_literals lbls) {
+        Z3_TRY;
+        LOG_Z3_del_literals(c, lbls);
+        RESET_ERROR_CODE();
+        dealloc(reinterpret_cast<labels*>(lbls));
+        Z3_CATCH;
+    }
+
+    unsigned Z3_API Z3_get_num_literals(Z3_context c,Z3_literals lbls) {
+        Z3_TRY;
+        LOG_Z3_get_num_literals(c, lbls);
+        RESET_ERROR_CODE();
+        return reinterpret_cast<labels*>(lbls)->size();   
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_symbol Z3_API Z3_get_label_symbol(Z3_context c,Z3_literals lbls, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_get_label_symbol(c, lbls, idx);
+        RESET_ERROR_CODE();
+        return of_symbol((*reinterpret_cast<labels*>(lbls))[idx].get_label());        
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_get_literal(Z3_context c,Z3_literals lbls, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_get_literal(c, lbls, idx);
+        RESET_ERROR_CODE();
+        expr* e = (*reinterpret_cast<labels*>(lbls))[idx].get_literal();
+        mk_c(c)->save_ast_trail(e);
+        RETURN_Z3(of_ast(e));
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_disable_literal(Z3_context c, Z3_literals lbls, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_disable_literal(c, lbls, idx);
+        RESET_ERROR_CODE();
+        (*reinterpret_cast<labels*>(lbls))[idx].disable(); 
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_block_literals(Z3_context c, Z3_literals lbls) {
+        Z3_TRY;
+        LOG_Z3_block_literals(c, lbls);
+        RESET_ERROR_CODE();
+        labels* _lbls = reinterpret_cast<labels*>(lbls);
+        ast_manager& m = mk_c(c)->m();
+        expr_ref_vector lits(m);
+        for (unsigned i = 0; i < _lbls->size(); ++i) {
+            if ((*_lbls)[i].is_enabled()) {
+                lits.push_back(m.mk_not((*_lbls)[i].get_literal()));
+            }
+        }
+        expr_ref clause(m);
+        clause = m.mk_or(lits.size(), lits.c_ptr());
+        mk_c(c)->save_ast_trail(clause.get());
+        mk_c(c)->assert_cnstr(clause.get());
+        Z3_CATCH;
+    }
+
+    char const * Z3_API Z3_context_to_string(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_context_to_string(c);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        mk_c(c)->get_solver().display(buffer);
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_API Z3_get_context_assignment(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_get_context_assignment(c);
+        RESET_ERROR_CODE();
+        ast_manager& m = mk_c(c)->m();
+        expr_ref result(m);
+        expr_ref_vector assignment(m);
+        mk_c(c)->get_solver().get_assignments(assignment);
+        result = mk_c(c)->mk_and(assignment.size(), assignment.c_ptr());
+        RETURN_Z3(of_ast(result.get()));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_string Z3_API Z3_statistics_to_string(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_statistics_to_string(c);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        mk_c(c)->get_solver().display_statistics(buffer);
+        memory::display_max_usage(buffer);
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_soft_check_cancel(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_soft_check_cancel(c);
+        RESET_ERROR_CODE();
+        mk_c(c)->interrupt();
+        Z3_CATCH;
+    }
+
+};
+
+void Z3_display_statistics(Z3_context c, std::ostream& s) {
+    mk_c(c)->get_solver().display_statistics(s);
+}
+
+void Z3_display_istatistics(Z3_context c, std::ostream& s) {
+    mk_c(c)->get_solver().display_istatistics(s);
+}
+    

src/api/api_stats.cpp

@@ -0,0 +1,133 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_stats.cpp
+
+Abstract:
+    API for browsing statistics
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-07.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_stats.h"
+
+extern "C" {
+
+    Z3_string Z3_API Z3_stats_to_string(Z3_context c, Z3_stats s) {
+        Z3_TRY;
+        LOG_Z3_stats_to_string(c, s);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        to_stats_ref(s).display_smt2(buffer);
+        std::string result = buffer.str();
+        // Hack for removing the trailing '\n'
+        result = buffer.str();
+        SASSERT(result.size() > 0);
+        result.resize(result.size()-1);
+        return mk_c(c)->mk_external_string(result);
+        Z3_CATCH_RETURN("");
+    }
+
+    void Z3_API Z3_stats_inc_ref(Z3_context c, Z3_stats s) {
+        Z3_TRY;
+        LOG_Z3_stats_inc_ref(c, s);
+        RESET_ERROR_CODE();
+        to_stats(s)->inc_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_stats_dec_ref(Z3_context c, Z3_stats s) {
+        Z3_TRY;
+        LOG_Z3_stats_dec_ref(c, s);
+        RESET_ERROR_CODE();
+        to_stats(s)->dec_ref();
+        Z3_CATCH;
+    }
+    
+    unsigned Z3_API Z3_stats_size(Z3_context c, Z3_stats s) {
+        Z3_TRY;
+        LOG_Z3_stats_size(c, s);
+        RESET_ERROR_CODE();
+        return to_stats_ref(s).size();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_string Z3_API Z3_stats_get_key(Z3_context c, Z3_stats s, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_stats_get_key(c, s, idx);
+        RESET_ERROR_CODE();
+        if (idx >= to_stats_ref(s).size()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return "";
+        }
+        return to_stats_ref(s).get_key(idx);
+        Z3_CATCH_RETURN("");
+    }
+
+    Z3_bool Z3_API Z3_stats_is_uint(Z3_context c, Z3_stats s, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_stats_is_uint(c, s, idx);
+        RESET_ERROR_CODE();
+        if (idx >= to_stats_ref(s).size()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return Z3_FALSE;
+        }
+        return to_stats_ref(s).is_uint(idx);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_bool Z3_API Z3_stats_is_double(Z3_context c, Z3_stats s, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_stats_is_double(c, s, idx);
+        RESET_ERROR_CODE();
+        if (idx >= to_stats_ref(s).size()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return Z3_FALSE;
+        }
+        return !to_stats_ref(s).is_uint(idx);
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+    
+    unsigned Z3_API Z3_stats_get_uint_value(Z3_context c, Z3_stats s, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_stats_get_uint_value(c, s, idx);
+        RESET_ERROR_CODE();
+        if (idx >= to_stats_ref(s).size()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return 0;
+        }
+        if (!to_stats_ref(s).is_uint(idx)) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return 0;
+        }
+        return to_stats_ref(s).get_uint_value(idx);
+        Z3_CATCH_RETURN(0);
+    }
+
+    double Z3_API Z3_stats_get_double_value(Z3_context c, Z3_stats s, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_stats_get_double_value(c, s, idx);
+        RESET_ERROR_CODE();
+        if (idx >= to_stats_ref(s).size()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return 0.0;
+        }
+        if (to_stats_ref(s).is_uint(idx)) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return 0.0;
+        }
+        return to_stats_ref(s).get_double_value(idx);
+        Z3_CATCH_RETURN(0.0);
+    }
+
+};

src/api/api_stats.h

@@ -0,0 +1,33 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_stats.h
+
+Abstract:
+    API for Z3 statistics
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-07.
+
+Revision History:
+
+--*/
+#ifndef _API_STATS_H_
+#define _API_STATS_H_
+
+#include"api_util.h"
+#include"statistics.h"
+
+struct Z3_stats_ref : public api::object {
+    statistics m_stats;
+    virtual ~Z3_stats_ref() {}
+};
+
+inline Z3_stats_ref * to_stats(Z3_stats s) { return reinterpret_cast<Z3_stats_ref *>(s); }
+inline Z3_stats of_stats(Z3_stats_ref * s) { return reinterpret_cast<Z3_stats>(s); }
+inline statistics & to_stats_ref(Z3_stats s) { return to_stats(s)->m_stats; }
+
+#endif

src/api/api_tactic.cpp

@@ -0,0 +1,528 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_tactic.cpp
+
+Abstract:
+    API for creating tactics and probes
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-06.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_tactic.h"
+#include"api_model.h"
+#include"scoped_ctrl_c.h"
+#include"cancel_eh.h"
+#include"scoped_timer.h"
+
+Z3_apply_result_ref::Z3_apply_result_ref(ast_manager & m):m_core(m) {
+}
+
+extern "C" {
+
+#define RETURN_TACTIC(_t_) {                            \
+    Z3_tactic_ref * _ref_ = alloc(Z3_tactic_ref);       \
+    _ref_->m_tactic   = _t_;                            \
+    mk_c(c)->save_object(_ref_);                        \
+    Z3_tactic _result_  = of_tactic(_ref_);             \
+    RETURN_Z3(_result_);                                \
+}
+
+#define RETURN_PROBE(_t_) {                     \
+    Z3_probe_ref * _ref_ = alloc(Z3_probe_ref); \
+    _ref_->m_probe   = _t_;                     \
+    mk_c(c)->save_object(_ref_);                \
+    Z3_probe _result_  = of_probe(_ref_);       \
+    RETURN_Z3(_result_);                        \
+}
+
+    Z3_tactic Z3_API Z3_mk_tactic(Z3_context c, Z3_string name) {
+        Z3_TRY;
+        LOG_Z3_mk_tactic(c, name);
+        RESET_ERROR_CODE();
+        tactic_cmd * t = mk_c(c)->find_tactic_cmd(symbol(name));
+        if (t == 0) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        tactic * new_t = t->mk(mk_c(c)->m());
+        RETURN_TACTIC(new_t);
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_tactic_inc_ref(Z3_context c, Z3_tactic t) {
+        Z3_TRY;
+        LOG_Z3_tactic_inc_ref(c, t);
+        RESET_ERROR_CODE();
+        to_tactic(t)->inc_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_tactic_dec_ref(Z3_context c, Z3_tactic t) {
+        Z3_TRY;
+        LOG_Z3_tactic_dec_ref(c, t);
+        RESET_ERROR_CODE();
+        to_tactic(t)->dec_ref();
+        Z3_CATCH;
+    }
+
+    Z3_probe Z3_API Z3_mk_probe(Z3_context c, Z3_string name) {
+        Z3_TRY;
+        LOG_Z3_mk_probe(c, name);
+        RESET_ERROR_CODE();
+        probe_info * p = mk_c(c)->find_probe(symbol(name));
+        if (p == 0) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            RETURN_Z3(0);
+        }
+        probe * new_p = p->get();
+        RETURN_PROBE(new_p);
+        Z3_CATCH_RETURN(0);
+    }
+
+    void Z3_API Z3_probe_inc_ref(Z3_context c, Z3_probe p) {
+        Z3_TRY;
+        LOG_Z3_probe_inc_ref(c, p);
+        RESET_ERROR_CODE();
+        to_probe(p)->inc_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_probe_dec_ref(Z3_context c, Z3_probe p) {
+        Z3_TRY;
+        LOG_Z3_probe_dec_ref(c, p);
+        RESET_ERROR_CODE();
+        to_probe(p)->dec_ref();
+        Z3_CATCH;
+    }
+
+    Z3_tactic Z3_API Z3_tactic_and_then(Z3_context c, Z3_tactic t1, Z3_tactic t2) {
+        Z3_TRY;
+        LOG_Z3_tactic_and_then(c, t1, t2);
+        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_tactic Z3_API Z3_tactic_or_else(Z3_context c, Z3_tactic t1, Z3_tactic t2) {
+        Z3_TRY;
+        LOG_Z3_tactic_or_else(c, t1, t2);
+        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_tactic Z3_API Z3_tactic_par_or(Z3_context c, unsigned num, Z3_tactic const ts[]) {
+        Z3_TRY;
+        LOG_Z3_tactic_par_or(c, num, ts);
+        RESET_ERROR_CODE();
+        ptr_buffer<tactic> _ts;
+        for (unsigned i = 0; i < num; i++) {
+            _ts.push_back(to_tactic_ref(ts[i]));
+        }
+        tactic * new_t = par(num, _ts.c_ptr());
+        RETURN_TACTIC(new_t);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_tactic Z3_API Z3_tactic_par_and_then(Z3_context c, Z3_tactic t1, Z3_tactic t2) {
+        Z3_TRY;
+        LOG_Z3_tactic_par_and_then(c, t1, t2);
+        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_tactic Z3_API Z3_tactic_try_for(Z3_context c, Z3_tactic t, unsigned ms) {
+        Z3_TRY;
+        LOG_Z3_tactic_try_for(c, t, ms);
+        RESET_ERROR_CODE();
+        tactic * new_t = try_for(to_tactic_ref(t), ms);
+        RETURN_TACTIC(new_t);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_tactic Z3_API Z3_tactic_when(Z3_context c, Z3_probe p, Z3_tactic t) {
+        Z3_TRY;
+        LOG_Z3_tactic_when(c, p, t);
+        RESET_ERROR_CODE();
+        tactic * new_t = when(to_probe_ref(p), to_tactic_ref(t));
+        RETURN_TACTIC(new_t);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_tactic Z3_API Z3_tactic_cond(Z3_context c, Z3_probe p, Z3_tactic t1, Z3_tactic t2) {
+        Z3_TRY;
+        LOG_Z3_tactic_cond(c, p, t1, t2);
+        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_tactic Z3_API Z3_tactic_repeat(Z3_context c, Z3_tactic t, unsigned max) {
+        Z3_TRY;
+        LOG_Z3_tactic_repeat(c, t, max);
+        RESET_ERROR_CODE();
+        tactic * new_t = repeat(to_tactic_ref(t), max);
+        RETURN_TACTIC(new_t);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_tactic Z3_API Z3_tactic_skip(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_tactic_skip(c);
+        RESET_ERROR_CODE();
+        tactic * new_t = mk_skip_tactic();
+        RETURN_TACTIC(new_t);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_tactic Z3_API Z3_tactic_fail(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_tactic_fail(c);
+        RESET_ERROR_CODE();
+        tactic * new_t = mk_fail_tactic();
+        RETURN_TACTIC(new_t);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_tactic Z3_API Z3_tactic_fail_if(Z3_context c, Z3_probe p) {
+        Z3_TRY;
+        LOG_Z3_tactic_fail_if(c, p);
+        RESET_ERROR_CODE();
+        tactic * new_t = fail_if(to_probe_ref(p));
+        RETURN_TACTIC(new_t);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_tactic Z3_API Z3_tactic_fail_if_not_decided(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_tactic_fail_if_not_decided(c);
+        RESET_ERROR_CODE();
+        tactic * new_t = mk_fail_if_undecided_tactic();
+        RETURN_TACTIC(new_t);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_tactic Z3_API Z3_tactic_using_params(Z3_context c, Z3_tactic t, Z3_params p) {
+        Z3_TRY;
+        LOG_Z3_tactic_using_params(c, t, p);
+        RESET_ERROR_CODE();
+        tactic * new_t = using_params(to_tactic_ref(t), to_param_ref(p));
+        RETURN_TACTIC(new_t);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_probe Z3_API Z3_probe_const(Z3_context c, double val) {
+        Z3_TRY;
+        LOG_Z3_probe_const(c, val);
+        RESET_ERROR_CODE();
+        probe * new_p = mk_const_probe(val);
+        RETURN_PROBE(new_p);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_probe Z3_API Z3_probe_lt(Z3_context c, Z3_probe p1, Z3_probe p2) {
+        Z3_TRY;
+        LOG_Z3_probe_lt(c, p1, p2);
+        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_probe Z3_API Z3_probe_gt(Z3_context c, Z3_probe p1, Z3_probe p2) {
+        Z3_TRY;
+        LOG_Z3_probe_gt(c, p1, p2);
+        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_probe Z3_API Z3_probe_le(Z3_context c, Z3_probe p1, Z3_probe p2) {
+        Z3_TRY;
+        LOG_Z3_probe_le(c, p1, p2);
+        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_probe Z3_API Z3_probe_ge(Z3_context c, Z3_probe p1, Z3_probe p2) {
+        Z3_TRY;
+        LOG_Z3_probe_ge(c, p1, p2);
+        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_probe Z3_API Z3_probe_eq(Z3_context c, Z3_probe p1, Z3_probe p2) {
+        Z3_TRY;
+        LOG_Z3_probe_eq(c, p1, p2);
+        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_probe Z3_API Z3_probe_and(Z3_context c, Z3_probe p1, Z3_probe p2) {
+        Z3_TRY;
+        LOG_Z3_probe_and(c, p1, p2);
+        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_probe Z3_API Z3_probe_or(Z3_context c, Z3_probe p1, Z3_probe p2) {
+        Z3_TRY;
+        LOG_Z3_probe_or(c, p1, p2);
+        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_probe Z3_API Z3_probe_not(Z3_context c, Z3_probe p) {
+        Z3_TRY;
+        LOG_Z3_probe_not(c, p);
+        RESET_ERROR_CODE();
+        probe * new_p = mk_not(to_probe_ref(p));
+        RETURN_PROBE(new_p);
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_API Z3_get_num_tactics(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_get_num_tactics(c);
+        RESET_ERROR_CODE();
+        return mk_c(c)->num_tactics();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_string Z3_API Z3_get_tactic_name(Z3_context c, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_get_tactic_name(c, idx);
+        RESET_ERROR_CODE();
+        if (idx >= mk_c(c)->num_tactics()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return "";
+        }
+        return mk_c(c)->get_tactic(idx)->get_name().bare_str();
+        Z3_CATCH_RETURN("");
+    }
+
+    unsigned Z3_API Z3_get_num_probes(Z3_context c) {
+        Z3_TRY;
+        LOG_Z3_get_num_probes(c);
+        RESET_ERROR_CODE();
+        return mk_c(c)->num_probes();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_string Z3_API Z3_get_probe_name(Z3_context c, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_get_probe_name(c, idx);
+        RESET_ERROR_CODE();
+        if (idx >= mk_c(c)->num_probes()) {
+            SET_ERROR_CODE(Z3_IOB);
+            return "";
+        }
+        return mk_c(c)->get_probe(idx)->get_name().bare_str();
+        Z3_CATCH_RETURN("");
+    }
+
+    Z3_string Z3_API Z3_tactic_get_help(Z3_context c, Z3_tactic t) {
+        Z3_TRY;
+        LOG_Z3_tactic_get_help(c, t);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        param_descrs descrs;
+        to_tactic_ref(t)->collect_param_descrs(descrs);
+        descrs.display(buffer);
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN("");
+    }
+
+    Z3_param_descrs Z3_API Z3_tactic_get_param_descrs(Z3_context c, Z3_tactic t) {
+        Z3_TRY;
+        LOG_Z3_tactic_get_param_descrs(c, t);
+        RESET_ERROR_CODE();
+        Z3_param_descrs_ref * d = alloc(Z3_param_descrs_ref);
+        mk_c(c)->save_object(d);
+        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_string Z3_API Z3_tactic_get_descr(Z3_context c, Z3_string name) {
+        Z3_TRY;
+        LOG_Z3_tactic_get_descr(c, name);
+        RESET_ERROR_CODE();
+        tactic_cmd * t = mk_c(c)->find_tactic_cmd(symbol(name));
+        if (t == 0) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return "";
+        }
+        return t->get_descr();
+        Z3_CATCH_RETURN("");
+    }
+    
+    Z3_string Z3_API Z3_probe_get_descr(Z3_context c, Z3_string name) {
+        Z3_TRY;
+        LOG_Z3_probe_get_descr(c, name);
+        RESET_ERROR_CODE();
+        probe_info * p = mk_c(c)->find_probe(symbol(name));
+        if (p == 0) {
+            SET_ERROR_CODE(Z3_INVALID_ARG);
+            return "";
+        }
+        return p->get_descr();
+        Z3_CATCH_RETURN("");
+    }
+
+    static Z3_apply_result _tactic_apply(Z3_context c, Z3_tactic t, Z3_goal g, params_ref p) {
+        goal_ref new_goal;
+        new_goal = alloc(goal, *to_goal_ref(g));
+        Z3_apply_result_ref * ref = alloc(Z3_apply_result_ref, mk_c(c)->m());
+        mk_c(c)->save_object(ref); 
+
+        unsigned timeout     = p.get_uint(":timeout", UINT_MAX);
+        bool     use_ctrl_c  = p.get_bool(":ctrl-c", false);
+        cancel_eh<tactic> eh(*to_tactic_ref(t));
+        
+        to_tactic_ref(t)->updt_params(p);
+
+        api::context::set_interruptable(*(mk_c(c)), eh);
+        {
+            scoped_ctrl_c ctrlc(eh, false, use_ctrl_c);
+            scoped_timer timer(timeout, &eh);
+            try {
+                exec(*to_tactic_ref(t), new_goal, ref->m_subgoals, ref->m_mc, ref->m_pc, ref->m_core);
+                return of_apply_result(ref);
+            }
+            catch (z3_exception & ex) {
+                mk_c(c)->handle_exception(ex);
+                return 0;
+            }
+        }
+    }
+
+    double Z3_API Z3_probe_apply(Z3_context c, Z3_probe p, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_probe_apply(c, p, g);
+        RESET_ERROR_CODE();
+        return to_probe_ref(p)->operator()(*to_goal_ref(g)).get_value();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_apply_result Z3_API Z3_tactic_apply(Z3_context c, Z3_tactic t, Z3_goal g) {
+        Z3_TRY;
+        LOG_Z3_tactic_apply(c, t, g);
+        RESET_ERROR_CODE();
+        params_ref p;
+        Z3_apply_result r = _tactic_apply(c, t, g, p);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_apply_result Z3_API Z3_tactic_apply_ex(Z3_context c, Z3_tactic t, Z3_goal g, Z3_params p) {
+        Z3_TRY;
+        LOG_Z3_tactic_apply_ex(c, t, g, p);
+        RESET_ERROR_CODE();
+        Z3_apply_result r = _tactic_apply(c, t, g, to_param_ref(p));
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    void Z3_API Z3_apply_result_inc_ref(Z3_context c, Z3_apply_result r) {
+        Z3_TRY;
+        LOG_Z3_apply_result_inc_ref(c, r);
+        RESET_ERROR_CODE();
+        to_apply_result(r)->inc_ref();
+        Z3_CATCH;
+    }
+
+    void Z3_API Z3_apply_result_dec_ref(Z3_context c, Z3_apply_result r) {
+        Z3_TRY;
+        LOG_Z3_apply_result_dec_ref(c, r);
+        RESET_ERROR_CODE();
+        to_apply_result(r)->dec_ref();
+        Z3_CATCH;
+    }
+    
+    Z3_string Z3_API Z3_apply_result_to_string(Z3_context c, Z3_apply_result r) {
+        Z3_TRY;
+        LOG_Z3_apply_result_to_string(c, r);
+        RESET_ERROR_CODE();
+        std::ostringstream buffer;
+        buffer << "(goals\n";
+        unsigned sz = to_apply_result(r)->m_subgoals.size();
+        for (unsigned i = 0; i < sz; i++) {
+            to_apply_result(r)->m_subgoals[i]->display(buffer);
+        }
+        buffer << ")";
+        return mk_c(c)->mk_external_string(buffer.str());
+        Z3_CATCH_RETURN("");
+    }
+    
+    unsigned Z3_API Z3_apply_result_get_num_subgoals(Z3_context c, Z3_apply_result r) {
+        Z3_TRY;
+        LOG_Z3_apply_result_get_num_subgoals(c, r);
+        RESET_ERROR_CODE();
+        return to_apply_result(r)->m_subgoals.size();
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_goal Z3_API Z3_apply_result_get_subgoal(Z3_context c, Z3_apply_result r, unsigned i) {
+        Z3_TRY;
+        LOG_Z3_apply_result_get_subgoal(c, r, i);
+        RESET_ERROR_CODE();
+        if (i > to_apply_result(r)->m_subgoals.size()) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        Z3_goal_ref * g = alloc(Z3_goal_ref);
+        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_model Z3_API Z3_apply_result_convert_model(Z3_context c, Z3_apply_result r, unsigned i, Z3_model m) {
+        Z3_TRY;
+        LOG_Z3_apply_result_convert_model(c, r, i, m);
+        RESET_ERROR_CODE();
+        if (i > to_apply_result(r)->m_subgoals.size()) {
+            SET_ERROR_CODE(Z3_IOB);
+            RETURN_Z3(0);
+        }
+        model_ref new_m = to_model_ref(m)->copy();
+        if (to_apply_result(r)->m_mc)
+            to_apply_result(r)->m_mc->operator()(new_m, i);
+        Z3_model_ref * m_ref = alloc(Z3_model_ref); 
+        m_ref->m_model = new_m;
+        mk_c(c)->save_object(m_ref);
+        RETURN_Z3(of_model(m_ref));
+        Z3_CATCH_RETURN(0);
+    }
+
+};

src/api/api_tactic.h

@@ -0,0 +1,54 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_tactic.h
+
+Abstract:
+    API for creating tactics and goals.
+    
+Author:
+
+    Leonardo de Moura (leonardo) 2012-03-06.
+
+Revision History:
+
+--*/
+#ifndef _API_TACTIC_H_
+#define _API_TACTIC_H_
+
+#include"api_goal.h"
+#include"tactical.h"
+
+struct Z3_tactic_ref : public api::object {
+    tactic_ref   m_tactic;
+    virtual ~Z3_tactic_ref() {}
+};
+
+struct Z3_probe_ref : public api::object {
+    probe_ref    m_probe;
+    virtual ~Z3_probe_ref() {}
+};
+
+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 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(); }
+
+struct Z3_apply_result_ref : public api::object {
+    goal_ref_buffer      m_subgoals;
+    model_converter_ref  m_mc;
+    proof_converter_ref  m_pc;
+    expr_dependency_ref  m_core;
+    Z3_apply_result_ref(ast_manager & m);
+    virtual ~Z3_apply_result_ref() {}
+};
+
+inline Z3_apply_result_ref * to_apply_result(Z3_apply_result g) { return reinterpret_cast<Z3_apply_result_ref *>(g); }
+inline Z3_apply_result of_apply_result(Z3_apply_result_ref * g) { return reinterpret_cast<Z3_apply_result>(g); }
+
+#endif

src/api/api_user_theory.cpp

@@ -0,0 +1,333 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    api_user_theory.cpp
+
+Abstract:
+    API for external theories
+
+Author:
+
+    Leonardo de Moura (leonardo) 2012-02-29.
+
+Revision History:
+
+--*/
+#include<iostream>
+#include"z3.h"
+#include"api_log_macros.h"
+#include"api_context.h"
+#include"api_util.h"
+#include"user_smt_theory.h"
+
+smt::user_theory * mk_t(Z3_theory t) {
+    return reinterpret_cast<smt::user_theory*>(t);
+}
+
+extern "C" {
+
+    ///////////////////////////////
+    // Theory plugin
+    // No support for logging
+
+    Z3_theory Z3_mk_theory(Z3_context c, Z3_string th_name, void * ext_data) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        if (mk_c(c)->get_solver().get_scope_level() > 0) {
+            SET_ERROR_CODE(Z3_INVALID_USAGE);
+            return 0;
+        }
+        return reinterpret_cast<Z3_theory>(mk_user_theory(mk_c(c)->get_solver(), c, ext_data, th_name));
+        Z3_CATCH_RETURN(0);
+    }
+
+    void * Z3_theory_get_ext_data(Z3_theory t) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        void * r = mk_t(t)->get_ext_data();
+        return r;
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_sort Z3_theory_mk_sort(Z3_context c, Z3_theory t, Z3_symbol s) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        sort * r = mk_t(t)->mk_sort(to_symbol(s));
+        mk_c(c)->save_ast_trail(r);
+        return of_sort(r);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_ast Z3_theory_mk_value(Z3_context c, Z3_theory t, Z3_symbol n, Z3_sort s) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        func_decl * d = mk_t(t)->mk_value_decl(to_symbol(n), to_sort(s));
+        app * r       = mk_c(c)->m().mk_const(d);
+        mk_c(c)->save_ast_trail(r);
+        return of_ast(r);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_ast Z3_theory_mk_constant(Z3_context c, Z3_theory t, Z3_symbol n, Z3_sort s) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        Z3_func_decl d = Z3_theory_mk_func_decl(c, t, n, 0, 0, s);
+        app * r        = mk_c(c)->m().mk_const(to_func_decl(d));
+        mk_c(c)->save_ast_trail(r);
+        return of_ast(r);
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_func_decl Z3_theory_mk_func_decl(Z3_context c, Z3_theory t, Z3_symbol n,
+                                        unsigned domain_size, Z3_sort const domain[],
+                                        Z3_sort range) {
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        func_decl * r = mk_t(t)->mk_func_decl(to_symbol(n), domain_size, to_sorts(domain), to_sort(range));
+        mk_c(c)->save_ast_trail(r);
+        return of_func_decl(r);
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_context Z3_theory_get_context(Z3_theory t) {
+        Z3_context c = reinterpret_cast<Z3_context>(mk_t(t)->get_ext_context());
+        RESET_ERROR_CODE();
+        return c;
+    }
+
+    void Z3_set_delete_callback(Z3_theory t, Z3_theory_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_delete_fptr(reinterpret_cast<smt::theory_callback_fptr>(f));
+        Z3_CATCH;
+    }
+
+    void Z3_set_reduce_app_callback(Z3_theory t, Z3_reduce_app_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_reduce_app_fptr(reinterpret_cast<reduce_app_fptr>(f));
+        Z3_CATCH;
+    }
+
+    void Z3_set_reduce_eq_callback(Z3_theory t, Z3_reduce_eq_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_reduce_eq_fptr(reinterpret_cast<reduce_eq_fptr>(f));
+        Z3_CATCH;
+    }
+
+    void Z3_set_reduce_distinct_callback(Z3_theory t, Z3_reduce_distinct_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t); 
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_reduce_distinct_fptr(reinterpret_cast<reduce_distinct_fptr>(f));
+        Z3_CATCH;
+    }
+
+    void Z3_set_new_app_callback(Z3_theory t, Z3_theory_ast_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY; 
+        RESET_ERROR_CODE();
+        mk_t(t)->set_new_app_fptr(reinterpret_cast<smt::theory_app_callback_fptr>(f));
+        Z3_CATCH;
+    }
+
+    void Z3_set_new_elem_callback(Z3_theory t, Z3_theory_ast_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_new_elem_fptr(reinterpret_cast<smt::theory_app_callback_fptr>(f));
+        Z3_CATCH;
+    }
+
+    void Z3_set_init_search_callback(Z3_theory t, Z3_theory_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_init_search_fptr(reinterpret_cast<smt::theory_callback_fptr>(f));
+        Z3_CATCH;
+    }
+        
+    void Z3_set_push_callback(Z3_theory t, Z3_theory_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_push_fptr(reinterpret_cast<smt::theory_callback_fptr>(f));
+        Z3_CATCH;
+    }
+ 
+    void Z3_set_pop_callback(Z3_theory t, Z3_theory_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_pop_fptr(reinterpret_cast<smt::theory_callback_fptr>(f));
+        Z3_CATCH;
+    }
+
+    void Z3_set_restart_callback(Z3_theory t, Z3_theory_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_restart_fptr(reinterpret_cast<smt::theory_callback_fptr>(f));
+        Z3_CATCH;
+    }
+
+    void Z3_set_reset_callback(Z3_theory t, Z3_theory_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_reset_fptr(reinterpret_cast<smt::theory_callback_fptr>(f));
+        Z3_CATCH;
+    }
+    
+    void Z3_set_final_check_callback(Z3_theory t, Z3_theory_final_check_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_final_check_fptr(reinterpret_cast<smt::theory_final_check_callback_fptr>(f));
+        Z3_CATCH;
+    }
+        
+    void Z3_set_new_eq_callback(Z3_theory t, Z3_theory_ast_ast_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_new_eq_fptr(reinterpret_cast<smt::theory_app_app_callback_fptr>(f));
+        Z3_CATCH;
+    }
+
+    void Z3_set_new_diseq_callback(Z3_theory t, Z3_theory_ast_ast_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_new_diseq_fptr(reinterpret_cast<smt::theory_app_app_callback_fptr>(f));
+        Z3_CATCH;
+    }
+    
+    void Z3_set_new_assignment_callback(Z3_theory t, Z3_theory_ast_bool_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_new_assignment_fptr(reinterpret_cast<smt::theory_app_bool_callback_fptr>(f));
+        Z3_CATCH;
+    }
+
+    void Z3_set_new_relevant_callback(Z3_theory t, Z3_theory_ast_callback_fptr f) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->set_new_relevant_fptr(reinterpret_cast<smt::theory_app_callback_fptr>(f));
+        Z3_CATCH;
+    }
+    
+    void Z3_theory_assert_axiom(Z3_theory t, Z3_ast ax) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->assert_axiom(to_ast(ax));
+        Z3_CATCH;
+    }
+
+    void Z3_theory_assume_eq(Z3_theory t, Z3_ast lhs, Z3_ast rhs) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        mk_t(t)->assume_eq(to_ast(lhs), to_ast(rhs));
+        Z3_CATCH;
+    }
+
+    void Z3_theory_enable_axiom_simplification(Z3_theory t, Z3_bool flag) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY; 
+        RESET_ERROR_CODE();
+        mk_t(t)->enable_axiom_simplification(flag == Z3_TRUE);
+        Z3_CATCH;
+    }
+
+    Z3_ast Z3_theory_get_eqc_root(Z3_theory t, Z3_ast n) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        return of_ast(mk_t(t)->get_root(to_ast(n)));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_theory_get_eqc_next(Z3_theory t, Z3_ast n) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        return of_ast(mk_t(t)->get_next(to_ast(n)));
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_theory_get_num_parents(Z3_theory t, Z3_ast n) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        return mk_t(t)->get_num_parents(to_ast(n));
+        Z3_CATCH_RETURN(0);
+    }
+    
+    Z3_ast Z3_theory_get_parent(Z3_theory t, Z3_ast n, unsigned i) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        return of_ast(mk_t(t)->get_parent(to_ast(n), i));
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_theory_get_num_elems(Z3_theory t) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        return mk_t(t)->get_num_asts();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_theory_get_elem(Z3_theory t, unsigned i) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        return of_ast(mk_t(t)->get_ast(i));
+        Z3_CATCH_RETURN(0);
+    }
+
+    unsigned Z3_theory_get_num_apps(Z3_theory t) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        return mk_t(t)->get_num_parents();
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_ast Z3_theory_get_app(Z3_theory t, unsigned i) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        return of_ast(mk_t(t)->get_parent(i));
+        Z3_CATCH_RETURN(0);
+    }
+
+    Z3_bool Z3_theory_is_value(Z3_theory t, Z3_ast n) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        return is_app(to_ast(n)) && mk_t(t)->get_family_id() == to_app(to_ast(n))->get_family_id();
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+    Z3_bool Z3_theory_is_decl(Z3_theory t, Z3_func_decl d) {
+        Z3_context c = Z3_theory_get_context(t);
+        Z3_TRY;
+        RESET_ERROR_CODE();
+        return mk_t(t)->get_family_id() == to_func_decl(d)->get_family_id();
+        Z3_CATCH_RETURN(Z3_FALSE);
+    }
+
+};

src/api/api_util.h

@@ -0,0 +1,150 @@
+/*++
+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:
+
+--*/
+#ifndef _API_UTIL_H_
+#define _API_UTIL_H_
+
+#include"params.h"
+#include"lbool.h"
+#include"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 CHECK_REF_COUNT(a) (reinterpret_cast<ast const*>(a)->get_ref_count() > 0)
+#define VALIDATE(a) SASSERT(!a || CHECK_REF_COUNT(a))
+
+namespace api {
+    // Generic wrapper for ref-count objects exposed by the API
+    class object {
+        unsigned m_ref_count;
+    public:
+        object():m_ref_count(0) {}
+        virtual ~object() {}
+        void inc_ref() { m_ref_count++; }
+        void dec_ref() { SASSERT(m_ref_count > 0); m_ref_count--; if (m_ref_count == 0) dealloc(this); }
+    };
+};
+
+inline ast * to_ast(Z3_ast a) { VALIDATE(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) { VALIDATE(a); return reinterpret_cast<expr*>(a); }
+inline Z3_ast of_expr(expr* e) { return reinterpret_cast<Z3_ast>(e); }
+
+inline expr * const * to_exprs(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) { VALIDATE(a); return reinterpret_cast<app*>(a); }
+inline app * to_app(Z3_ast a) { VALIDATE(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) { VALIDATE(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) { VALIDATE(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) { VALIDATE(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::mk_symbol_from_c_ptr(reinterpret_cast<void*>(s)); }
+inline Z3_symbol of_symbol(symbol s) { return reinterpret_cast<Z3_symbol>(const_cast<void*>(s.c_ptr())); }
+
+inline Z3_pattern of_pattern(ast* a) { VALIDATE(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;
+    virtual ~Z3_params_ref() {}
+};
+
+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; }
+
+struct Z3_param_descrs_ref : public api::object {
+    param_descrs m_descrs;
+    virtual ~Z3_param_descrs_ref() {}
+};
+
+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); }
+
+
+#define SKIP ((void) 0)
+
+#define MK_UNARY_BODY(NAME, FID, OP, EXTRA_CODE)                \
+    Z3_TRY;                                                     \
+    RESET_ERROR_CODE();                                         \
+    EXTRA_CODE;                                                 \
+    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;                                                 \
+    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_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(args)); \
+    mk_c(c)->save_ast_trail(a);                                         \
+    check_sorts(c, a);                                                  \
+    RETURN_Z3(of_ast(a));                                               \
+    Z3_CATCH_RETURN(0);                                                 \
+}
+
+#endif