C++ RESET_ERROR_CODE函数代码示例

 Z3_ast Z3_API Z3_algebraic_div(Z3_context c, Z3_ast a, Z3_ast b) {
     Z3_TRY;
     LOG_Z3_algebraic_div(c, a, b);
     RESET_ERROR_CODE();
     CHECK_IS_ALGEBRAIC_X(a, 0);
     CHECK_IS_ALGEBRAIC_X(b, 0);
     if ((is_rational(c, b) && get_rational(c, b).is_zero()) ||
         (!is_rational(c, b) && am(c).is_zero(get_irrational(c, b)))) {
         SET_ERROR_CODE(Z3_INVALID_ARG);
         RETURN_Z3(0);
     }
     BIN_OP(/,div);
     Z3_CATCH_RETURN(0);
 }

 Z3_ast Z3_API Z3_mk_fpa_to_sbv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz) {
     Z3_TRY;
     LOG_Z3_mk_fpa_to_sbv(c, rm, t, sz);
     RESET_ERROR_CODE();
     if (!is_rm(c, rm) || !is_fp(c, t)) {
         SET_ERROR_CODE(Z3_INVALID_ARG, "rm and float sorts expected");
         RETURN_Z3(nullptr);
     }
     api::context * ctx = mk_c(c);
     expr * a = ctx->fpautil().mk_to_sbv(to_expr(rm), to_expr(t), sz);
     ctx->save_ast_trail(a);
     RETURN_Z3(of_expr(a));
     Z3_CATCH_RETURN(nullptr);
 }

 Z3_ast Z3_API Z3_mk_fpa_to_real(Z3_context c, Z3_ast t) {
     Z3_TRY;
     LOG_Z3_mk_fpa_to_real(c, t);
     RESET_ERROR_CODE();
     if (!is_fp(c, t)) {
         SET_ERROR_CODE(Z3_INVALID_ARG, "fp sort expected");
         RETURN_Z3(nullptr);
     }
     api::context * ctx = mk_c(c);
     expr * a = ctx->fpautil().mk_to_real(to_expr(t));
     ctx->save_ast_trail(a);
     RETURN_Z3(of_expr(a));
     Z3_CATCH_RETURN(nullptr);
 }

 Z3_ast Z3_API Z3_mk_fpa_fp(Z3_context c, Z3_ast sgn, Z3_ast exp, Z3_ast sig) {
     Z3_TRY;
     LOG_Z3_mk_fpa_fp(c, sgn, exp, sig);
     RESET_ERROR_CODE();
     if (!is_bv(c, sgn) || !is_bv(c, exp) || !is_bv(c, sig)) {
         SET_ERROR_CODE(Z3_INVALID_ARG);
         RETURN_Z3(nullptr);
     }
     api::context * ctx = mk_c(c);
     expr * a = ctx->fpautil().mk_fp(to_expr(sgn), to_expr(exp), to_expr(sig));
     ctx->save_ast_trail(a);
     RETURN_Z3(of_expr(a));
     Z3_CATCH_RETURN(nullptr);
 }

 Z3_ast Z3_API Z3_mk_fpa_min(Z3_context c, Z3_ast t1, Z3_ast t2) {
     Z3_TRY;
     LOG_Z3_mk_fpa_min(c, t1, t2);
     RESET_ERROR_CODE();
     if (!is_fp(c, t1) || !is_fp(c, t2)) {
         SET_ERROR_CODE(Z3_INVALID_ARG);
         RETURN_Z3(nullptr);
     }
     api::context * ctx = mk_c(c);
     expr * a = ctx->fpautil().mk_min(to_expr(t1), to_expr(t2));
     ctx->save_ast_trail(a);
     RETURN_Z3(of_expr(a));
     Z3_CATCH_RETURN(nullptr);
 }

 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_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_smt_kernel().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);
 }

 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("");
 }

 void Z3_API Z3_add_const_interp(Z3_context c, Z3_model m, Z3_func_decl f, Z3_ast a) {
     Z3_TRY;
     LOG_Z3_add_const_interp(c, m, f, a);
     RESET_ERROR_CODE();
     func_decl* d = to_func_decl(f);
     if (!d || d->get_arity() != 0) {
         SET_ERROR_CODE(Z3_INVALID_ARG, nullptr);
     }
     else {
         model* mdl = to_model_ref(m);
         mdl->register_decl(d, to_expr(a));
     }
     Z3_CATCH;
 }

 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);
 }

 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);
 }

    Z3_ast Z3_API Z3_mk_array_default(Z3_context c, 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_func_interp Z3_API Z3_add_func_interp(Z3_context c, Z3_model m, Z3_func_decl f, Z3_ast else_val) {
     Z3_TRY;
     LOG_Z3_add_func_interp(c, m, f, else_val);
     RESET_ERROR_CODE();
     func_decl* d = to_func_decl(f);
     model* mdl = to_model_ref(m);
     Z3_func_interp_ref * f_ref = alloc(Z3_func_interp_ref, *mk_c(c), mdl); 
     f_ref->m_func_interp = alloc(func_interp, mk_c(c)->m(), d->get_arity());
     mk_c(c)->save_object(f_ref);
     mdl->register_decl(d, f_ref->m_func_interp);
     f_ref->m_func_interp->set_else(to_expr(else_val));
     RETURN_Z3(of_func_interp(f_ref));
     Z3_CATCH_RETURN(nullptr);
 }

 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();        
     CHECK_IS_EXPR(a, Z3_FALSE);
     expr* e = to_expr(a);
     return
         mk_c(c)->autil().is_numeral(e) ||
         mk_c(c)->bvutil().is_numeral(e) ||
         mk_c(c)->fpautil().is_numeral(e) ||
         mk_c(c)->fpautil().is_rm_numeral(e) ||
         mk_c(c)->datalog_util().is_numeral_ext(e);
     Z3_CATCH_RETURN(Z3_FALSE);
 }

 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);
 }