context Class Reference

A Context manages all other Z3 objects, global configuration options, etc. More...

Public Member Functions
	context ()
	context (config &c)
	~context ()
	operator Z3_context () const
Z3_error_code	check_error () const
	Auxiliary method used to check for API usage errors. More...
void	check_parser_error () const
void	set_enable_exceptions (bool f)
	The C++ API uses by defaults exceptions on errors. For applications that don't work well with exceptions (there should be only few) you have the ability to turn off exceptions. The tradeoffs are that applications have to be very careful about using check_error() after calls that may result in an erroneous state. More...
bool	enable_exceptions () const
void	set (char const *param, char const *value)
	Update global parameter param with string value. More...
void	set (char const *param, bool value)
	Update global parameter param with Boolean value. More...
void	set (char const *param, int value)
	Update global parameter param with Integer value. More...
void	interrupt ()
	Interrupt the current procedure being executed by any object managed by this context. This is a soft interruption: there is no guarantee the object will actually stop. More...
symbol	str_symbol (char const *s)
	Create a Z3 symbol based on the given string. More...
symbol	int_symbol (int n)
	Create a Z3 symbol based on the given integer. More...
sort	bool_sort ()
	Return the Boolean sort. More...
sort	int_sort ()
	Return the integer sort. More...
sort	real_sort ()
	Return the Real sort. More...
sort	bv_sort (unsigned sz)
	Return the Bit-vector sort of size sz. That is, the sort for bit-vectors of size sz. More...
sort	string_sort ()
	Return the sort for ASCII strings. More...
sort	seq_sort (sort &s)
	Return a sequence sort over base sort s. More...
sort	re_sort (sort &seq_sort)
	Return a regular expression sort over sequences seq_sort. More...
sort	array_sort (sort d, sort r)
	Return an array sort for arrays from d to r. More...
sort	array_sort (sort_vector const &d, sort r)
sort	fpa_sort (unsigned ebits, unsigned sbits)
	Return a floating point sort. ebits is a number of exponent bits, sbits is a number of significand bits,. More...
template<size_t precision>
sort	fpa_sort ()
	Return a FloatingPoint sort with given precision bitwidth (16, 32, 64 or 128). More...
sort	fpa_rounding_mode ()
	Return a RoundingMode sort. More...
void	set_rounding_mode (rounding_mode rm)
	Sets RoundingMode of FloatingPoints. More...
sort	enumeration_sort (char const *name, unsigned n, char const *const *enum_names, func_decl_vector &cs, func_decl_vector &ts)
	Return an enumeration sort: enum_names[0], ..., enum_names[n-1]. cs and ts are output parameters. The method stores in cs the constants corresponding to the enumerated elements, and in ts the predicates for testing if terms of the enumeration sort correspond to an enumeration. More...
func_decl	tuple_sort (char const *name, unsigned n, char const *const *names, sort const *sorts, func_decl_vector &projs)
	Return a tuple constructor. name is the name of the returned constructor, n are the number of arguments, names and sorts are their projected sorts. projs is an output parameter. It contains the set of projection functions. More...
sort	uninterpreted_sort (char const *name)
	create an uninterpreted sort with the name given by the string or symbol. More...
sort	uninterpreted_sort (symbol const &name)
func_decl	function (symbol const &name, unsigned arity, sort const *domain, sort const &range)
func_decl	function (char const *name, unsigned arity, sort const *domain, sort const &range)
func_decl	function (symbol const &name, sort_vector const &domain, sort const &range)
func_decl	function (char const *name, sort_vector const &domain, sort const &range)
func_decl	function (char const *name, sort const &domain, sort const &range)
func_decl	function (char const *name, sort const &d1, sort const &d2, sort const &range)
func_decl	function (char const *name, sort const &d1, sort const &d2, sort const &d3, sort const &range)
func_decl	function (char const *name, sort const &d1, sort const &d2, sort const &d3, sort const &d4, sort const &range)
func_decl	function (char const *name, sort const &d1, sort const &d2, sort const &d3, sort const &d4, sort const &d5, sort const &range)
func_decl	recfun (symbol const &name, unsigned arity, sort const *domain, sort const &range)
func_decl	recfun (char const *name, unsigned arity, sort const *domain, sort const &range)
func_decl	recfun (char const *name, sort const &domain, sort const &range)
func_decl	recfun (char const *name, sort const &d1, sort const &d2, sort const &range)
void	recdef (func_decl, expr_vector const &args, expr const &body)
expr	constant (symbol const &name, sort const &s)
expr	constant (char const *name, sort const &s)
expr	bool_const (char const *name)
expr	int_const (char const *name)
expr	real_const (char const *name)
expr	bv_const (char const *name, unsigned sz)
expr	fpa_const (char const *name, unsigned ebits, unsigned sbits)
template<size_t precision>
expr	fpa_const (char const *name)
expr	bool_val (bool b)
expr	int_val (int n)
expr	int_val (unsigned n)
expr	int_val (int64_t n)
expr	int_val (uint64_t n)
expr	int_val (char const *n)
expr	real_val (int n, int d)
expr	real_val (int n)
expr	real_val (unsigned n)
expr	real_val (int64_t n)
expr	real_val (uint64_t n)
expr	real_val (char const *n)
expr	bv_val (int n, unsigned sz)
expr	bv_val (unsigned n, unsigned sz)
expr	bv_val (int64_t n, unsigned sz)
expr	bv_val (uint64_t n, unsigned sz)
expr	bv_val (char const *n, unsigned sz)
expr	bv_val (unsigned n, bool const *bits)
expr	fpa_val (double n)
expr	fpa_val (float n)
expr	string_val (char const *s)
expr	string_val (char const *s, unsigned n)
expr	string_val (std::string const &s)
expr	num_val (int n, sort const &s)
expr_vector	parse_string (char const *s)
	parsing More...
expr_vector	parse_file (char const *file)
expr_vector	parse_string (char const *s, sort_vector const &sorts, func_decl_vector const &decls)
expr_vector	parse_file (char const *s, sort_vector const &sorts, func_decl_vector const &decls)
template<>
sort	fpa_sort ()
template<>
sort	fpa_sort ()
template<>
sort	fpa_sort ()
template<>
sort	fpa_sort ()

Friends
class	scoped_context

Detailed Description

A Context manages all other Z3 objects, global configuration options, etc.

Definition at line 155 of file z3++.h.

Constructor & Destructor Documentation

context() [1/2]

context ( )

inline

Definition at line 179 of file z3++.h.

{ config c; init(c); }

context() [2/2]

context ( config &  c )

inline

Definition at line 180 of file z3++.h.

{ init(c); }

~context()

~context ( )

inline

Definition at line 181 of file z3++.h.

{ if (m_ctx) Z3_del_context(m_ctx); }

Member Function Documentation

array_sort() [1/2]

sort array_sort ( sort  d, sort  r  )

inline

Return an array sort for arrays from d to r.

Example: Given a context c, c.array_sort(c.int_sort(), c.bool_sort()) is an array sort from integer to Boolean.

Definition at line 3029 of file z3++.h.

{ Z3_sort s = Z3_mk_array_sort(m_ctx, d, r); check_error(); return sort(*this, s); }

array_sort() [2/2]

sort array_sort ( sort_vector const &  d, sort  r  )

inline

Definition at line 3030 of file z3++.h.

                                                                {
        array<Z3_sort> dom(d);
        Z3_sort s = Z3_mk_array_sort_n(m_ctx, dom.size(), dom.ptr(), r); check_error(); return sort(*this, s);
    }

bool_const()

expr bool_const ( char const *  name )

inline

Definition at line 3174 of file z3++.h.

{ return constant(name, bool_sort()); }

bool_sort()

sort bool_sort ( )

inline

Return the Boolean sort.

Definition at line 2995 of file z3++.h.

{ Z3_sort s = Z3_mk_bool_sort(m_ctx); check_error(); return sort(*this, s); }

bool_val()

expr bool_val ( bool  b )

inline

Definition at line 3183 of file z3++.h.

Referenced by z3::implies(), z3::operator &&(), and z3::operator||().

{ return b ? expr(*this, Z3_mk_true(m_ctx)) : expr(*this, Z3_mk_false(m_ctx)); }

bv_const()

expr bv_const ( char const *  name, unsigned  sz  )

inline

Definition at line 3177 of file z3++.h.

{ return constant(name, bv_sort(sz)); }

bv_sort()

sort bv_sort ( unsigned  sz )

inline

Return the Bit-vector sort of size sz. That is, the sort for bit-vectors of size sz.

Definition at line 2998 of file z3++.h.

{ Z3_sort s = Z3_mk_bv_sort(m_ctx, sz); check_error(); return sort(*this, s); }

bv_val() [1/6]

expr bv_val ( int  n, unsigned  sz  )

inline

Definition at line 3198 of file z3++.h.

{ sort s = bv_sort(sz); Z3_ast r = Z3_mk_int(m_ctx, n, s); check_error(); return expr(*this, r); }

bv_val() [2/6]

expr bv_val ( unsigned  n, unsigned  sz  )

inline

Definition at line 3199 of file z3++.h.

{ sort s = bv_sort(sz); Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, s); check_error(); return expr(*this, r); }

bv_val() [3/6]

expr bv_val ( int64_t  n, unsigned  sz  )

inline

Definition at line 3200 of file z3++.h.

{ sort s = bv_sort(sz); Z3_ast r = Z3_mk_int64(m_ctx, n, s); check_error(); return expr(*this, r); }

bv_val() [4/6]

expr bv_val ( uint64_t  n, unsigned  sz  )

inline

Definition at line 3201 of file z3++.h.

{ sort s = bv_sort(sz); Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, s); check_error(); return expr(*this, r); }

bv_val() [5/6]

expr bv_val ( char const *  n, unsigned  sz  )

inline

Definition at line 3202 of file z3++.h.

{ sort s = bv_sort(sz); Z3_ast r = Z3_mk_numeral(m_ctx, n, s); check_error(); return expr(*this, r); }

bv_val() [6/6]

expr bv_val ( unsigned  n, bool const *  bits  )

inline

Definition at line 3203 of file z3++.h.

                                                            {
        array<bool> _bits(n);
        for (unsigned i = 0; i < n; ++i) _bits[i] = bits[i] ? 1 : 0;
        Z3_ast r = Z3_mk_bv_numeral(m_ctx, n, _bits.ptr()); check_error(); return expr(*this, r);
    }

check_error()

Z3_error_code check_error ( ) const

inline

Auxiliary method used to check for API usage errors.

Definition at line 187 of file z3++.h.

Referenced by object::check_error(), z3::concat(), z3::to_expr(), z3::to_func_decl(), and z3::to_sort().

                                          {
            Z3_error_code e = Z3_get_error_code(m_ctx);
            if (e != Z3_OK && enable_exceptions())
                Z3_THROW(exception(Z3_get_error_msg(m_ctx, e)));
            return e;
        }

check_parser_error()

void check_parser_error ( ) const

inline

Definition at line 194 of file z3++.h.

                                        {
            check_error();
        }

constant() [1/2]

expr constant ( symbol const &  name, sort const &  s  )

inline

Definition at line 3168 of file z3++.h.

                                                                     {
        Z3_ast r = Z3_mk_const(m_ctx, name, s);
        check_error();
        return expr(*this, r);
    }

constant() [2/2]

expr constant ( char const *  name, sort const &  s  )

inline

Definition at line 3173 of file z3++.h.

{ return constant(str_symbol(name), s); }

enable_exceptions()

bool enable_exceptions ( ) const

inline

Definition at line 207 of file z3++.h.

{ return m_enable_exceptions; }

enumeration_sort()

sort enumeration_sort ( char const *  name, unsigned  n, char const *const *  enum_names, func_decl_vector &  cs, func_decl_vector &  ts  )

inline

Return an enumeration sort: enum_names[0], ..., enum_names[n-1]. cs and ts are output parameters. The method stores in cs the constants corresponding to the enumerated elements, and in ts the predicates for testing if terms of the enumeration sort correspond to an enumeration.

Definition at line 3034 of file z3++.h.

                                                                                                                                                      {
        array<Z3_symbol> _enum_names(n);
        for (unsigned i = 0; i < n; i++) { _enum_names[i] = Z3_mk_string_symbol(*this, enum_names[i]); }
        array<Z3_func_decl> _cs(n);
        array<Z3_func_decl> _ts(n);
        Z3_symbol _name = Z3_mk_string_symbol(*this, name);
        sort s = to_sort(*this, Z3_mk_enumeration_sort(*this, _name, n, _enum_names.ptr(), _cs.ptr(), _ts.ptr()));
        check_error();
        for (unsigned i = 0; i < n; i++) { cs.push_back(func_decl(*this, _cs[i])); ts.push_back(func_decl(*this, _ts[i])); }
        return s;
    }

fpa_const() [1/2]

expr fpa_const ( char const *  name, unsigned  ebits, unsigned  sbits  )

inline

Definition at line 3178 of file z3++.h.

{ return constant(name, fpa_sort(ebits, sbits)); }

fpa_const() [2/2]

expr fpa_const ( char const *  name )

inline

Definition at line 3181 of file z3++.h.

{ return constant(name, fpa_sort<precision>()); }

fpa_rounding_mode()

sort fpa_rounding_mode ( )

inline

Return a RoundingMode sort.

Definition at line 3016 of file z3++.h.

Referenced by z3::operator*(), z3::operator+(), z3::operator-(), and z3::operator/().

                                           {
        switch (m_rounding_mode) {
        case RNA: return sort(*this, Z3_mk_fpa_rna(m_ctx));
        case RNE: return sort(*this, Z3_mk_fpa_rne(m_ctx));
        case RTP: return sort(*this, Z3_mk_fpa_rtp(m_ctx));
        case RTN: return sort(*this, Z3_mk_fpa_rtn(m_ctx));
        case RTZ: return sort(*this, Z3_mk_fpa_rtz(m_ctx));
        default: return sort(*this); 
        }
    }

fpa_sort() [1/6]

sort fpa_sort ( unsigned  ebits, unsigned  sbits  )

inline

Return a floating point sort. ebits is a number of exponent bits, sbits is a number of significand bits,.

Precondition

where ebits must be larger than 1 and sbits must be larger than 2.

Definition at line 3002 of file z3++.h.

{ Z3_sort s = Z3_mk_fpa_sort(m_ctx, ebits, sbits); check_error(); return sort(*this, s); }

fpa_sort() [2/6]

sort fpa_sort

(

)

Return a FloatingPoint sort with given precision bitwidth (16, 32, 64 or 128).

fpa_sort() [3/6]

sort fpa_sort ( )

inline

Definition at line 3005 of file z3++.h.

Referenced by context::fpa_sort().

{ return fpa_sort(5, 11); }

fpa_sort() [4/6]

sort fpa_sort ( )

inline

Definition at line 3008 of file z3++.h.

Referenced by context::fpa_sort().

{ return fpa_sort(8, 24); }

fpa_sort() [5/6]

sort fpa_sort ( )

inline

Definition at line 3011 of file z3++.h.

Referenced by context::fpa_sort().

{ return fpa_sort(11, 53); }

fpa_sort() [6/6]

sort fpa_sort ( )

inline

Definition at line 3014 of file z3++.h.

Referenced by context::fpa_sort().

{ return fpa_sort(15, 113); }

fpa_val() [1/2]

expr fpa_val ( double  n )

inline

Definition at line 3209 of file z3++.h.

{ sort s = fpa_sort<64>(); Z3_ast r = Z3_mk_fpa_numeral_double(m_ctx, n, s); check_error(); return expr(*this, r); }

fpa_val() [2/2]

expr fpa_val ( float  n )

inline

Definition at line 3210 of file z3++.h.

{ sort s = fpa_sort<32>(); Z3_ast r = Z3_mk_fpa_numeral_float(m_ctx, n, s); check_error(); return expr(*this, r); }

function() [1/9]

func_decl function ( symbol const &  name, unsigned  arity, sort const *  domain, sort const &  range  )

inline

Definition at line 3066 of file z3++.h.

Referenced by z3::function().

                                                                                                                   {
        array<Z3_sort> args(arity);
        for (unsigned i = 0; i < arity; i++) {
            check_context(domain[i], range);
            args[i] = domain[i];
        }
        Z3_func_decl f = Z3_mk_func_decl(m_ctx, name, arity, args.ptr(), range);
        check_error();
        return func_decl(*this, f);
    }

function() [2/9]

func_decl function ( char const *  name, unsigned  arity, sort const *  domain, sort const &  range  )

inline

Definition at line 3077 of file z3++.h.

                                                                                                                 {
        return function(range.ctx().str_symbol(name), arity, domain, range);
    }

function() [3/9]

func_decl function ( symbol const &  name, sort_vector const &  domain, sort const &  range  )

inline

Definition at line 3081 of file z3++.h.

                                                                                                       {
        array<Z3_sort> args(domain.size());
        for (unsigned i = 0; i < domain.size(); i++) {
            check_context(domain[i], range);
            args[i] = domain[i];
        }
        Z3_func_decl f = Z3_mk_func_decl(m_ctx, name, domain.size(), args.ptr(), range);
        check_error();
        return func_decl(*this, f);
    }

function() [4/9]

func_decl function ( char const *  name, sort_vector const &  domain, sort const &  range  )

inline

Definition at line 3092 of file z3++.h.

                                                                                                      {
        return function(range.ctx().str_symbol(name), domain, range);
    }

function() [5/9]

func_decl function ( char const *  name, sort const &  domain, sort const &  range  )

inline

Definition at line 3097 of file z3++.h.

                                                                                                 {
        check_context(domain, range);
        Z3_sort args[1] = { domain };
        Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 1, args, range);
        check_error();
        return func_decl(*this, f);
    }

function() [6/9]

func_decl function ( char const *  name, sort const &  d1, sort const &  d2, sort const &  range  )

inline

Definition at line 3105 of file z3++.h.

                                                                                                              {
        check_context(d1, range); check_context(d2, range);
        Z3_sort args[2] = { d1, d2 };
        Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 2, args, range);
        check_error();
        return func_decl(*this, f);
    }

function() [7/9]

func_decl function ( char const *  name, sort const &  d1, sort const &  d2, sort const &  d3, sort const &  range  )

inline

Definition at line 3113 of file z3++.h.

                                                                                                                               {
        check_context(d1, range); check_context(d2, range); check_context(d3, range);
        Z3_sort args[3] = { d1, d2, d3 };
        Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 3, args, range);
        check_error();
        return func_decl(*this, f);
    }

function() [8/9]

func_decl function ( char const *  name, sort const &  d1, sort const &  d2, sort const &  d3, sort const &  d4, sort const &  range  )

inline

Definition at line 3121 of file z3++.h.

                                                                                                                                                {
        check_context(d1, range); check_context(d2, range); check_context(d3, range); check_context(d4, range);
        Z3_sort args[4] = { d1, d2, d3, d4 };
        Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 4, args, range);
        check_error();
        return func_decl(*this, f);
    }

function() [9/9]

func_decl function ( char const *  name, sort const &  d1, sort const &  d2, sort const &  d3, sort const &  d4, sort const &  d5, sort const &  range  )

inline

Definition at line 3129 of file z3++.h.

                                                                                                                                                                 {
        check_context(d1, range); check_context(d2, range); check_context(d3, range); check_context(d4, range); check_context(d5, range);
        Z3_sort args[5] = { d1, d2, d3, d4, d5 };
        Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 5, args, range);
        check_error();
        return func_decl(*this, f);
    }

int_const()

expr int_const ( char const *  name )

inline

Definition at line 3175 of file z3++.h.

{ return constant(name, int_sort()); }

int_sort()

sort int_sort ( )

inline

Return the integer sort.

Definition at line 2996 of file z3++.h.

{ Z3_sort s = Z3_mk_int_sort(m_ctx); check_error(); return sort(*this, s); }

int_symbol()

symbol int_symbol ( int  n )

inline

Create a Z3 symbol based on the given integer.

Definition at line 2993 of file z3++.h.

{ Z3_symbol r = Z3_mk_int_symbol(m_ctx, n); check_error(); return symbol(*this, r); }

int_val() [1/5]

expr int_val ( int  n )

inline

Definition at line 3185 of file z3++.h.

Referenced by z3::abs().

{ Z3_ast r = Z3_mk_int(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }

int_val() [2/5]

expr int_val ( unsigned  n )

inline

Definition at line 3186 of file z3++.h.

{ Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }

int_val() [3/5]

expr int_val ( int64_t  n )

inline

Definition at line 3187 of file z3++.h.

{ Z3_ast r = Z3_mk_int64(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }

int_val() [4/5]

expr int_val ( uint64_t  n )

inline

Definition at line 3188 of file z3++.h.

{ Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }

int_val() [5/5]

expr int_val ( char const *  n )

inline

Definition at line 3189 of file z3++.h.

{ Z3_ast r = Z3_mk_numeral(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }

interrupt()

void interrupt ( )

inline

Interrupt the current procedure being executed by any object managed by this context. This is a soft interruption: there is no guarantee the object will actually stop.

Definition at line 229 of file z3++.h.

{ Z3_interrupt(m_ctx); }

num_val()

expr num_val ( int  n, sort const &  s  )

inline

Definition at line 3216 of file z3++.h.

Referenced by z3::ashr(), z3::lshr(), z3::mod(), z3::operator &(), z3::operator!=(), z3::operator*(), z3::operator+(), z3::operator-(), z3::operator/(), z3::operator<(), z3::operator<=(), z3::operator==(), z3::operator>(), z3::operator>=(), z3::operator^(), z3::operator|(), z3::pw(), z3::rem(), z3::select(), z3::shl(), z3::sle(), z3::slt(), z3::smod(), z3::srem(), z3::store(), z3::udiv(), z3::uge(), z3::ugt(), z3::ule(), z3::ult(), and z3::urem().

{ Z3_ast r = Z3_mk_int(m_ctx, n, s); check_error(); return expr(*this, r); }

operator Z3_context()

operator Z3_context ( ) const

inline

Definition at line 182 of file z3++.h.

{ return m_ctx; }

parse_file() [1/2]

expr_vector parse_file ( char const *  file )

inline

Definition at line 3535 of file z3++.h.

                                                        {
        Z3_ast_vector r = Z3_parse_smtlib2_file(*this, s, 0, 0, 0, 0, 0, 0);
        check_error();
        return expr_vector(*this, r);
    }

parse_file() [2/2]

expr_vector parse_file ( char const *  s, sort_vector const &  sorts, func_decl_vector const &  decls  )

inline

Definition at line 3558 of file z3++.h.

                                                                                                                 {
        array<Z3_symbol> sort_names(sorts.size());
        array<Z3_symbol> decl_names(decls.size());
        array<Z3_sort>   sorts1(sorts);
        array<Z3_func_decl> decls1(decls);
        for (unsigned i = 0; i < sorts.size(); ++i) {
            sort_names[i] = sorts[i].name();
        }
        for (unsigned i = 0; i < decls.size(); ++i) {
            decl_names[i] = decls[i].name();
        }
        Z3_ast_vector r = Z3_parse_smtlib2_file(*this, s, sorts.size(), sort_names.ptr(), sorts1.ptr(), decls.size(), decl_names.ptr(), decls1.ptr());
        check_error();
        return expr_vector(*this, r);
    }

parse_string() [1/2]

expr_vector parse_string ( char const *  s )

inline

parsing

Definition at line 3529 of file z3++.h.

                                                          {
        Z3_ast_vector r = Z3_parse_smtlib2_string(*this, s, 0, 0, 0, 0, 0, 0);
        check_error();
        return expr_vector(*this, r);

    }

parse_string() [2/2]

expr_vector parse_string ( char const *  s, sort_vector const &  sorts, func_decl_vector const &  decls  )

inline

Definition at line 3541 of file z3++.h.

                                                                                                                   {
        array<Z3_symbol> sort_names(sorts.size());
        array<Z3_symbol> decl_names(decls.size());
        array<Z3_sort>   sorts1(sorts);
        array<Z3_func_decl> decls1(decls);
        for (unsigned i = 0; i < sorts.size(); ++i) {
            sort_names[i] = sorts[i].name();
        }
        for (unsigned i = 0; i < decls.size(); ++i) {
            decl_names[i] = decls[i].name();
        }

        Z3_ast_vector r = Z3_parse_smtlib2_string(*this, s, sorts.size(), sort_names.ptr(), sorts1.ptr(), decls.size(), decl_names.ptr(), decls1.ptr());
        check_error();
        return expr_vector(*this, r);
    }

re_sort()

sort re_sort ( sort &  seq_sort )

inline

Return a regular expression sort over sequences seq_sort.

Definition at line 3001 of file z3++.h.

{ Z3_sort r = Z3_mk_re_sort(m_ctx, s); check_error(); return sort(*this, r); }

real_const()

expr real_const ( char const *  name )

inline

Definition at line 3176 of file z3++.h.

{ return constant(name, real_sort()); }

real_sort()

sort real_sort ( )

inline

Return the Real sort.

Definition at line 2997 of file z3++.h.

{ Z3_sort s = Z3_mk_real_sort(m_ctx); check_error(); return sort(*this, s); }

real_val() [1/6]

expr real_val ( int  n, int  d  )

inline

Definition at line 3191 of file z3++.h.

Referenced by z3::abs().

{ Z3_ast r = Z3_mk_real(m_ctx, n, d); check_error(); return expr(*this, r); }

real_val() [2/6]

expr real_val ( int  n )

inline

Definition at line 3192 of file z3++.h.

{ Z3_ast r = Z3_mk_int(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }

real_val() [3/6]

expr real_val ( unsigned  n )

inline

Definition at line 3193 of file z3++.h.

{ Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }

real_val() [4/6]

expr real_val ( int64_t  n )

inline

Definition at line 3194 of file z3++.h.

{ Z3_ast r = Z3_mk_int64(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }

real_val() [5/6]

expr real_val ( uint64_t  n )

inline

Definition at line 3195 of file z3++.h.

{ Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }

real_val() [6/6]

expr real_val ( char const *  n )

inline

Definition at line 3196 of file z3++.h.

{ Z3_ast r = Z3_mk_numeral(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }

recdef()

void recdef ( func_decl  f, expr_vector const &  args, expr const &  body  )

inline

Definition at line 3162 of file z3++.h.

                                                                                      {
        check_context(f, args); check_context(f, body);
        array<Z3_ast> vars(args);
        Z3_add_rec_def(f.ctx(), f, vars.size(), vars.ptr(), body);
    }

recfun() [1/4]

func_decl recfun ( symbol const &  name, unsigned  arity, sort const *  domain, sort const &  range  )

inline

Definition at line 3137 of file z3++.h.

Referenced by z3::recfun().

                                                                                                                 {
        array<Z3_sort> args(arity);
        for (unsigned i = 0; i < arity; i++) {
            check_context(domain[i], range);
            args[i] = domain[i];
        }
        Z3_func_decl f = Z3_mk_rec_func_decl(m_ctx, name, arity, args.ptr(), range);
        check_error();
        return func_decl(*this, f);

    }

recfun() [2/4]

func_decl recfun ( char const *  name, unsigned  arity, sort const *  domain, sort const &  range  )

inline

Definition at line 3149 of file z3++.h.

                                                                                                               {
        return recfun(str_symbol(name), arity, domain, range);
    }

recfun() [3/4]

func_decl recfun ( char const *  name, sort const &  domain, sort const &  range  )

inline

Definition at line 3153 of file z3++.h.

                                                                                          {
        return recfun(str_symbol(name), 1, &d1, range);
    }

recfun() [4/4]

func_decl recfun ( char const *  name, sort const &  d1, sort const &  d2, sort const &  range  )

inline

Definition at line 3157 of file z3++.h.

                                                                                                          {
        sort dom[2] = { d1, d2 };
        return recfun(str_symbol(name), 2, dom, range);
    }

seq_sort()

sort seq_sort ( sort &  s )

inline

Return a sequence sort over base sort s.

Definition at line 3000 of file z3++.h.

{ Z3_sort r = Z3_mk_seq_sort(m_ctx, s); check_error(); return sort(*this, r); }

set() [1/3]

void set ( char const *  param, char const *  value  )

inline

Update global parameter param with string value.

Definition at line 212 of file z3++.h.

{ Z3_update_param_value(m_ctx, param, value); }

set() [2/3]

void set ( char const *  param, bool  value  )

inline

Update global parameter param with Boolean value.

Definition at line 216 of file z3++.h.

{ Z3_update_param_value(m_ctx, param, value ? "true" : "false"); }

set() [3/3]

void set ( char const *  param, int  value  )

inline

Update global parameter param with Integer value.

Definition at line 220 of file z3++.h.

                                                {
            auto str = std::to_string(value);
            Z3_update_param_value(m_ctx, param, str.c_str());
        }

set_enable_exceptions()

void set_enable_exceptions ( bool  f )

inline

The C++ API uses by defaults exceptions on errors. For applications that don't work well with exceptions (there should be only few) you have the ability to turn off exceptions. The tradeoffs are that applications have to be very careful about using check_error() after calls that may result in an erroneous state.

Definition at line 205 of file z3++.h.

{ m_enable_exceptions = f; }

set_rounding_mode()

void set_rounding_mode ( rounding_mode  rm )

inline

Sets RoundingMode of FloatingPoints.

Definition at line 3027 of file z3++.h.

{ m_rounding_mode = rm; }

str_symbol()

symbol str_symbol ( char const *  s )

inline

Create a Z3 symbol based on the given string.

Definition at line 2992 of file z3++.h.

Referenced by context::function(), and solver::solver().

{ Z3_symbol r = Z3_mk_string_symbol(m_ctx, s); check_error(); return symbol(*this, r); }

string_sort()

sort string_sort ( )

inline

Return the sort for ASCII strings.

Definition at line 2999 of file z3++.h.

{ Z3_sort s = Z3_mk_string_sort(m_ctx); check_error(); return sort(*this, s); }

string_val() [1/3]

expr string_val ( char const *  s )

inline

Definition at line 3213 of file z3++.h.

{ Z3_ast r = Z3_mk_string(m_ctx, s); check_error(); return expr(*this, r); }

string_val() [2/3]

expr string_val ( char const *  s, unsigned  n  )

inline

Definition at line 3212 of file z3++.h.

{ Z3_ast r = Z3_mk_lstring(m_ctx, n, s); check_error(); return expr(*this, r); }

string_val() [3/3]

expr string_val ( std::string const &  s )

inline

Definition at line 3214 of file z3++.h.

{ Z3_ast r = Z3_mk_string(m_ctx, s.c_str()); check_error(); return expr(*this, r); }

tuple_sort()

func_decl tuple_sort ( char const *  name, unsigned  n, char const *const *  names, sort const *  sorts, func_decl_vector &  projs  )

inline

Return a tuple constructor. name is the name of the returned constructor, n are the number of arguments, names and sorts are their projected sorts. projs is an output parameter. It contains the set of projection functions.

Definition at line 3045 of file z3++.h.

                                                                                                                                               {
        array<Z3_symbol> _names(n);
        array<Z3_sort> _sorts(n);
        for (unsigned i = 0; i < n; i++) { _names[i] = Z3_mk_string_symbol(*this, names[i]); _sorts[i] = sorts[i]; }
        array<Z3_func_decl> _projs(n);
        Z3_symbol _name = Z3_mk_string_symbol(*this, name);
        Z3_func_decl tuple;
        sort _ignore_s = to_sort(*this, Z3_mk_tuple_sort(*this, _name, n, _names.ptr(), _sorts.ptr(), &tuple, _projs.ptr()));
        check_error();
        for (unsigned i = 0; i < n; i++) { projs.push_back(func_decl(*this, _projs[i])); }
        return func_decl(*this, tuple);
    }

uninterpreted_sort() [1/2]

sort uninterpreted_sort ( char const *  name )

inline

create an uninterpreted sort with the name given by the string or symbol.

Definition at line 3058 of file z3++.h.

                                                            {
        Z3_symbol _name = Z3_mk_string_symbol(*this, name);
        return to_sort(*this, Z3_mk_uninterpreted_sort(*this, _name));
    }

uninterpreted_sort() [2/2]

sort uninterpreted_sort ( symbol const &  name )

inline

Definition at line 3062 of file z3++.h.

                                                              {
        return to_sort(*this, Z3_mk_uninterpreted_sort(*this, name));
    }

Friends And Related Function Documentation

scoped_context

friend class scoped_context

friend

Definition at line 175 of file z3++.h.