mirror of
https://github.com/Z3Prover/z3
synced 2025-04-13 12:28:44 +00:00
3261 lines
99 KiB
C++
3261 lines
99 KiB
C++
/*++
|
|
Copyright (c) 2007 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Microsoft.Z3V3.cpp
|
|
|
|
Abstract:
|
|
|
|
Z3 Managed API.
|
|
|
|
Author:
|
|
|
|
Nikolaj Bjorner (nbjorner)
|
|
Leonardo de Moura (leonardo) 2007-06-8
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
|
|
//#include "stdafx.h"
|
|
#include "Microsoft.Z3V3.h"
|
|
#include "..\lib\util.h"
|
|
#include "..\lib\z3_private.h"
|
|
#include <sstream>
|
|
#include <strstream>
|
|
#include <vcclr.h>
|
|
#include "../lib/rational.h"
|
|
#include "../lib/z3_private.h"
|
|
|
|
|
|
using namespace System::Text;
|
|
using namespace Microsoft::Z3V3;
|
|
|
|
// -------------------------------
|
|
// ref_context
|
|
|
|
ref_context* ref_context::mk(Z3_context ctx, bool owned, bool scoped) {
|
|
return alloc(ref_context, ctx, owned, scoped);
|
|
}
|
|
|
|
void ref_context::dec_ref() {
|
|
--m_count;
|
|
if (0 == m_count) {
|
|
if (m_owned) {
|
|
if (m_dl) {
|
|
Z3_fixedpoint_dec_ref(m_ctx, m_dl);
|
|
}
|
|
Z3_del_context(m_ctx);
|
|
}
|
|
dealloc(this);
|
|
}
|
|
}
|
|
|
|
void ref_context::inc_ref() {
|
|
++m_count;
|
|
}
|
|
|
|
Z3_fixedpoint ref_context::dl() {
|
|
if (!m_dl) {
|
|
m_dl = Z3_mk_fixedpoint(m_ctx);
|
|
Z3_fixedpoint_inc_ref(m_ctx, m_dl);
|
|
}
|
|
return m_dl;
|
|
}
|
|
|
|
|
|
// -------------------------------
|
|
// static functions
|
|
|
|
|
|
static std::string
|
|
CreateString(
|
|
String^ string
|
|
)
|
|
{
|
|
std::string s;
|
|
array<Byte>^ bytes =
|
|
Encoding::Convert(
|
|
Encoding::Unicode,
|
|
Encoding::ASCII,
|
|
Encoding::Unicode->GetBytes(string)
|
|
);
|
|
|
|
for (int i = 0; i < bytes->Length; ++i) {
|
|
s += bytes[i];
|
|
}
|
|
return s;
|
|
}
|
|
|
|
bool Z3Log::Open(String^ filename) {
|
|
m_open = true;
|
|
return Z3_TRUE == Z3_open_log(CreateString(filename).c_str());
|
|
}
|
|
|
|
void Z3Log::Append(String^ s) {
|
|
Z3_append_log(CreateString(s).c_str());
|
|
}
|
|
|
|
void Z3Log::Close() {
|
|
m_open = false;
|
|
Z3_close_log();
|
|
}
|
|
|
|
template<class T>
|
|
class scoped_array {
|
|
public:
|
|
scoped_array(unsigned length)
|
|
: m_length(length),
|
|
m_data(new T[length])
|
|
{
|
|
}
|
|
|
|
scoped_array(array<T>^ a)
|
|
{
|
|
m_length = a?a->Length:0;
|
|
m_data = a?(new T[m_length]):0;
|
|
for (unsigned i = 0; i < m_length; ++i) {
|
|
m_data[i] = a[i];
|
|
}
|
|
}
|
|
|
|
virtual ~scoped_array() {
|
|
delete[] m_data;
|
|
}
|
|
|
|
T* c_ptr() { return m_data; }
|
|
|
|
T const* c_ptr() const { return m_data; }
|
|
|
|
T& operator[](int i) { return m_data[i]; }
|
|
|
|
unsigned size() { return m_length; }
|
|
protected:
|
|
unsigned m_length;
|
|
T* m_data;
|
|
};
|
|
|
|
template<typename T>
|
|
class scoped_Z3_ast_array : public scoped_array<T> {
|
|
public:
|
|
scoped_Z3_ast_array(array<IntPtr>^ asts)
|
|
: scoped_array((!asts)?0:asts->Length)
|
|
{
|
|
for (unsigned i = 0; i < m_length; ++i) {
|
|
c_ptr()[i] = static_cast<T>(asts[i].ToPointer());
|
|
}
|
|
}
|
|
scoped_Z3_ast_array(int length)
|
|
: scoped_array(length) {}
|
|
};
|
|
|
|
|
|
class scoped_Z3_symbol_array : public scoped_array<Z3_symbol> {
|
|
public:
|
|
scoped_Z3_symbol_array(array<Symbol^>^ symbols)
|
|
: scoped_array((!symbols)?0:symbols->Length)
|
|
{
|
|
for (unsigned i = 0; i < m_length; ++i) {
|
|
c_ptr()[i] = symbols[i]->get();
|
|
}
|
|
}
|
|
|
|
scoped_Z3_symbol_array(Z3_context ctx, array<String^>^ symbols)
|
|
: scoped_array((!symbols)?0:symbols->Length)
|
|
{
|
|
for (unsigned i = 0; i < m_length; ++i) {
|
|
c_ptr()[i] = Z3_mk_string_symbol(ctx, CreateString(symbols[i]).c_str());
|
|
}
|
|
}
|
|
|
|
scoped_Z3_symbol_array(unsigned n): scoped_array(n) {}
|
|
};
|
|
|
|
static void CopyFuncDecl(scoped_Z3_ast_array<Z3_func_decl>& src,
|
|
array<FuncDeclPtr>^ dst) {
|
|
SASSERT(dst->Length == src.size());
|
|
for (unsigned i = 0; i < src.size(); ++i) {
|
|
dst[i] = FuncDeclPtr(src[i]);
|
|
}
|
|
}
|
|
|
|
static array<TermPtr>^ MkArray(unsigned n, Z3_ast const* args) {
|
|
array<TermPtr>^ result = gcnew array<TermPtr>(n);
|
|
for (unsigned i = 0; i < n; ++i) {
|
|
result[i] = TermPtr(args[i]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static SearchFailureExplanation ConvertExplanation(Z3_search_failure f) {
|
|
switch(f) {
|
|
case Z3_NO_FAILURE:
|
|
return SearchFailureExplanation::NoFailure;
|
|
case Z3_UNKNOWN:
|
|
return SearchFailureExplanation::Unknown;
|
|
case Z3_TIMEOUT:
|
|
return SearchFailureExplanation::TimeOut;
|
|
case Z3_MEMOUT_WATERMARK:
|
|
return SearchFailureExplanation::MemOut;
|
|
case Z3_CANCELED:
|
|
return SearchFailureExplanation::UserCanceled;
|
|
case Z3_NUM_CONFLICTS:
|
|
return SearchFailureExplanation::MaxConflicts;
|
|
case Z3_THEORY:
|
|
return SearchFailureExplanation::Theory;
|
|
case Z3_QUANTIFIERS:
|
|
return SearchFailureExplanation::Quantifiers;
|
|
}
|
|
return SearchFailureExplanation::Unknown;
|
|
}
|
|
|
|
//----------------------------------------
|
|
// Config
|
|
|
|
Config::Config() { m_config = Z3_mk_config(); }
|
|
|
|
Config::~Config() {
|
|
if (m_config) {
|
|
Z3_del_config(m_config);
|
|
m_config = 0;
|
|
}
|
|
}
|
|
|
|
Config::!Config() {
|
|
if (m_config) {
|
|
if (RawContext::m_error_handler ) {
|
|
RawContext::m_error_handler->Handler(ErrorCode::NonDisposedConfig);
|
|
}
|
|
else {
|
|
verbose_stream() << "WARNING: configuration was not disposed\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Config::SetParamValue(String^ param_id, String^ param_value) {
|
|
Z3_set_param_value(m_config, CreateString(param_id).c_str(), CreateString(param_value).c_str());
|
|
}
|
|
|
|
|
|
//----------------------------------------
|
|
// Model
|
|
|
|
RawModel::~RawModel() {
|
|
Reset();
|
|
}
|
|
|
|
RawModel::!RawModel() {
|
|
if (m_model) {
|
|
if (RawContext::m_error_handler ) {
|
|
RawContext::m_error_handler->Handler(ErrorCode::NonDisposedModel);
|
|
}
|
|
else {
|
|
verbose_stream() << "WARNING: model was not disposed\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
void RawModel::Reset() {
|
|
if (m_model != 0) {
|
|
Z3_del_model(m_context(), m_model);
|
|
m_context.dec_ref();
|
|
m_model = 0;
|
|
}
|
|
}
|
|
|
|
array<FuncDeclPtr>^ RawModel::GetModelConstants() {
|
|
unsigned num_consts = Z3_get_model_num_constants(m_context(), m_model);
|
|
array<FuncDeclPtr>^ result = gcnew array<FuncDeclPtr>(num_consts);
|
|
for (unsigned i = 0; i < num_consts; ++i) {
|
|
result[i] = FuncDeclPtr(Z3_get_model_constant(m_context(), m_model, i));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
String^ RawContext::GetNumeralString(TermPtr v) {
|
|
return gcnew String(Z3_get_numeral_string(ctx(), get_ast(v)));
|
|
}
|
|
|
|
int RawContext::GetNumeralInt(TermPtr v) {
|
|
int result = 0;
|
|
if (!Z3_get_numeral_int(ctx(), get_ast(v), &result)) {
|
|
throw gcnew System::ArgumentException("Expecting value of integer type");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool RawContext::TryGetNumeralInt(TermPtr v, int% i) {
|
|
int result = 0;
|
|
if (!Z3_get_numeral_int(ctx(), get_ast(v), &result)) {
|
|
return false;
|
|
}
|
|
i = result;
|
|
return true;
|
|
}
|
|
|
|
unsigned RawContext::GetNumeralUInt(TermPtr v) {
|
|
unsigned result = 0;
|
|
if (!Z3_get_numeral_uint(ctx(), get_ast(v), &result)) {
|
|
throw gcnew System::ArgumentException("Expecting TermPtr of unsigned integer type");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool RawContext::TryGetNumeralUInt(TermPtr v, unsigned% u) {
|
|
unsigned result = 0;
|
|
if (!Z3_get_numeral_uint(ctx(), get_ast(v), &result)) {
|
|
return false;
|
|
}
|
|
u = result;
|
|
return true;
|
|
}
|
|
|
|
|
|
__int64 RawContext::GetNumeralInt64(TermPtr v) {
|
|
__int64 result = 0;
|
|
if (!Z3_get_numeral_int64(ctx(), get_ast(v), &result)) {
|
|
throw gcnew System::ArgumentException("Expecting value of signed 64 bit integer type");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool RawContext::TryGetNumeralInt64(TermPtr v, __int64% i) {
|
|
__int64 result = 0;
|
|
if (!Z3_get_numeral_int64(ctx(), get_ast(v), &result)) {
|
|
return false;
|
|
}
|
|
i = result;
|
|
return true;
|
|
}
|
|
|
|
|
|
unsigned __int64 RawContext::GetNumeralUInt64(TermPtr v) {
|
|
unsigned __int64 result = 0;
|
|
if (!Z3_get_numeral_uint64(ctx(), get_ast(v), &result)) {
|
|
throw gcnew System::ArgumentException("Expecting value of unsigned 64 bit integer type");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool RawContext::TryGetNumeralUInt64(TermPtr v, unsigned __int64% u) {
|
|
unsigned __int64 result = 0;
|
|
if (!Z3_get_numeral_uint64(ctx(), get_ast(v), &result)) {
|
|
return false;
|
|
}
|
|
u = result;
|
|
return true;
|
|
}
|
|
|
|
bool RawContext::TryGetNumeral(TermPtr v, [Out] __int64% num, [Out] __int64% den) {
|
|
__int64 _num, _den;
|
|
if (!Z3_get_numeral_rational_int64(ctx(), get_ast(v), &_num, &_den)) {
|
|
return false;
|
|
}
|
|
num = _num;
|
|
den = _den;
|
|
return true;
|
|
}
|
|
|
|
|
|
void RawContext::GetNumeral(TermPtr v, [Out] System::Numerics::BigInteger% num, [Out] System::Numerics::BigInteger% den) {
|
|
rational r;
|
|
if (!Z3_get_numeral_rational(ctx(), get_ast(v), r)) {
|
|
Z3_error_handler(Z3_INVALID_ARG);
|
|
return;
|
|
}
|
|
rational d = denominator(r);
|
|
rational n = numerator(r);
|
|
rational ten(10);
|
|
bool is_neg = false;
|
|
SASSERT(!d.is_neg());
|
|
if (n.is_neg()) {
|
|
is_neg = true;
|
|
n = -n;
|
|
}
|
|
num = 0;
|
|
System::Numerics::BigInteger mul = 1;
|
|
while (n.is_pos()) {
|
|
num += mul * mod(n,ten).get_unsigned();
|
|
n = div(n,ten);
|
|
mul *= 10;
|
|
}
|
|
if (is_neg) {
|
|
num = -num;
|
|
}
|
|
den = 0;
|
|
mul = 1;
|
|
while (d.is_pos()) {
|
|
den += mul * mod(d,ten).get_unsigned();
|
|
d = div(d,ten);
|
|
mul *= 10;
|
|
}
|
|
}
|
|
|
|
|
|
LBool RawContext::GetBoolValue(TermPtr a) {
|
|
switch (Z3_get_bool_value(ctx(), get_ast(a))) {
|
|
case Z3_L_FALSE: return LBool::False;
|
|
case Z3_L_UNDEF: return LBool::Undef;
|
|
case Z3_L_TRUE: return LBool::True;
|
|
default:
|
|
UNREACHABLE();
|
|
return LBool::Undef;
|
|
}
|
|
}
|
|
|
|
|
|
bool RawModel::TryGetArrayValue(TermPtr v, RawArrayValue^% av) {
|
|
unsigned num_entries;
|
|
if (!Z3_is_array_value(m_context(), m_model, get_ast(v), & num_entries)) {
|
|
return false;
|
|
}
|
|
scoped_Z3_ast_array<Z3_ast> _indices(num_entries);
|
|
scoped_Z3_ast_array<Z3_ast> _values(num_entries);
|
|
Z3_ast else_value;
|
|
Z3_get_array_value(m_context(), m_model, get_ast(v), num_entries, _indices.c_ptr(), _values.c_ptr(), &else_value);
|
|
av = gcnew RawArrayValue();
|
|
av->Domain = gcnew array<TermPtr>(num_entries);
|
|
av->Range = gcnew array<TermPtr>(num_entries);
|
|
av->ElseCase = TermPtr(else_value);
|
|
for (unsigned i = 0; i < num_entries; ++i) {
|
|
av->Domain[i] = TermPtr(_indices[i]);
|
|
av->Range[i] = TermPtr(_values[i]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
TermPtr RawContext::GetAssignments() {
|
|
return TermPtr(Z3_get_context_assignment(ctx()));
|
|
}
|
|
|
|
|
|
TermPtr RawContext::UpdateTerm(TermPtr t, array<TermPtr>^ new_args) {
|
|
scoped_Z3_ast_array<Z3_ast> _new_args(new_args);
|
|
return TermPtr(Z3_update_term(ctx(), get_ast(t),
|
|
_new_args.size(), _new_args.c_ptr()));
|
|
}
|
|
|
|
Dictionary<FuncDeclPtr, RawFunctionGraph^>^ RawModel::GetFunctionGraphs() {
|
|
if (m_graphs) {
|
|
return m_graphs;
|
|
}
|
|
SASSERT(m_model);
|
|
unsigned _num_funs = Z3_get_model_num_funcs(m_context(), m_model);
|
|
|
|
Dictionary<FuncDeclPtr, RawFunctionGraph^>^ graphs =
|
|
gcnew Dictionary<FuncDeclPtr, RawFunctionGraph^>();
|
|
|
|
for (unsigned i = 0; i < _num_funs; ++i) {
|
|
unsigned num_entries = Z3_get_model_func_num_entries(m_context(), m_model, i);
|
|
FuncDeclPtr decl = FuncDeclPtr(Z3_get_model_func_decl(m_context(), m_model, i));
|
|
RawFunctionGraph^ graph = gcnew RawFunctionGraph();
|
|
graphs[decl] = graph;
|
|
graph->Declaration = decl;
|
|
graph->Else = TermPtr(Z3_get_model_func_else(m_context(), m_model, i));
|
|
graph->Entries = gcnew array<RawFunctionEntry^>(num_entries);
|
|
|
|
for (unsigned j = 0; j < num_entries; ++j) {
|
|
unsigned num_args = Z3_get_model_func_entry_num_args(m_context(), m_model, i, j);
|
|
graph->Entries[j] = gcnew RawFunctionEntry();
|
|
graph->Entries[j]->Arguments = gcnew array<TermPtr>(num_args);
|
|
for (unsigned k = 0; k < num_args; ++k) {
|
|
graph->Entries[j]->Arguments[k] = TermPtr(Z3_get_model_func_entry_arg(m_context(), m_model, i, j, k));
|
|
}
|
|
graph->Entries[j]->Result = TermPtr(Z3_get_model_func_entry_value(m_context(), m_model, i, j));
|
|
}
|
|
}
|
|
m_graphs = graphs;
|
|
return graphs;
|
|
}
|
|
|
|
TermPtr RawModel::Eval(TermPtr t) {
|
|
Z3_ast v = 0;
|
|
if (!Z3_eval(m_context(), m_model, get_ast(t), &v)) {
|
|
return IntPtr::Zero;
|
|
}
|
|
return TermPtr(v);
|
|
}
|
|
|
|
TermPtr RawModel::Eval(FuncDeclPtr decl, array<TermPtr>^ args) {
|
|
Z3_ast v = 0;
|
|
scoped_Z3_ast_array<Z3_ast> _args(args);
|
|
|
|
if (!Z3_eval_decl(m_context(), m_model, get_func_decl(decl),
|
|
_args.size(), _args.c_ptr(), &v)) {
|
|
return IntPtr::Zero;
|
|
}
|
|
return TermPtr(v);
|
|
}
|
|
|
|
String^ RawModel::ToString() {
|
|
return gcnew String(Z3_model_to_string(m_context(), m_model));
|
|
}
|
|
|
|
void RawModel::Display(System::IO::TextWriter^ w) {
|
|
w->Write(ToString());
|
|
}
|
|
|
|
RawTheory^ RawContext::MkTheory(String^ name) {
|
|
return gcnew RawTheory(*m_context, name);
|
|
}
|
|
|
|
|
|
void RawContext::RegisterRelation(FuncDeclPtr r) {
|
|
Z3_fixedpoint_register_relation(ctx(), dl(), get_func_decl(r));
|
|
}
|
|
|
|
void RawContext::AddRule(TermPtr term, Symbol^ name) {
|
|
Z3_fixedpoint_add_rule(ctx(), dl(), get_ast(term), name?name->get():0);
|
|
}
|
|
|
|
LBool RawContext::Query(TermPtr query) {
|
|
switch(Z3_fixedpoint_query(ctx(), dl(), get_ast(query))) {
|
|
case Z3_L_FALSE: return LBool::False;
|
|
case Z3_L_TRUE: return LBool::True;
|
|
default: return LBool::Undef;
|
|
}
|
|
}
|
|
|
|
String^ RawContext::GetQueryStatus() {
|
|
return gcnew String(Z3_fixedpoint_get_reason_unknown(ctx(),dl()));
|
|
}
|
|
|
|
TermPtr RawContext::GetQueryAnswer() {
|
|
return TermPtr(Z3_fixedpoint_get_answer(ctx(),dl()));
|
|
}
|
|
|
|
static void fixedpoint_assign_callback(void* c, Z3_func_decl f, unsigned n, Z3_ast const* _args, unsigned m, Z3_ast const* outs) {
|
|
RawContext::fixedpoint_assign_callback(c, f, n, _args, m, outs);
|
|
}
|
|
|
|
static void fixedpoint_apply_callback(void* c, Z3_func_decl f, unsigned n, Z3_ast const* _args, Z3_ast* out) {
|
|
RawContext::fixedpoint_apply_callback(c, f, n, _args, out);
|
|
}
|
|
|
|
void RawContext::init_fixedpoint_callbacks() {
|
|
if (contexts == nullptr) {
|
|
contexts = gcnew Dictionary<GCHandle, RawContext^>();
|
|
}
|
|
if (m_fixedpoint_gch == IntPtr::Zero) {
|
|
int id = contexts->Count;
|
|
GCHandle h = GCHandle::Alloc(id, GCHandleType::Pinned);
|
|
contexts[h] = this;
|
|
m_fixedpoint_gch = GCHandle::ToIntPtr(h);
|
|
Z3_fixedpoint_init(ctx(), dl(), m_fixedpoint_gch.ToPointer());
|
|
Z3_fixedpoint_set_reduce_assign_callback(ctx(), dl(), ::fixedpoint_assign_callback);
|
|
Z3_fixedpoint_set_reduce_app_callback(ctx(), dl(), ::fixedpoint_apply_callback);
|
|
}
|
|
}
|
|
|
|
|
|
void RawContext::fixedpoint_assign_callback(void* ud, Z3_func_decl f, unsigned n, Z3_ast const* args, unsigned m, Z3_ast const* outs) {
|
|
RawContext^ ctx = contexts[GCHandle::FromIntPtr(IntPtr(ud))];
|
|
if (ctx->m_fixedpoint_assign != nullptr) {
|
|
array<TermPtr>^ _args = MkArray(n, args);
|
|
array<TermPtr>^ _outs = MkArray(m, outs);
|
|
ctx->m_fixedpoint_assign(TermPtr(f), _args, _outs);
|
|
}
|
|
}
|
|
|
|
void RawContext::fixedpoint_apply_callback(void* ud, Z3_func_decl f, unsigned n, Z3_ast const* args, Z3_ast* out) {
|
|
RawContext^ ctx = contexts[GCHandle::FromIntPtr(IntPtr(ud))];
|
|
if (ctx->m_fixedpoint_apply != nullptr) {
|
|
array<TermPtr>^ _args = MkArray(n, args);
|
|
TermPtr r = ctx->m_fixedpoint_apply(TermPtr(f), _args);
|
|
if (out) *out = get_ast(r);
|
|
}
|
|
}
|
|
|
|
String^ RawContext::FixedpointToString(array<TermPtr>^ queries) {
|
|
scoped_Z3_ast_array<Z3_ast> _queries(queries);
|
|
return gcnew String(Z3_fixedpoint_to_string(
|
|
ctx(), dl(),
|
|
_queries.size(), _queries.c_ptr()));
|
|
}
|
|
|
|
array<TermPtr>^ RawContext::SimplifyFixedpointRules(array<TermPtr>^ rules, array<FuncDeclPtr>^ output_predicates) {
|
|
scoped_Z3_ast_array<Z3_ast> _rules(rules);
|
|
scoped_Z3_ast_array<Z3_func_decl> _outputs(output_predicates);
|
|
Z3_ast_vector new_rules = Z3_fixedpoint_simplify_rules(
|
|
ctx(), dl(), _rules.size(), _rules.c_ptr(),
|
|
_outputs.size(), _outputs.c_ptr());
|
|
unsigned num_rules = Z3_ast_vector_size(ctx(), new_rules);
|
|
Z3_ast_vector_inc_ref(ctx(), new_rules);
|
|
array<TermPtr>^ result = gcnew array<TermPtr>(num_rules);
|
|
for (unsigned i = 0; i < num_rules; ++i) {
|
|
result[i] = TermPtr(Z3_ast_vector_get(ctx(), new_rules, i));
|
|
}
|
|
Z3_ast_vector_dec_ref(ctx(), new_rules);
|
|
return result;
|
|
}
|
|
|
|
//----------------------------------------
|
|
// RawContext
|
|
|
|
static void error_handler(Z3_context ctx, Z3_error_code c) {
|
|
ErrorCode code;
|
|
switch(c) {
|
|
case Z3_OK: code = ErrorCode::Ok; break;
|
|
case Z3_SORT_ERROR: code = ErrorCode::TypeError; break;
|
|
case Z3_IOB: code = ErrorCode::IndexOutOfBounds; break;
|
|
case Z3_INVALID_ARG: code = ErrorCode::InvalidArgument; break;
|
|
case Z3_PARSER_ERROR: code = ErrorCode::ParserError; break;
|
|
case Z3_NO_PARSER: code = ErrorCode::NoParser; break;
|
|
case Z3_INVALID_PATTERN: code = ErrorCode::InvalidPattern; break;
|
|
case Z3_MEMOUT_FAIL: throw gcnew OutOfMemoryException();
|
|
case Z3_INTERNAL_FATAL: code = ErrorCode::InternalFatal; break;
|
|
case Z3_INVALID_USAGE: code = ErrorCode::InvalidUsage; break;
|
|
case Z3_FILE_ACCESS_ERROR: code = ErrorCode::FileAccessError; break;
|
|
default:
|
|
UNREACHABLE();
|
|
code = ErrorCode::InvalidArgument; break;
|
|
}
|
|
if (RawContext::m_error_handler ) {
|
|
RawContext::m_error_handler->Handler(code);
|
|
}
|
|
// we throw if you don't
|
|
throw gcnew Z3Error(code);
|
|
}
|
|
|
|
|
|
// -----------------------------
|
|
// LabeledLiterals
|
|
|
|
|
|
LabeledLiterals::!LabeledLiterals() {
|
|
if (m_labels) {
|
|
if (RawContext::m_error_handler ) {
|
|
RawContext::m_error_handler->Handler(ErrorCode::NonDisposedLiterals);
|
|
}
|
|
else {
|
|
verbose_stream() << "WARNING: labeled literals have not been disposed\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
// -----------------------------
|
|
// RawTheory
|
|
|
|
void RawTheory::static_delete_callback(Z3_theory th)
|
|
{
|
|
RawTheory^ theory = GetTheory(th);
|
|
if (theory->delete_handler) {
|
|
theory->delete_handler();
|
|
}
|
|
Z3_theory_data td = Z3_theory_get_ext_data(th);
|
|
theories->Remove(GCHandle::FromIntPtr(IntPtr(td)));
|
|
GCHandle::FromIntPtr(IntPtr(td)).Free();
|
|
}
|
|
|
|
static void static_delete_callback(Z3_theory th) {
|
|
RawTheory::static_delete_callback(th);
|
|
}
|
|
|
|
RawTheory::RawTheory(ref_context& ctx, String^ name): m_context(ctx), m_name(name)
|
|
{
|
|
if (!theories) theories = gcnew Dictionary<GCHandle, RawTheory^>();
|
|
int id = theories->Count;
|
|
GCHandle h = GCHandle::Alloc(id, GCHandleType::Pinned);
|
|
theories[h] = this;
|
|
IntPtr gch = GCHandle::ToIntPtr(h);
|
|
m_theory = Z3_mk_theory(ctx(), CreateString(name).c_str(), gch.ToPointer());
|
|
m_context.inc_ref();
|
|
Z3_set_delete_callback(m_theory, ::static_delete_callback);
|
|
}
|
|
|
|
RawTheory::~RawTheory() {
|
|
m_context.dec_ref();
|
|
}
|
|
|
|
Z3_bool RawTheory::reduce_eq_callback(Z3_theory th, Z3_ast a, Z3_ast b, Z3_ast* r) {
|
|
RawTheory^ theory = GetTheory(th);
|
|
TermPtr res = theory->reduce_eq(TermPtr(a), TermPtr(b));
|
|
if (res != TermPtr::Zero) {
|
|
*r = get_ast(res);
|
|
}
|
|
return res != TermPtr::Zero;
|
|
}
|
|
|
|
static Z3_bool reduce_eq_callback(Z3_theory th, Z3_ast a, Z3_ast b, Z3_ast* r) {
|
|
return RawTheory::reduce_eq_callback(th, a, b, r);
|
|
}
|
|
|
|
void RawTheory::set_reduce_eq(Func2<TermPtr, TermPtr, TermPtr>^ value) {
|
|
reduce_eq = value;
|
|
Z3_set_reduce_eq_callback(m_theory, ::reduce_eq_callback);
|
|
}
|
|
|
|
Z3_bool RawTheory::reduce_app_callback(Z3_theory th, Z3_func_decl f, unsigned num_args, Z3_ast const args[], Z3_ast* r) {
|
|
RawTheory^ theory = GetTheory(th);
|
|
array<TermPtr>^ argv = MkArray(num_args, args);
|
|
TermPtr res = theory->reduce_app(TermPtr(f), argv);
|
|
if (r && res != TermPtr::Zero) {
|
|
*r = get_ast(res);
|
|
}
|
|
return res != TermPtr::Zero;
|
|
}
|
|
|
|
static Z3_bool reduce_app_callback(Z3_theory th, Z3_func_decl f, unsigned num_args, Z3_ast const args[], Z3_ast* r) {
|
|
return RawTheory::reduce_app_callback(th, f, num_args, args, r);
|
|
}
|
|
|
|
void RawTheory::set_reduce_app(Func2<FuncDeclPtr, array<TermPtr>^, TermPtr>^ value) {
|
|
reduce_app = value;
|
|
Z3_set_reduce_app_callback(m_theory, ::reduce_app_callback);
|
|
}
|
|
|
|
Z3_bool RawTheory::reduce_distinct_callback(Z3_theory th, unsigned n, Z3_ast const args[], Z3_ast* r) {
|
|
RawTheory^ theory = GetTheory(th);
|
|
TermPtr res = theory->reduce_distinct(MkArray(n, args));
|
|
if (r && res != TermPtr::Zero) {
|
|
*r = get_ast(res);
|
|
}
|
|
return res != TermPtr::Zero;
|
|
}
|
|
|
|
static Z3_bool reduce_distinct_callback(Z3_theory th, unsigned n, Z3_ast const args[], Z3_ast* r) {
|
|
return RawTheory::reduce_distinct_callback(th, n, args, r);
|
|
}
|
|
|
|
void RawTheory::set_reduce_distinct(Func1<array<TermPtr>^, TermPtr>^ value) {
|
|
reduce_distinct = value;
|
|
Z3_set_reduce_distinct_callback(m_theory, ::reduce_distinct_callback);
|
|
}
|
|
|
|
static void new_relevant_callback(Z3_theory t, Z3_ast a) {
|
|
RawTheory::GetTheory(t)->new_relevant(TermPtr(a));
|
|
}
|
|
|
|
void RawTheory::set_new_relevant(Action<TermPtr>^ value) {
|
|
new_relevant = value;
|
|
Z3_set_new_relevant_callback(m_theory, ::new_relevant_callback);
|
|
}
|
|
|
|
static void new_app_callback(Z3_theory t, Z3_ast a) {
|
|
RawTheory::GetTheory(t)->new_app(TermPtr(a));
|
|
}
|
|
|
|
void RawTheory::set_new_app(Action<TermPtr>^ value) {
|
|
new_app = value;
|
|
Z3_set_new_app_callback(m_theory, ::new_app_callback);
|
|
}
|
|
|
|
|
|
static void new_elem_callback(Z3_theory t, Z3_ast a) {
|
|
RawTheory::GetTheory(t)->new_elem(TermPtr(a));
|
|
}
|
|
|
|
void RawTheory::set_new_elem(Action<TermPtr>^ value) {
|
|
new_elem = value;
|
|
Z3_set_new_elem_callback(m_theory, ::new_elem_callback);
|
|
}
|
|
|
|
static void init_search_callback(Z3_theory t) {
|
|
RawTheory::GetTheory(t)->init_search();
|
|
}
|
|
|
|
void RawTheory::set_init_search(Action0^ value) {
|
|
init_search = value;
|
|
Z3_set_init_search_callback(m_theory, ::init_search_callback);
|
|
}
|
|
|
|
static void push_callback(Z3_theory t) {
|
|
RawTheory::GetTheory(t)->push();
|
|
}
|
|
|
|
void RawTheory::set_push(Action0^ value) {
|
|
push = value;
|
|
Z3_set_push_callback(m_theory, ::push_callback);
|
|
}
|
|
|
|
|
|
static void pop_callback(Z3_theory t) {
|
|
RawTheory::GetTheory(t)->pop();
|
|
}
|
|
|
|
void RawTheory::set_pop(Action0^ value) {
|
|
pop = value;
|
|
Z3_set_pop_callback(m_theory, ::pop_callback);
|
|
}
|
|
|
|
|
|
static void reset_callback(Z3_theory t) {
|
|
RawTheory::GetTheory(t)->reset();
|
|
}
|
|
|
|
void RawTheory::set_reset(Action0^ value) {
|
|
reset = value;
|
|
Z3_set_reset_callback(m_theory, ::reset_callback);
|
|
}
|
|
|
|
|
|
static void restart_callback(Z3_theory t) {
|
|
RawTheory::GetTheory(t)->restart();
|
|
}
|
|
|
|
void RawTheory::set_restart(Action0^ value) {
|
|
restart = value;
|
|
Z3_set_restart_callback(m_theory, ::restart_callback);
|
|
}
|
|
|
|
|
|
static Z3_bool final_check_callback(Z3_theory t) {
|
|
return RawTheory::GetTheory(t)->final_check();
|
|
}
|
|
|
|
void RawTheory::set_final_check(Func0<bool>^ value) {
|
|
final_check = value;
|
|
Z3_set_final_check_callback(m_theory, ::final_check_callback);
|
|
}
|
|
|
|
static void new_eq_callback(Z3_theory t, Z3_ast a, Z3_ast b) {
|
|
RawTheory::GetTheory(t)->new_eq(TermPtr(a), TermPtr(b));
|
|
}
|
|
|
|
void RawTheory::set_new_eq(Action2<TermPtr, TermPtr>^ value) {
|
|
new_eq = value;
|
|
Z3_set_new_eq_callback(m_theory, ::new_eq_callback);
|
|
}
|
|
|
|
|
|
static void new_diseq_callback(Z3_theory t, Z3_ast a, Z3_ast b) {
|
|
RawTheory::GetTheory(t)->new_diseq(TermPtr(a), TermPtr(b));
|
|
}
|
|
|
|
void RawTheory::set_new_diseq(Action2<TermPtr, TermPtr>^ value) {
|
|
new_diseq = value;
|
|
Z3_set_new_diseq_callback(m_theory, ::new_diseq_callback);
|
|
}
|
|
|
|
static void new_assignment_callback(Z3_theory t, Z3_ast a, Z3_bool b)
|
|
{
|
|
RawTheory::GetTheory(t)->new_assignment(TermPtr(a), b?true:false);
|
|
}
|
|
|
|
void RawTheory::set_new_assignment(Action2<TermPtr, bool>^ value) {
|
|
new_assignment = value;
|
|
Z3_set_new_assignment_callback(m_theory, ::new_assignment_callback);
|
|
}
|
|
|
|
FuncDeclPtr RawTheory::MkFuncDecl(Symbol^ n, array<SortPtr>^ domain, SortPtr range) {
|
|
scoped_Z3_ast_array<Z3_sort> _domain(domain);
|
|
return FuncDeclPtr(Z3_theory_mk_func_decl(m_context(), m_theory, n->get(),
|
|
_domain.size(), _domain.c_ptr(), get_sort(range)));
|
|
}
|
|
|
|
|
|
SortPtr RawTheory::MkSort(String^ s) {
|
|
return SortPtr(Z3_theory_mk_sort(m_context(), m_theory, Z3_mk_string_symbol(m_context(), CreateString(s).c_str())));
|
|
}
|
|
|
|
TermPtr RawTheory::MkValue(String^ s, SortPtr srt) {
|
|
Z3_symbol sym = Z3_mk_string_symbol(m_context(), CreateString(s).c_str());
|
|
return TermPtr(Z3_theory_mk_value(m_context(), m_theory, sym, get_sort(srt)));
|
|
}
|
|
|
|
TermPtr RawTheory::MkConstant(String^ s, SortPtr srt) {
|
|
Z3_symbol sym = Z3_mk_string_symbol(m_context(), CreateString(s).c_str());
|
|
return TermPtr(Z3_theory_mk_constant(m_context(), m_theory, sym, get_sort(srt)));
|
|
}
|
|
|
|
FuncDeclPtr RawTheory::MkFuncDecl(String^ s, array<SortPtr>^ domain, SortPtr range) {
|
|
Z3_symbol sym = Z3_mk_string_symbol(m_context(), CreateString(s).c_str());
|
|
scoped_Z3_ast_array<Z3_sort> _domain(domain);
|
|
return FuncDeclPtr(Z3_theory_mk_func_decl(m_context(), m_theory, sym,
|
|
_domain.size(), _domain.c_ptr(), get_sort(range)));
|
|
|
|
}
|
|
|
|
|
|
// -----------------------------
|
|
// Constructor
|
|
|
|
Constructor::Constructor(
|
|
ref_context& context,
|
|
String^ name,
|
|
String^ tester,
|
|
array<String^>^ field_names,
|
|
array<SortPtr>^ field_sorts,
|
|
array<unsigned>^ field_refs
|
|
):
|
|
m_context(context),
|
|
m_constructor(0),
|
|
m_name(name),
|
|
m_tester_name(tester),
|
|
m_field_names(field_names),
|
|
m_field_sorts(field_sorts),
|
|
m_field_refs(field_refs),
|
|
m_constructor_decl(FuncDeclPtr()),
|
|
m_tester(FuncDeclPtr()),
|
|
m_accessors(nullptr)
|
|
{
|
|
m_context.inc_ref();
|
|
}
|
|
|
|
|
|
Z3_constructor Constructor::Get()
|
|
{
|
|
if (m_constructor) {
|
|
return m_constructor;
|
|
}
|
|
Z3_symbol _name = Z3_mk_string_symbol(m_context(), CreateString(m_name).c_str());
|
|
Z3_symbol _tester = Z3_mk_string_symbol(m_context(), CreateString(m_tester_name).c_str());
|
|
unsigned num_fields = (!m_field_names)?0:m_field_names->Length;
|
|
scoped_Z3_symbol_array _field_names(m_context(), m_field_names);
|
|
scoped_Z3_ast_array<Z3_sort> _field_sorts(m_field_sorts);
|
|
scoped_array<unsigned> _field_refs(m_field_refs);
|
|
SASSERT(_field_names.size() == _field_sorts.size());
|
|
SASSERT(_field_names.size() == _field_refs.size());
|
|
m_constructor = Z3_mk_constructor(m_context(), _name, _tester, num_fields,
|
|
_field_names.c_ptr(), _field_sorts.c_ptr(), _field_refs.c_ptr());
|
|
return m_constructor;
|
|
}
|
|
|
|
Z3_constructor Constructor::Query() {
|
|
Z3_constructor result = 0;
|
|
if (!m_accessors) {
|
|
SASSERT(m_constructor);
|
|
result = m_constructor;
|
|
unsigned num_fields = (!m_field_names)?0:m_field_names->Length;
|
|
m_accessors = gcnew array<FuncDeclPtr>(num_fields);
|
|
Z3_func_decl constructor_decl, tester_decl;
|
|
scoped_array<Z3_func_decl> accs(num_fields);
|
|
Z3_query_constructor(m_context(),
|
|
m_constructor,
|
|
num_fields,
|
|
&constructor_decl,
|
|
&tester_decl,
|
|
accs.c_ptr());
|
|
m_constructor_decl = FuncDeclPtr(constructor_decl);
|
|
m_tester = FuncDeclPtr(tester_decl);
|
|
for (unsigned i = 0; i < num_fields; ++i) {
|
|
m_accessors[i] = FuncDeclPtr(accs[i]);
|
|
}
|
|
m_constructor = 0;
|
|
}
|
|
SASSERT(!m_constructor);
|
|
return result;
|
|
}
|
|
|
|
Constructor::!Constructor() {
|
|
SASSERT(!m_constructor);
|
|
}
|
|
|
|
|
|
Constructor::~Constructor() {
|
|
SASSERT(!m_constructor);
|
|
m_context.dec_ref();
|
|
}
|
|
|
|
|
|
FuncDeclPtr Constructor::GetConstructor() {
|
|
if (!m_constructor && !m_accessors) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidUsage);
|
|
}
|
|
Z3_constructor c = Query();
|
|
SASSERT(!c);
|
|
return FuncDeclPtr(m_constructor_decl);
|
|
}
|
|
|
|
FuncDeclPtr Constructor::GetTester() {
|
|
if (!m_constructor && !m_accessors) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidUsage);
|
|
}
|
|
Z3_constructor c = Query();
|
|
SASSERT(!c);
|
|
return FuncDeclPtr(m_tester);
|
|
}
|
|
|
|
array<FuncDeclPtr>^ Constructor::GetAccessors() {
|
|
if (!m_constructor && !m_accessors) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidUsage);
|
|
}
|
|
Z3_constructor c = Query();
|
|
SASSERT(!c);
|
|
return m_accessors;
|
|
}
|
|
|
|
|
|
|
|
|
|
// -----------------------------
|
|
// RawContext
|
|
|
|
|
|
void RawContext::Init() {
|
|
m_disposed = false;
|
|
s_nonempty = false;
|
|
if (s_todec == nullptr) {
|
|
s_todec = gcnew List<KeyValuePair<IntPtr, RawContext^> >();
|
|
s_monitor = gcnew IntPtr(0);
|
|
}
|
|
Z3_set_error_handler(ctx(), error_handler);
|
|
}
|
|
|
|
RawContext::RawContext(Config^ config) {
|
|
m_context = ref_context::mk(Z3_mk_context(config->get()), true, true);
|
|
Init();
|
|
}
|
|
|
|
RawContext::RawContext(Config^ config, ReferenceCounted^ rc) {
|
|
m_context = ref_context::mk(Z3_mk_context_rc(config->get()), true, false);
|
|
Init();
|
|
}
|
|
|
|
RawContext::RawContext() {
|
|
m_context = ref_context::mk(Z3_mk_context(0), true, true);
|
|
Init();
|
|
}
|
|
|
|
void RawContext::SetContext(Z3_context ctx) {
|
|
Reset();
|
|
m_context = ref_context::mk(ctx, false, true);
|
|
}
|
|
|
|
RawContext::!RawContext() {
|
|
if (!m_disposed) {
|
|
if (RawContext::m_error_handler ) {
|
|
RawContext::m_error_handler->Handler(ErrorCode::NonDisposedContext);
|
|
}
|
|
else {
|
|
verbose_stream() << "WARNING: context was not disposed\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
RawContext::Reset() {
|
|
System::Threading::Monitor::Enter(s_monitor);
|
|
if (!m_disposed) {
|
|
m_context->dec_ref();
|
|
m_disposed = true;
|
|
}
|
|
System::Threading::Monitor::Exit(s_monitor);
|
|
}
|
|
|
|
RawContext::~RawContext() {
|
|
Reset();
|
|
}
|
|
|
|
#include "..\lib\vector.h"
|
|
#include "..\lib\trace.h"
|
|
|
|
void RawContext::EnableDebugTrace(String^ tag) {
|
|
static vector<std::string*> pinned;
|
|
std::string s = CreateString(tag);
|
|
pinned.push_back(new std::string(s));
|
|
enable_trace(pinned.back()->c_str());
|
|
}
|
|
|
|
void RawContext::ToggleWarningMessages(bool enabled) {
|
|
Z3_toggle_warning_messages(enabled);
|
|
}
|
|
|
|
void RawContext::UpdateParamValue(String^ p, String^ v) {
|
|
Z3_update_param_value(ctx(), CreateString(p).c_str(), CreateString(v).c_str());
|
|
}
|
|
|
|
String^ RawContext::GetParamValue(String^ p) {
|
|
Z3_string vl = "";
|
|
if (!Z3_get_param_value(ctx(), CreateString(p).c_str(), &vl)) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidArgument);
|
|
}
|
|
return gcnew String(vl);
|
|
}
|
|
|
|
bool RawContext::SetLogic(String^ l) {
|
|
return Z3_TRUE == Z3_set_logic(ctx(), CreateString(l).c_str());
|
|
}
|
|
|
|
Symbol^ RawContext::MkSymbol(String^ s) {
|
|
return gcnew Symbol(ctx(), Z3_mk_string_symbol(ctx(), CreateString(s).c_str()));
|
|
}
|
|
Symbol^ RawContext::MkSymbol(int i) {
|
|
return gcnew Symbol(ctx(), Z3_mk_int_symbol(ctx(), i));
|
|
}
|
|
|
|
SortPtr RawContext::MkSort(Symbol^ s) {
|
|
return SortPtr(Z3_mk_uninterpreted_sort(ctx(), s->get()));
|
|
}
|
|
|
|
SortPtr RawContext::MkSort(String^ s) {
|
|
return SortPtr(Z3_mk_uninterpreted_sort(ctx(), Z3_mk_string_symbol(ctx(), CreateString(s).c_str())));
|
|
}
|
|
|
|
SortPtr RawContext::MkSort(int i) {
|
|
return SortPtr(Z3_mk_uninterpreted_sort(ctx(), Z3_mk_int_symbol(ctx(), i)));
|
|
}
|
|
|
|
SortPtr RawContext::MkBoolSort() { return SortPtr(Z3_mk_bool_sort(ctx())); }
|
|
|
|
SortPtr RawContext::MkIntSort() { return SortPtr(Z3_mk_int_sort(ctx())); }
|
|
|
|
SortPtr RawContext::MkRealSort() { return SortPtr(Z3_mk_real_sort(ctx())); }
|
|
|
|
SortPtr RawContext::MkBvSort(unsigned sz) { return SortPtr(Z3_mk_bv_sort(ctx(), sz)); }
|
|
|
|
SortPtr RawContext::MkArraySort(SortPtr domain, SortPtr range) {
|
|
return SortPtr(Z3_mk_array_sort(ctx(), get_sort(domain), get_sort(range)));
|
|
}
|
|
|
|
SortPtr RawContext::MkFiniteDomainSort(String^ s, unsigned __int64 domain_size) {
|
|
return SortPtr(Z3_mk_finite_domain_sort(ctx(), Z3_mk_string_symbol(ctx(), CreateString(s).c_str()), domain_size));
|
|
}
|
|
|
|
SortPtr RawContext::MkTupleSort(
|
|
Symbol^ mk_tuple_name,
|
|
array<Symbol^>^ field_names,
|
|
array<SortPtr>^ field_types,
|
|
FuncDeclPtr% mk_tuple_decl,
|
|
array<FuncDeclPtr>^ proj_decls
|
|
)
|
|
{
|
|
if (!field_names ||
|
|
!field_types ||
|
|
!proj_decls ||
|
|
field_names->Length != field_types->Length ||
|
|
field_names->Length != proj_decls->Length) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidArgument);
|
|
}
|
|
scoped_Z3_symbol_array syms(field_names);
|
|
scoped_Z3_ast_array<Z3_sort> types(field_types);
|
|
scoped_Z3_ast_array<Z3_func_decl> projs(field_names->Length);
|
|
Z3_func_decl decl;
|
|
|
|
Z3_sort ty =
|
|
Z3_mk_tuple_sort(
|
|
ctx(),
|
|
mk_tuple_name->get(),
|
|
syms.size(),
|
|
syms.c_ptr(),
|
|
types.c_ptr(),
|
|
&decl,
|
|
projs.c_ptr()
|
|
);
|
|
|
|
mk_tuple_decl = FuncDeclPtr(decl);
|
|
CopyFuncDecl(projs, proj_decls);
|
|
return SortPtr(ty);
|
|
}
|
|
|
|
SortPtr RawContext::MkTupleSort(
|
|
String^ mk_tuple_name,
|
|
array<String^>^ field_names,
|
|
array<SortPtr>^ field_types,
|
|
FuncDeclPtr% mk_tuple_decl,
|
|
array<FuncDeclPtr>^ proj_decls
|
|
)
|
|
{
|
|
Symbol^ tn = MkSymbol(mk_tuple_name);
|
|
array<Symbol^>^ fields = gcnew array<Symbol^>(field_names->Length);
|
|
for (int i = 0; i < fields->Length; ++i) {
|
|
fields[i] = MkSymbol(field_names[i]);
|
|
}
|
|
return MkTupleSort(tn, fields, field_types, mk_tuple_decl, proj_decls);
|
|
|
|
}
|
|
|
|
SortPtr RawContext::MkEnumerationSort(
|
|
String^ name,
|
|
array<String^>^ enum_names,
|
|
array<FuncDeclPtr>^ enum_consts,
|
|
array<FuncDeclPtr>^ enum_testers) {
|
|
|
|
Z3_symbol _name(Z3_mk_string_symbol(ctx(), CreateString(name).c_str()));
|
|
scoped_Z3_symbol_array _enum_names(ctx(), enum_names);
|
|
scoped_Z3_ast_array<Z3_func_decl> _enum_consts(enum_consts);
|
|
scoped_Z3_ast_array<Z3_func_decl> _enum_testers(enum_testers);
|
|
unsigned sz = _enum_names.size();
|
|
SASSERT(sz == _enum_consts.size());
|
|
SASSERT(sz == _enum_testers.size());
|
|
Z3_sort s = Z3_mk_enumeration_sort(ctx(), _name, sz, _enum_names.c_ptr(), _enum_consts.c_ptr(), _enum_testers.c_ptr());
|
|
CopyFuncDecl(_enum_consts, enum_consts);
|
|
CopyFuncDecl(_enum_testers, enum_testers);
|
|
return SortPtr(s);
|
|
}
|
|
|
|
SortPtr RawContext::MkListSort(
|
|
String^ name,
|
|
SortPtr elem_sort,
|
|
FuncDeclPtr% nil_decl,
|
|
FuncDeclPtr% is_nil_decl,
|
|
FuncDeclPtr% cons_decl,
|
|
FuncDeclPtr% is_cons_decl,
|
|
FuncDeclPtr% head_decl,
|
|
FuncDeclPtr% tail_decl
|
|
)
|
|
{
|
|
Z3_func_decl _nil_decl, _is_nil_decl, _cons_decl, _is_cons_decl, _head_decl, _tail_decl;
|
|
Z3_symbol _name = Z3_mk_string_symbol(ctx(), CreateString(name).c_str());
|
|
Z3_sort _elem_sort = get_sort(elem_sort);
|
|
|
|
Z3_sort s = Z3_mk_list_sort(ctx(), _name, _elem_sort,
|
|
&_nil_decl, &_is_nil_decl, &_cons_decl,
|
|
&_is_cons_decl, &_head_decl, &_tail_decl);
|
|
|
|
is_nil_decl = FuncDeclPtr(_is_nil_decl);
|
|
nil_decl = FuncDeclPtr(_nil_decl);
|
|
is_cons_decl = FuncDeclPtr(_is_cons_decl);
|
|
cons_decl = FuncDeclPtr(_cons_decl);
|
|
head_decl = FuncDeclPtr(_head_decl);
|
|
tail_decl = FuncDeclPtr(_tail_decl);
|
|
return SortPtr(s);
|
|
}
|
|
|
|
|
|
|
|
Constructor^ RawContext::MkConstructor(
|
|
String^ name,
|
|
String^ tester,
|
|
array<String^>^ field_names,
|
|
array<SortPtr>^ field_sorts,
|
|
array<unsigned>^ field_refs
|
|
)
|
|
{
|
|
|
|
int l1 = (!field_names)?0:field_names->Length;
|
|
int l2 = (!field_sorts)?0:field_sorts->Length;
|
|
int l3 = (!field_refs)?0:field_refs->Length;
|
|
if (l1 != l2 || l1 != l3) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidArgument);
|
|
}
|
|
return gcnew Constructor(*m_context, name, tester,
|
|
field_names, field_sorts, field_refs);
|
|
}
|
|
|
|
|
|
SortPtr RawContext::MkDataType(
|
|
String^ name,
|
|
array<Constructor^>^ constructors
|
|
)
|
|
{
|
|
Z3_symbol _name = Z3_mk_string_symbol(ctx(), CreateString(name).c_str());
|
|
scoped_array<Z3_constructor> _cons(constructors->Length);
|
|
for (int i = 0; i < constructors->Length; ++i) {
|
|
_cons[i] = constructors[i]->Get();
|
|
}
|
|
Z3_sort s = Z3_mk_datatype(ctx(), _name, _cons.size(), _cons.c_ptr());
|
|
for (int i = 0; i < constructors->Length; ++i) {
|
|
Z3_constructor c = constructors[i]->Query();
|
|
Z3_del_constructor(ctx(), c);
|
|
}
|
|
return SortPtr(s);
|
|
}
|
|
|
|
array<SortPtr>^ RawContext::MkDataTypes(
|
|
array<String^>^ names,
|
|
array<array<Constructor^>^>^ constructors_list
|
|
)
|
|
{
|
|
if (!names ||
|
|
!constructors_list ||
|
|
names->Length != constructors_list->Length) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidArgument);
|
|
|
|
}
|
|
unsigned num_sorts = names->Length;
|
|
scoped_array<Z3_symbol> sort_names(num_sorts);
|
|
scoped_array<Z3_constructor_list> clist(num_sorts);
|
|
scoped_array<Z3_sort> sort_sorts(num_sorts);
|
|
array<SortPtr>^ result = gcnew array<SortPtr>(num_sorts);
|
|
unsigned num_constructors = 0;
|
|
for (unsigned j = 0; j < num_sorts; ++j) {
|
|
num_constructors += constructors_list[j]->Length;
|
|
}
|
|
scoped_array<Z3_constructor> constructor_vec(num_constructors);
|
|
svector<Z3_constructor> constructors_q;
|
|
unsigned constructor_idx = 0;
|
|
|
|
for (unsigned j = 0; j < num_sorts; ++j) {
|
|
String^ name = names[j];
|
|
array<Constructor^>^ constructors = constructors_list[j];
|
|
|
|
// add sort name
|
|
Z3_symbol _name = Z3_mk_string_symbol(ctx(), CreateString(name).c_str());
|
|
sort_names[j] = _name;
|
|
|
|
// create constructor_list
|
|
scoped_array<Z3_constructor> _cons(constructors->Length);
|
|
for (int i = 0; i < constructors->Length; ++i) {
|
|
_cons[i] = constructors[i]->Get();
|
|
constructor_vec[constructor_idx++] = _cons[i];
|
|
}
|
|
Z3_constructor_list cl = Z3_mk_constructor_list(ctx(), _cons.size(), _cons.c_ptr());
|
|
clist[j] = cl;
|
|
}
|
|
Z3_mk_datatypes(ctx(), num_sorts, sort_names.c_ptr(), sort_sorts.c_ptr(), clist.c_ptr());
|
|
|
|
for (unsigned j = 0; j < num_sorts; ++j) {
|
|
Z3_del_constructor_list(ctx(), clist[j]);
|
|
result[j] = SortPtr(sort_sorts[j]);
|
|
// populate the constructors
|
|
array<Constructor^>^ constructors = constructors_list[j];
|
|
for (int i = 0; i < constructors->Length; ++i) {
|
|
constructors_q.push_back(constructors[i]->Query());
|
|
}
|
|
}
|
|
for (unsigned i = 0; i < constructors_q.size(); ++i) {
|
|
Z3_constructor c = constructors_q[i];
|
|
if (c) {
|
|
Z3_del_constructor(ctx(), c);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
FuncDeclPtr RawContext::MkFuncDecl(Symbol^ s, array<SortPtr>^ domain, SortPtr range) {
|
|
scoped_Z3_ast_array<Z3_sort> types(domain);
|
|
return FuncDeclPtr(Z3_mk_func_decl(ctx(), s->get(), types.size(), types.c_ptr(), get_sort(range)));
|
|
}
|
|
|
|
FuncDeclPtr RawContext::MkFuncDecl(String^ s, array<SortPtr>^ domain, SortPtr range) {
|
|
scoped_Z3_ast_array<Z3_sort> types(domain);
|
|
Z3_symbol sym = Z3_mk_string_symbol(ctx(), CreateString(s).c_str());
|
|
return FuncDeclPtr(Z3_mk_func_decl(ctx(), sym, types.size(), types.c_ptr(), get_sort(range)));
|
|
}
|
|
|
|
FuncDeclPtr RawContext::MkFuncDecl(Symbol^ s, SortPtr domain, SortPtr range) {
|
|
Z3_sort dom[1] = { get_sort(domain) };
|
|
return FuncDeclPtr(Z3_mk_func_decl(ctx(), s->get(), 1, dom, get_sort(range)));
|
|
}
|
|
|
|
FuncDeclPtr RawContext::MkFuncDecl(Symbol^ s, SortPtr d1, SortPtr d2, SortPtr range) {
|
|
Z3_sort dom[2] = { get_sort(d1), get_sort(d2) };
|
|
return FuncDeclPtr(Z3_mk_func_decl(ctx(), s->get(), 2, dom, get_sort(range)));
|
|
}
|
|
|
|
FuncDeclPtr RawContext::MkFuncDecl(String^ s, SortPtr domain, SortPtr range) {
|
|
Z3_sort dom[1] = { get_sort(domain) };
|
|
Z3_symbol sym = Z3_mk_string_symbol(ctx(), CreateString(s).c_str());
|
|
return FuncDeclPtr(Z3_mk_func_decl(ctx(), sym, 1, dom, get_sort(range)));
|
|
}
|
|
|
|
FuncDeclPtr RawContext::MkFuncDecl(String^ s, SortPtr d1, SortPtr d2, SortPtr range) {
|
|
Z3_symbol sym = Z3_mk_string_symbol(ctx(), CreateString(s).c_str());
|
|
Z3_sort dom[2] = { get_sort(d1), get_sort(d2) };
|
|
return FuncDeclPtr(Z3_mk_func_decl(ctx(), sym, 2, dom, get_sort(range)));
|
|
}
|
|
|
|
TermPtr RawContext::MkApp(FuncDeclPtr d, array<TermPtr>^ args) {
|
|
scoped_Z3_ast_array<Z3_ast> z3_args(args);
|
|
return TermPtr(Z3_mk_app(ctx(), get_func_decl(d), z3_args.size(), z3_args.c_ptr()));
|
|
}
|
|
|
|
TermPtr RawContext::MkApp(FuncDeclPtr d, TermPtr arg) {
|
|
Z3_ast args[1] = { get_ast(arg) };
|
|
return TermPtr(Z3_mk_app(ctx(), get_func_decl(d), 1, args));
|
|
}
|
|
|
|
TermPtr RawContext::MkApp(FuncDeclPtr d, TermPtr arg1, TermPtr arg2) {
|
|
Z3_ast args[2] = { get_ast(arg1), get_ast(arg2) };
|
|
return TermPtr(Z3_mk_app(ctx(), get_func_decl(d), 2, args));
|
|
}
|
|
|
|
TermPtr RawContext::MkApp(FuncDeclPtr d, TermPtr arg1, TermPtr arg2, TermPtr arg3) {
|
|
Z3_ast args[3] = { get_ast(arg1), get_ast(arg2), get_ast(arg3) };
|
|
return TermPtr(Z3_mk_app(ctx(), get_func_decl(d), 3, args));
|
|
}
|
|
|
|
|
|
TermPtr RawContext::MkConst(FuncDeclPtr d) {
|
|
return TermPtr(Z3_mk_app(ctx(),get_func_decl(d), 0, 0));
|
|
}
|
|
|
|
TermPtr RawContext::MkConst(String^ s, SortPtr ty) {
|
|
Z3_symbol sym = Z3_mk_string_symbol(ctx(),CreateString(s).c_str());
|
|
Z3_func_decl d = Z3_mk_func_decl(ctx(), sym, 0, 0, get_sort(ty));
|
|
return TermPtr(Z3_mk_app(ctx(), d, 0, 0));
|
|
}
|
|
|
|
TermPtr RawContext::MkConst(Symbol^ s, SortPtr ty) {
|
|
Z3_func_decl d = Z3_mk_func_decl(ctx(), s->get(), 0, 0, get_sort(ty));
|
|
return TermPtr(Z3_mk_app(ctx(), d, 0, 0));
|
|
}
|
|
|
|
FuncDeclPtr RawContext::MkFreshFuncDecl(String^ prefix, array<SortPtr>^ domain, SortPtr range) {
|
|
scoped_Z3_ast_array<Z3_sort> types(domain);
|
|
return FuncDeclPtr(Z3_mk_fresh_func_decl(ctx(), CreateString(prefix).c_str(), types.size(), types.c_ptr(), get_sort(range)));
|
|
}
|
|
|
|
TermPtr RawContext::MkFreshConst(String^ prefix, SortPtr ty) {
|
|
return TermPtr(Z3_mk_fresh_const(ctx(), CreateString(prefix).c_str(), get_sort(ty)));
|
|
}
|
|
|
|
TermPtr RawContext::MkLabel(Symbol^ name, bool pos, TermPtr fml) {
|
|
return TermPtr(Z3_mk_label(ctx(), name->get(), pos, get_ast(fml)));
|
|
}
|
|
|
|
|
|
TermPtr RawContext::MkEq(TermPtr l, TermPtr r) {
|
|
return TermPtr(Z3_mk_eq(ctx(), get_ast(l), get_ast(r)));
|
|
}
|
|
|
|
TermPtr RawContext::MkDistinct(array<TermPtr>^ _args) {
|
|
scoped_Z3_ast_array<Z3_ast> args(_args);
|
|
return TermPtr(Z3_mk_distinct(ctx(), args.size(), args.c_ptr()));
|
|
}
|
|
|
|
TermPtr RawContext::MkNot(TermPtr arg) {
|
|
return TermPtr(Z3_mk_not(ctx(), get_ast(arg)));
|
|
}
|
|
|
|
TermPtr RawContext::MkIte(TermPtr t1, TermPtr t2, TermPtr t3) {
|
|
return TermPtr(Z3_mk_ite(ctx(), get_ast(t1), get_ast(t2), get_ast(t3)));
|
|
}
|
|
|
|
#define MK_BINARY(fn, t1, t2) return TermPtr(Z3_mk_ ## fn (ctx(), get_ast(t1), get_ast(t2)))
|
|
|
|
#define MK_UNARY(fn, t1) return TermPtr(Z3_mk_ ## fn (ctx(), get_ast(t1)))
|
|
|
|
#define MK_NARY(fn, _args_) { scoped_Z3_ast_array<Z3_ast> my_args(_args_); return TermPtr(Z3_mk_ ## fn (ctx(), my_args.size(), my_args.c_ptr())); }
|
|
|
|
TermPtr RawContext::MkIff(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(iff, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkImplies(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(implies, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkXor(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(xor, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkAnd(array<TermPtr>^ args) {
|
|
MK_NARY(and, args);
|
|
}
|
|
|
|
TermPtr RawContext::MkAnd(TermPtr arg1, TermPtr arg2) {
|
|
Z3_ast args[2] = { get_ast(arg1), get_ast(arg2) };
|
|
return TermPtr(Z3_mk_and(ctx(), 2, args));
|
|
}
|
|
|
|
TermPtr RawContext::MkOr(array<TermPtr>^ args) {
|
|
MK_NARY(or, args);
|
|
}
|
|
|
|
TermPtr RawContext::MkOr(TermPtr arg1, TermPtr arg2) {
|
|
Z3_ast args[2] = { get_ast(arg1), get_ast(arg2) };
|
|
return TermPtr(Z3_mk_or(ctx(), 2, args));
|
|
}
|
|
|
|
TermPtr RawContext::MkAdd(array<TermPtr>^ args) {
|
|
MK_NARY(add, args);
|
|
}
|
|
|
|
TermPtr RawContext::MkAdd(TermPtr arg1, TermPtr arg2) {
|
|
Z3_ast args[2] = { get_ast(arg1), get_ast(arg2) };
|
|
return TermPtr(Z3_mk_add(ctx(), 2, args));
|
|
}
|
|
|
|
TermPtr RawContext::MkMul(array<TermPtr>^ args) {
|
|
MK_NARY(mul, args);
|
|
}
|
|
|
|
TermPtr RawContext::MkMul(TermPtr arg1, TermPtr arg2) {
|
|
Z3_ast args[2] = { get_ast(arg1), get_ast(arg2) };
|
|
return TermPtr(Z3_mk_mul(ctx(), 2, args));
|
|
}
|
|
|
|
TermPtr RawContext::MkSub(array<TermPtr>^ args) {
|
|
MK_NARY(sub, args);
|
|
}
|
|
|
|
TermPtr RawContext::MkSub(TermPtr arg1, TermPtr arg2) {
|
|
Z3_ast args[2] = { get_ast(arg1), get_ast(arg2) };
|
|
return TermPtr(Z3_mk_sub(ctx(), 2, args));
|
|
}
|
|
|
|
TermPtr RawContext::MkUnaryMinus(TermPtr arg) {
|
|
MK_UNARY(unary_minus, arg);
|
|
}
|
|
|
|
TermPtr RawContext::MkDiv(TermPtr arg1, TermPtr arg2) {
|
|
MK_BINARY(div, arg1, arg2);
|
|
}
|
|
|
|
TermPtr RawContext::MkMod(TermPtr arg1, TermPtr arg2) {
|
|
MK_BINARY(mod, arg1, arg2);
|
|
}
|
|
|
|
TermPtr RawContext::MkRem(TermPtr arg1, TermPtr arg2) {
|
|
MK_BINARY(rem, arg1, arg2);
|
|
}
|
|
|
|
TermPtr RawContext::MkToReal(TermPtr arg) {
|
|
MK_UNARY(int2real, arg);
|
|
}
|
|
|
|
|
|
TermPtr RawContext::MkToInt(TermPtr arg) {
|
|
MK_UNARY(real2int, arg);
|
|
}
|
|
|
|
TermPtr RawContext::MkIsInt(TermPtr arg) {
|
|
MK_UNARY(is_int, arg);
|
|
}
|
|
|
|
TermPtr RawContext::MkLt(TermPtr arg1, TermPtr arg2) {
|
|
MK_BINARY(lt, arg1, arg2);
|
|
}
|
|
|
|
TermPtr RawContext::MkLe(TermPtr arg1, TermPtr arg2) {
|
|
MK_BINARY(le, arg1, arg2);
|
|
}
|
|
|
|
TermPtr RawContext::MkGt(TermPtr arg1, TermPtr arg2) {
|
|
MK_BINARY(gt, arg1, arg2);
|
|
}
|
|
|
|
TermPtr RawContext::MkGe(TermPtr arg1, TermPtr arg2) {
|
|
MK_BINARY(ge, arg1, arg2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvNot(TermPtr t1) {
|
|
MK_UNARY(bvnot, t1);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvReduceAnd(TermPtr t1) {
|
|
MK_UNARY(bvredand, t1);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvReduceOr(TermPtr t1) {
|
|
MK_UNARY(bvredor, t1);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvAnd(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvand, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvOr(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvor, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvXor(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvxor, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvNand(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvnand, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvNor(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvnor, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvXnor(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvxnor, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvNeg(TermPtr t1) {
|
|
MK_UNARY(bvneg, t1);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvAdd(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvadd, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSub(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvsub, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvMul(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvmul, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvUdiv(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvudiv, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSdiv(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvsdiv, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvUrem(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvurem, t1, t2);
|
|
}
|
|
TermPtr RawContext::MkBvSrem(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvsrem, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSmod(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvsmod, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvUlt(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvult, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSlt(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvslt, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvUle(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvule, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSle(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvsle, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvUge(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvuge, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSge(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvsge, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvUgt(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvugt, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSgt(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvsgt, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvConcat(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(concat, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvExtract(unsigned high, unsigned low, TermPtr t) {
|
|
return TermPtr(Z3_mk_extract(ctx(), high, low, get_ast(t)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSignExt(unsigned i, TermPtr t) {
|
|
return TermPtr(Z3_mk_sign_ext(ctx(), i, get_ast(t)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvZeroExt(unsigned i, TermPtr t) {
|
|
return TermPtr(Z3_mk_zero_ext(ctx(), i, get_ast(t)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvRepeat(unsigned i, TermPtr t) {
|
|
return TermPtr(Z3_mk_repeat(ctx(), i, get_ast(t)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvShl(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvshl, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvLshr(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvlshr, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvAshr(TermPtr t1, TermPtr t2) {
|
|
MK_BINARY(bvashr, t1, t2);
|
|
}
|
|
|
|
TermPtr RawContext::MkBvRotateLeft(unsigned i, TermPtr t1) {
|
|
return TermPtr(Z3_mk_rotate_left(ctx(), i, get_ast(t1)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvRotateRight(unsigned i, TermPtr t1) {
|
|
return TermPtr(Z3_mk_rotate_right(ctx(), i, get_ast(t1)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvRotateLeft(TermPtr t1, TermPtr t2) {
|
|
return TermPtr(Z3_mk_ext_rotate_left(ctx(), get_ast(t1), get_ast(t2)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvRotateRight(TermPtr t1, TermPtr t2) {
|
|
return TermPtr(Z3_mk_ext_rotate_right(ctx(), get_ast(t1), get_ast(t2)));
|
|
}
|
|
|
|
TermPtr RawContext::MkInt2Bv(unsigned i, TermPtr t1) {
|
|
return TermPtr(Z3_mk_int2bv(ctx(), i, get_ast(t1)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBv2Int(TermPtr t1, bool is_signed) {
|
|
return TermPtr(Z3_mk_bv2int(ctx(), get_ast(t1), is_signed));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvAddNoOverflow(TermPtr t1, TermPtr t2, bool is_signed) {
|
|
return TermPtr(Z3_mk_bvadd_no_overflow(ctx(), get_ast(t1), get_ast(t2), is_signed));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvAddNoUnderflow(TermPtr t1, TermPtr t2) {
|
|
return TermPtr(Z3_mk_bvadd_no_underflow(ctx(), get_ast(t1), get_ast(t2)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSubNoOverflow(TermPtr t1, TermPtr t2) {
|
|
return TermPtr(Z3_mk_bvsub_no_overflow(ctx(), get_ast(t1), get_ast(t2)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSubNoUnderflow(TermPtr t1, TermPtr t2, bool is_signed) {
|
|
return TermPtr(Z3_mk_bvsub_no_underflow(ctx(), get_ast(t1), get_ast(t2), is_signed));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvSDivNoOverflow(TermPtr t1, TermPtr t2) {
|
|
return TermPtr(Z3_mk_bvsdiv_no_overflow(ctx(), get_ast(t1), get_ast(t2)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvNegNoOverflow(TermPtr t1) {
|
|
return TermPtr(Z3_mk_bvneg_no_overflow(ctx(), get_ast(t1)));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvMulNoOverflow(TermPtr t1, TermPtr t2, bool is_signed) {
|
|
return TermPtr(Z3_mk_bvmul_no_overflow(ctx(), get_ast(t1), get_ast(t2), is_signed));
|
|
}
|
|
|
|
TermPtr RawContext::MkBvMulNoUnderflow(TermPtr t1, TermPtr t2) {
|
|
return TermPtr(Z3_mk_bvmul_no_underflow(ctx(), get_ast(t1), get_ast(t2)));
|
|
}
|
|
|
|
TermPtr RawContext::MkArraySelect(TermPtr a, TermPtr i) {
|
|
return TermPtr(Z3_mk_select(ctx(), get_ast(a), get_ast(i)));
|
|
}
|
|
|
|
TermPtr RawContext::MkArrayStore(TermPtr a, TermPtr i, TermPtr v) {
|
|
return TermPtr(Z3_mk_store(ctx(), get_ast(a), get_ast(i), get_ast(v)));
|
|
}
|
|
|
|
TermPtr RawContext::MkArrayMap(FuncDeclPtr d, array<TermPtr>^ args) {
|
|
scoped_Z3_ast_array<Z3_ast> _args(args);
|
|
return TermPtr(Z3_mk_map(ctx(), get_func_decl(d), _args.size(), _args.c_ptr()));
|
|
}
|
|
|
|
TermPtr RawContext::MkArrayConst(SortPtr domain, TermPtr v) {
|
|
return TermPtr(Z3_mk_const_array(ctx(), get_sort(domain), get_ast(v)));
|
|
}
|
|
|
|
TermPtr RawContext::MkArrayDefault(TermPtr a) {
|
|
return TermPtr(Z3_mk_array_default(ctx(), get_ast(a)));
|
|
}
|
|
|
|
TermPtr RawContext::MkSetUnion(array<TermPtr>^ sets) {
|
|
scoped_Z3_ast_array<Z3_ast> _sets(sets);
|
|
return TermPtr(Z3_mk_set_union(ctx(), _sets.size(), _sets.c_ptr()));
|
|
}
|
|
|
|
TermPtr RawContext::MkSetUnion(TermPtr set1, TermPtr set2) {
|
|
Z3_ast args[2] = { get_ast(set1), get_ast(set2) };
|
|
return TermPtr(Z3_mk_set_union(ctx(), 2, args));
|
|
}
|
|
|
|
TermPtr RawContext::MkSetIntersect(array<TermPtr>^ sets) {
|
|
scoped_Z3_ast_array<Z3_ast> _sets(sets);
|
|
return TermPtr(Z3_mk_set_intersect(ctx(), _sets.size(), _sets.c_ptr()));
|
|
}
|
|
|
|
TermPtr RawContext::MkSetIntersect(TermPtr set1, TermPtr set2) {
|
|
Z3_ast args[2] = { get_ast(set1), get_ast(set2) };
|
|
return TermPtr(Z3_mk_set_intersect(ctx(), 2, args));
|
|
}
|
|
|
|
FuncDeclPtr RawContext::MkInjectiveFunction(String^ name, array<SortPtr>^ domain, SortPtr range) {
|
|
scoped_Z3_ast_array<Z3_sort> types(domain);
|
|
Z3_symbol sym = Z3_mk_string_symbol(ctx(), CreateString(name).c_str());
|
|
return FuncDeclPtr(Z3_mk_injective_function(ctx(), sym, types.size(), types.c_ptr(), get_sort(range)));
|
|
}
|
|
|
|
FuncDeclPtr RawContext::MkInjectiveFunction(Symbol^ name, array<SortPtr>^ domain, SortPtr range) {
|
|
scoped_Z3_ast_array<Z3_sort> types(domain);
|
|
return FuncDeclPtr(Z3_mk_injective_function(ctx(), name->get(), types.size(), types.c_ptr(), get_sort(range)));
|
|
}
|
|
|
|
|
|
TermPtr RawContext::MkNumeral(String^ numeral, SortPtr ty) {
|
|
return TermPtr(Z3_mk_numeral(ctx(), CreateString(numeral).c_str(), get_sort(ty)));
|
|
}
|
|
|
|
TermPtr RawContext::MkNumeral(int n, SortPtr ty) {
|
|
return TermPtr(Z3_mk_int(ctx(), n, get_sort(ty)));
|
|
}
|
|
|
|
TermPtr RawContext::MkNumeral(unsigned n, SortPtr ty) {
|
|
return TermPtr(Z3_mk_unsigned_int(ctx(), n, get_sort(ty)));
|
|
}
|
|
|
|
TermPtr RawContext::MkNumeral(__int64 n, SortPtr ty) {
|
|
return TermPtr(Z3_mk_int64(ctx(), n, get_sort(ty)));
|
|
}
|
|
|
|
TermPtr RawContext::MkNumeral(unsigned __int64 n, SortPtr ty) {
|
|
return TermPtr(Z3_mk_unsigned_int64(ctx(), n, get_sort(ty)));
|
|
}
|
|
|
|
PatternPtr RawContext::MkPattern(array<TermPtr>^ terms) {
|
|
scoped_Z3_ast_array<Z3_ast> args(terms);
|
|
return PatternPtr(Z3_mk_pattern(ctx(), args.size(), args.c_ptr()));
|
|
}
|
|
|
|
TermPtr RawContext::MkBound(unsigned index, SortPtr ty) {
|
|
return TermPtr(Z3_mk_bound(ctx(), index, get_sort(ty)));
|
|
}
|
|
|
|
TermPtr RawContext::MkForall(
|
|
unsigned weight,
|
|
array<PatternPtr>^ patterns,
|
|
array<SortPtr>^ types,
|
|
array<Symbol^>^ names,
|
|
TermPtr body
|
|
)
|
|
{
|
|
scoped_Z3_ast_array<Z3_pattern> _patterns(patterns);
|
|
scoped_Z3_ast_array<Z3_sort> _types(types);
|
|
scoped_Z3_symbol_array _names(names);
|
|
return TermPtr(
|
|
Z3_mk_forall(
|
|
ctx(),
|
|
weight,
|
|
_patterns.size(),
|
|
_patterns.c_ptr(),
|
|
_types.size(),
|
|
_types.c_ptr(),
|
|
_names.c_ptr(),
|
|
get_ast(body)
|
|
)
|
|
);
|
|
}
|
|
|
|
TermPtr RawContext::MkForall(
|
|
unsigned weight,
|
|
array<PatternPtr>^ patterns,
|
|
array<SortPtr>^ types,
|
|
array<String^>^ names,
|
|
TermPtr body
|
|
)
|
|
{
|
|
if (!names) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidArgument);
|
|
}
|
|
array<Symbol^>^ nameSymbols = gcnew array<Symbol^>(names->Length);
|
|
for (int i = 0; i < nameSymbols->Length; ++i) {
|
|
nameSymbols[i] = MkSymbol(names[i]);
|
|
}
|
|
return MkForall(weight, patterns, types, nameSymbols, body);
|
|
}
|
|
|
|
TermPtr RawContext::MkForall(
|
|
unsigned weight,
|
|
array<AppPtr>^ bound,
|
|
array<PatternPtr>^ patterns,
|
|
TermPtr body
|
|
)
|
|
{
|
|
scoped_Z3_ast_array<Z3_app> _bound(bound);
|
|
scoped_Z3_ast_array<Z3_pattern> _patterns(patterns);
|
|
return TermPtr(
|
|
Z3_mk_forall_const(
|
|
ctx(),
|
|
weight,
|
|
_bound.size(),
|
|
_bound.c_ptr(),
|
|
_patterns.size(),
|
|
_patterns.c_ptr(),
|
|
get_ast(body)
|
|
));
|
|
}
|
|
|
|
TermPtr RawContext::MkExists(
|
|
unsigned weight,
|
|
array<PatternPtr>^ patterns,
|
|
array<SortPtr>^ types,
|
|
array<Symbol^>^ names,
|
|
TermPtr body
|
|
)
|
|
{
|
|
scoped_Z3_ast_array<Z3_pattern> _patterns(patterns);
|
|
scoped_Z3_ast_array<Z3_sort> _types(types);
|
|
scoped_Z3_symbol_array _names(names);
|
|
return TermPtr(
|
|
Z3_mk_exists(
|
|
ctx(),
|
|
weight,
|
|
_patterns.size(),
|
|
_patterns.c_ptr(),
|
|
_types.size(),
|
|
_types.c_ptr(),
|
|
_names.c_ptr(),
|
|
get_ast(body)
|
|
)
|
|
);
|
|
}
|
|
|
|
TermPtr RawContext::MkExists(
|
|
unsigned weight,
|
|
array<PatternPtr>^ patterns,
|
|
array<SortPtr>^ types,
|
|
array<String^>^ names,
|
|
TermPtr body
|
|
)
|
|
{
|
|
if (!names) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidArgument);
|
|
}
|
|
array<Symbol^>^ nameSymbols = gcnew array<Symbol^>(names->Length);
|
|
for (int i = 0; i < nameSymbols->Length; ++i) {
|
|
nameSymbols[i] = MkSymbol(names[i]);
|
|
}
|
|
return MkExists(weight, patterns, types, nameSymbols, body);
|
|
}
|
|
|
|
TermPtr RawContext::MkExists(
|
|
unsigned weight,
|
|
array<AppPtr>^ bound,
|
|
array<PatternPtr>^ patterns,
|
|
TermPtr body
|
|
)
|
|
{
|
|
scoped_Z3_ast_array<Z3_app> _bound(bound);
|
|
scoped_Z3_ast_array<Z3_pattern> _patterns(patterns);
|
|
return TermPtr(
|
|
Z3_mk_exists_const(
|
|
ctx(),
|
|
weight,
|
|
_bound.size(),
|
|
_bound.c_ptr(),
|
|
_patterns.size(),
|
|
_patterns.c_ptr(),
|
|
get_ast(body)
|
|
));
|
|
}
|
|
|
|
TermPtr RawContext::MkQuantifier(
|
|
bool is_forall,
|
|
unsigned weight,
|
|
Symbol^ quantifier_id,
|
|
Symbol^ skolem_id,
|
|
array<PatternPtr>^ patterns,
|
|
array<TermPtr>^ no_patterns,
|
|
array<SortPtr>^ types,
|
|
array<Symbol^>^ names,
|
|
TermPtr body
|
|
)
|
|
{
|
|
scoped_Z3_ast_array<Z3_pattern> _patterns(patterns);
|
|
scoped_Z3_ast_array<Z3_ast> _no_patterns(no_patterns);
|
|
scoped_Z3_ast_array<Z3_sort> _types(types);
|
|
scoped_Z3_symbol_array _names(names);
|
|
return TermPtr(
|
|
Z3_mk_quantifier_ex(
|
|
ctx(),
|
|
is_forall,
|
|
weight,
|
|
quantifier_id?quantifier_id->get():0,
|
|
skolem_id?skolem_id->get():0,
|
|
_patterns.size(),
|
|
_patterns.c_ptr(),
|
|
_no_patterns.size(),
|
|
_no_patterns.c_ptr(),
|
|
_types.size(),
|
|
_types.c_ptr(),
|
|
_names.c_ptr(),
|
|
get_ast(body)
|
|
)
|
|
);
|
|
}
|
|
|
|
TermPtr RawContext::MkQuantifier(
|
|
bool is_forall,
|
|
unsigned weight,
|
|
Symbol^ quantifier_id,
|
|
Symbol^ skolem_id,
|
|
array<PatternPtr>^ patterns,
|
|
array<TermPtr>^ no_patterns,
|
|
array<TermPtr>^ bound,
|
|
TermPtr body
|
|
)
|
|
{
|
|
scoped_Z3_ast_array<Z3_pattern> _patterns(patterns);
|
|
scoped_Z3_ast_array<Z3_ast> _no_patterns(no_patterns);
|
|
scoped_Z3_ast_array<Z3_app> _bound(bound);
|
|
return TermPtr(
|
|
Z3_mk_quantifier_const_ex(
|
|
ctx(),
|
|
is_forall,
|
|
weight,
|
|
quantifier_id?quantifier_id->get():0,
|
|
skolem_id?skolem_id->get():0,
|
|
_bound.size(), _bound.c_ptr(),
|
|
_patterns.size(),
|
|
_patterns.c_ptr(),
|
|
_no_patterns.size(),
|
|
_no_patterns.c_ptr(),
|
|
get_ast(body)
|
|
)
|
|
);
|
|
}
|
|
|
|
unsigned RawContext::GetTermId(TermPtr t) {
|
|
return Z3_get_ast_id(ctx(), get_ast(t));
|
|
}
|
|
|
|
unsigned RawContext::GetFuncDeclId(FuncDeclPtr t) {
|
|
return Z3_get_func_decl_id(ctx(), get_func_decl(t));
|
|
}
|
|
|
|
unsigned RawContext::GetSortId(SortPtr t) {
|
|
return Z3_get_sort_id(ctx(), get_sort(t));
|
|
}
|
|
|
|
SymbolKind RawContext::GetSymbolKind(Symbol^ s) {
|
|
switch(Z3_get_symbol_kind(ctx(), s->get())) {
|
|
case Z3_INT_SYMBOL:
|
|
return SymbolKind::Int;
|
|
case Z3_STRING_SYMBOL:
|
|
return SymbolKind::String;
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
return SymbolKind::Int;
|
|
}
|
|
|
|
int RawContext::GetSymbolInt(Symbol^ s) {
|
|
return Z3_get_symbol_int(ctx(), s->get());
|
|
}
|
|
|
|
String^ Symbol::ToString() {
|
|
return gcnew String(Z3_get_symbol_string(m_ctx, m_symbol));
|
|
}
|
|
|
|
String^ RawContext::GetSymbolString(Symbol^ s) {
|
|
return gcnew String(Z3_get_symbol_string(ctx(), s->get()));
|
|
}
|
|
|
|
bool RawContext::IsEq(TermPtr t1, TermPtr t2) {
|
|
return Z3_TRUE == Z3_is_eq_ast(ctx(), get_ast(t1), get_ast(t2));
|
|
}
|
|
|
|
bool RawContext::IsWellSorted(TermPtr t) {
|
|
return Z3_is_well_sorted(ctx(), get_ast(t)) == Z3_TRUE;
|
|
}
|
|
|
|
TermKind RawContext::GetTermKind(TermPtr a) {
|
|
switch(Z3_get_ast_kind(ctx(), get_ast(a))) {
|
|
case Z3_NUMERAL_AST:
|
|
return TermKind::Numeral;
|
|
case Z3_APP_AST:
|
|
return TermKind::App;
|
|
case Z3_VAR_AST:
|
|
return TermKind::Var;
|
|
case Z3_QUANTIFIER_AST:
|
|
return TermKind::Quantifier;
|
|
case Z3_UNKNOWN_AST:
|
|
return TermKind::Unknown;
|
|
}
|
|
UNREACHABLE();
|
|
return TermKind::Unknown;
|
|
}
|
|
|
|
DeclKind RawContext::GetDeclKind(FuncDeclPtr d) {
|
|
switch(Z3_get_decl_kind(ctx(), get_func_decl(d))) {
|
|
case Z3_OP_TRUE: return DeclKind::True;
|
|
case Z3_OP_FALSE: return DeclKind::False;
|
|
case Z3_OP_EQ: return DeclKind::Eq;
|
|
case Z3_OP_DISTINCT: return DeclKind::Distinct;
|
|
case Z3_OP_ITE: return DeclKind::Ite;
|
|
case Z3_OP_AND: return DeclKind::And;
|
|
case Z3_OP_OR: return DeclKind::Or;
|
|
case Z3_OP_IFF: return DeclKind::Iff;
|
|
case Z3_OP_XOR: return DeclKind::Xor;
|
|
case Z3_OP_NOT: return DeclKind::Not;
|
|
case Z3_OP_IMPLIES: return DeclKind::Implies;
|
|
case Z3_OP_ANUM: return DeclKind::ArithNum;
|
|
case Z3_OP_LE: return DeclKind::Le;
|
|
case Z3_OP_GE: return DeclKind::Ge;
|
|
case Z3_OP_LT: return DeclKind::Lt;
|
|
case Z3_OP_GT: return DeclKind::Gt;
|
|
case Z3_OP_ADD: return DeclKind::Add;
|
|
case Z3_OP_SUB: return DeclKind::Sub;
|
|
case Z3_OP_UMINUS: return DeclKind::Uminus;
|
|
case Z3_OP_MUL: return DeclKind::Mul;
|
|
case Z3_OP_DIV: return DeclKind::Div;
|
|
case Z3_OP_IDIV: return DeclKind::IDiv;
|
|
case Z3_OP_REM: return DeclKind::Rem;
|
|
case Z3_OP_MOD: return DeclKind::Mod;
|
|
case Z3_OP_TO_REAL: return DeclKind::ToReal;
|
|
case Z3_OP_TO_INT: return DeclKind::ToInt;
|
|
case Z3_OP_IS_INT: return DeclKind::IsInt;
|
|
case Z3_OP_STORE: return DeclKind::Store;
|
|
case Z3_OP_SELECT: return DeclKind::Select;
|
|
case Z3_OP_CONST_ARRAY: return DeclKind::ConstArray;
|
|
case Z3_OP_ARRAY_DEFAULT: return DeclKind::DefaultArray;
|
|
case Z3_OP_ARRAY_MAP: return DeclKind::MapArray;
|
|
case Z3_OP_SET_UNION: return DeclKind::Union;
|
|
case Z3_OP_SET_INTERSECT: return DeclKind::Intersect;
|
|
case Z3_OP_SET_DIFFERENCE: return DeclKind::Difference;
|
|
case Z3_OP_SET_COMPLEMENT: return DeclKind::Complement;
|
|
case Z3_OP_SET_SUBSET: return DeclKind::Subset;
|
|
case Z3_OP_AS_ARRAY: return DeclKind::AsArray;
|
|
case Z3_OP_BNUM: return DeclKind::BitNum;
|
|
case Z3_OP_BIT1: return DeclKind::Bit1 ;
|
|
case Z3_OP_BIT0: return DeclKind::Bit0 ;
|
|
case Z3_OP_BNEG: return DeclKind::BNeg ;
|
|
case Z3_OP_BADD: return DeclKind::BAdd ;
|
|
case Z3_OP_BSUB: return DeclKind::BSub ;
|
|
case Z3_OP_BMUL: return DeclKind::BMul ;
|
|
|
|
case Z3_OP_BSDIV: return DeclKind::BSDiv ;
|
|
case Z3_OP_BUDIV: return DeclKind::BUDiv ;
|
|
case Z3_OP_BSREM: return DeclKind::BSRem ;
|
|
case Z3_OP_BUREM: return DeclKind::BURem ;
|
|
case Z3_OP_BSMOD: return DeclKind::BSMod ;
|
|
|
|
// special functions to record the division by 0 cases
|
|
// these are internal functions
|
|
case Z3_OP_BSDIV0: return DeclKind::BSDiv0 ;
|
|
case Z3_OP_BUDIV0: return DeclKind::BUDiv0 ;
|
|
case Z3_OP_BSREM0: return DeclKind::BSRem0 ;
|
|
case Z3_OP_BUREM0: return DeclKind::BURem0 ;
|
|
case Z3_OP_BSMOD0: return DeclKind::BSMod0 ;
|
|
|
|
case Z3_OP_ULEQ: return DeclKind::BULeq ;
|
|
case Z3_OP_SLEQ: return DeclKind::BSLeq ;
|
|
case Z3_OP_UGEQ: return DeclKind::BUGeq ;
|
|
case Z3_OP_SGEQ: return DeclKind::BSGeq ;
|
|
case Z3_OP_ULT: return DeclKind::BULt ;
|
|
case Z3_OP_SLT: return DeclKind::BSLt ;
|
|
case Z3_OP_UGT: return DeclKind::BUGt ;
|
|
case Z3_OP_SGT: return DeclKind::BSGt ;
|
|
|
|
case Z3_OP_BAND: return DeclKind::BAnd ;
|
|
case Z3_OP_BOR: return DeclKind::BOr ;
|
|
case Z3_OP_BNOT: return DeclKind::BNot;
|
|
case Z3_OP_BXOR: return DeclKind::BXor ;
|
|
case Z3_OP_BNAND: return DeclKind::BNand ;
|
|
case Z3_OP_BNOR: return DeclKind::BNor ;
|
|
case Z3_OP_BXNOR: return DeclKind::BXnor ;
|
|
|
|
case Z3_OP_CONCAT: return DeclKind::BConcat ;
|
|
case Z3_OP_SIGN_EXT: return DeclKind::BSignExt ;
|
|
case Z3_OP_ZERO_EXT: return DeclKind::BZeroExt ;
|
|
case Z3_OP_EXTRACT: return DeclKind::BExtract ;
|
|
case Z3_OP_REPEAT: return DeclKind::BRepeat ;
|
|
|
|
case Z3_OP_BREDOR: return DeclKind::BRedOr ;
|
|
case Z3_OP_BREDAND: return DeclKind::BRedAnd ;
|
|
case Z3_OP_BCOMP: return DeclKind::BComp ;
|
|
|
|
case Z3_OP_BSHL: return DeclKind::BShl ;
|
|
case Z3_OP_BLSHR: return DeclKind::BLShr ;
|
|
case Z3_OP_BASHR: return DeclKind::BAShr ;
|
|
case Z3_OP_ROTATE_LEFT: return DeclKind::BRotateLeft ;
|
|
case Z3_OP_ROTATE_RIGHT: return DeclKind::BRotateRight ;
|
|
case Z3_OP_EXT_ROTATE_LEFT: return DeclKind::BExtRotateLeft ;
|
|
case Z3_OP_EXT_ROTATE_RIGHT: return DeclKind::BExtRotateRight ;
|
|
|
|
case Z3_OP_INT2BV: return DeclKind::BInt2Bv ;
|
|
case Z3_OP_BV2INT: return DeclKind::BBv2Int ;
|
|
case Z3_OP_CARRY: return DeclKind::BCarry;
|
|
case Z3_OP_XOR3: return DeclKind::BXor3;
|
|
|
|
case Z3_OP_PR_ASSERTED: return DeclKind::PrAsserted ;
|
|
case Z3_OP_PR_GOAL: return DeclKind::PrGoal ;
|
|
case Z3_OP_PR_MODUS_PONENS: return DeclKind::PrModusPonens ;
|
|
case Z3_OP_PR_REFLEXIVITY: return DeclKind::PrReflexivity ;
|
|
case Z3_OP_PR_SYMMETRY: return DeclKind::PrSymmetry ;
|
|
case Z3_OP_PR_TRANSITIVITY: return DeclKind::PrTransitivity ;
|
|
case Z3_OP_PR_TRANSITIVITY_STAR: return DeclKind::PrTransitivityStar ;
|
|
case Z3_OP_PR_MONOTONICITY: return DeclKind::PrMonotonicity ;
|
|
case Z3_OP_PR_QUANT_INTRO: return DeclKind::PrQuantIntro ;
|
|
case Z3_OP_PR_DISTRIBUTIVITY: return DeclKind::PrDistributivity ;
|
|
case Z3_OP_PR_AND_ELIM: return DeclKind::PrAndElim ;
|
|
case Z3_OP_PR_NOT_OR_ELIM: return DeclKind::PrNotOrElim ;
|
|
case Z3_OP_PR_REWRITE: return DeclKind::PrRewrite ;
|
|
case Z3_OP_PR_REWRITE_STAR: return DeclKind::PrRewriteStar ;
|
|
case Z3_OP_PR_PULL_QUANT: return DeclKind::PrPullQuant ;
|
|
case Z3_OP_PR_PULL_QUANT_STAR: return DeclKind::PrPullQuantStar ;
|
|
case Z3_OP_PR_PUSH_QUANT: return DeclKind::PrPushQuant ;
|
|
case Z3_OP_PR_ELIM_UNUSED_VARS: return DeclKind::PrElimUnusedVars ;
|
|
case Z3_OP_PR_DER: return DeclKind::PrDer ;
|
|
case Z3_OP_PR_QUANT_INST: return DeclKind::PrQuantInst ;
|
|
case Z3_OP_PR_HYPOTHESIS: return DeclKind::PrHypothesis ;
|
|
case Z3_OP_PR_LEMMA: return DeclKind::PrLemma ;
|
|
case Z3_OP_PR_UNIT_RESOLUTION: return DeclKind::PrUnitResolution ;
|
|
case Z3_OP_PR_IFF_TRUE: return DeclKind::PrIffTrue ;
|
|
case Z3_OP_PR_IFF_FALSE: return DeclKind::PrIffFalse ;
|
|
case Z3_OP_PR_COMMUTATIVITY: return DeclKind::PrCommutativity ;
|
|
case Z3_OP_PR_DEF_AXIOM: return DeclKind::PrDefAxiom ;
|
|
case Z3_OP_PR_DEF_INTRO: return DeclKind::PrDefIntro ;
|
|
case Z3_OP_PR_APPLY_DEF: return DeclKind::PrApplyDef ;
|
|
case Z3_OP_PR_IFF_OEQ: return DeclKind::PrIffOeq ;
|
|
case Z3_OP_PR_NNF_POS: return DeclKind::PrNnfPos ;
|
|
case Z3_OP_PR_NNF_NEG: return DeclKind::PrNnfNeg ;
|
|
case Z3_OP_PR_NNF_STAR: return DeclKind::PrNnfStar ;
|
|
case Z3_OP_PR_SKOLEMIZE: return DeclKind::PrSkolemize ;
|
|
case Z3_OP_PR_CNF_STAR: return DeclKind::PrCnfStar ;
|
|
case Z3_OP_PR_MODUS_PONENS_OEQ: return DeclKind::PrModusPonensOeq ;
|
|
case Z3_OP_PR_TH_LEMMA: return DeclKind::PrThLemma ;
|
|
case Z3_OP_LABEL: return DeclKind::Label;
|
|
case Z3_OP_LABEL_LIT: return DeclKind::LabelLit;
|
|
case Z3_OP_RA_STORE: return DeclKind::RaStore;
|
|
case Z3_OP_RA_EMPTY: return DeclKind::RaEmpty;
|
|
case Z3_OP_RA_IS_EMPTY: return DeclKind::RaIsEmpty;
|
|
case Z3_OP_RA_JOIN: return DeclKind::RaJoin;
|
|
case Z3_OP_RA_UNION: return DeclKind::RaUnion;
|
|
case Z3_OP_RA_WIDEN: return DeclKind::RaWiden;
|
|
case Z3_OP_RA_PROJECT: return DeclKind::RaProject;
|
|
case Z3_OP_RA_FILTER: return DeclKind::RaFilter;
|
|
case Z3_OP_RA_NEGATION_FILTER: return DeclKind::RaNegationFilter;
|
|
case Z3_OP_RA_RENAME: return DeclKind::RaRename;
|
|
case Z3_OP_RA_COMPLEMENT: return DeclKind::RaComplement;
|
|
case Z3_OP_RA_SELECT: return DeclKind::RaSelect;
|
|
case Z3_OP_RA_CLONE: return DeclKind::RaClone;
|
|
|
|
case Z3_OP_UNINTERPRETED: return DeclKind::Uninterpreted;
|
|
default:
|
|
UNREACHABLE();
|
|
return DeclKind::Uninterpreted;
|
|
}
|
|
}
|
|
|
|
array<IRawParameter^>^ RawContext::GetDeclParameters(FuncDeclPtr d) {
|
|
Z3_func_decl fd = get_func_decl(d);
|
|
unsigned num_params = Z3_get_decl_num_parameters(ctx(), fd);
|
|
array<IRawParameter^>^ params = gcnew array<IRawParameter^>(num_params);
|
|
for (unsigned i = 0; i < num_params; ++i) {
|
|
switch(Z3_get_decl_parameter_kind(ctx(), fd, i)) {
|
|
case Z3_PARAMETER_INT:
|
|
params[i] = gcnew IntParameter(Z3_get_decl_int_parameter(ctx(), fd, i));
|
|
break;
|
|
case Z3_PARAMETER_DOUBLE:
|
|
params[i] = gcnew DoubleParameter(Z3_get_decl_double_parameter(ctx(), fd, i));
|
|
break;
|
|
case Z3_PARAMETER_RATIONAL: {
|
|
Z3_string s = Z3_get_decl_rational_parameter(ctx(), fd, i);
|
|
params[i] = gcnew RationalParameter(gcnew String(s));
|
|
break;
|
|
}
|
|
case Z3_PARAMETER_SYMBOL: {
|
|
Z3_symbol s = Z3_get_decl_symbol_parameter(ctx(), fd, i);
|
|
params[i] = gcnew SymbolParameter(gcnew Symbol(ctx(), s));
|
|
break;
|
|
}
|
|
case Z3_PARAMETER_SORT:
|
|
params[i] = gcnew SortPtrParameter(SortPtr(Z3_get_decl_sort_parameter(ctx(), fd, i)));
|
|
break;
|
|
case Z3_PARAMETER_AST:
|
|
params[i] = gcnew TermPtrParameter(TermPtr(Z3_get_decl_ast_parameter(ctx(), fd, i)));
|
|
break;
|
|
case Z3_PARAMETER_FUNC_DECL:
|
|
params[i] = gcnew FuncDeclPtrParameter(FuncDeclPtr(Z3_get_decl_func_decl_parameter(ctx(), fd, i)));
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
}
|
|
return params;
|
|
}
|
|
|
|
FuncDeclPtr RawContext::GetAppDecl(AppPtr a) {
|
|
if (GetTermKind(a) != TermKind::App) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidArgument);
|
|
}
|
|
return FuncDeclPtr(Z3_get_app_decl(ctx(), get_const_ast(a)));
|
|
}
|
|
|
|
array<TermPtr>^ RawContext::GetAppArgs(AppPtr a) {
|
|
if (GetTermKind(a) != TermKind::App) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidArgument);
|
|
}
|
|
|
|
unsigned num_args = Z3_get_app_num_args(ctx(), get_const_ast(a));
|
|
array<TermPtr>^ result = gcnew array<TermPtr>(num_args);
|
|
for (unsigned i = 0; i < num_args; ++i) {
|
|
result[i] = TermPtr(Z3_get_app_arg(ctx(), get_const_ast(a), i));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
RawQuantifier^ RawContext::GetQuantifier(TermPtr a) {
|
|
if (GetTermKind(a) != TermKind::Quantifier) {
|
|
throw gcnew Z3Error(ErrorCode::InvalidArgument);
|
|
}
|
|
RawQuantifier^ t = gcnew RawQuantifier();
|
|
Z3_ast ast = get_ast(a);
|
|
t->IsForall = Z3_TRUE == Z3_is_quantifier_forall(ctx(), ast);
|
|
t->Weight = Z3_get_quantifier_weight(ctx(), ast);
|
|
t->Patterns = gcnew array<PatternPtr>(Z3_get_quantifier_num_patterns(ctx(), ast));
|
|
t->NoPatterns = gcnew array<TermPtr>(Z3_get_quantifier_num_no_patterns(ctx(), ast));
|
|
t->Sorts = gcnew array<SortPtr>(Z3_get_quantifier_num_bound(ctx(), ast));
|
|
t->Names = gcnew array<Symbol^>(Z3_get_quantifier_num_bound(ctx(), ast));
|
|
t->Body = TermPtr(Z3_get_quantifier_body(ctx(), ast));
|
|
for (int i = 0; i < t->Sorts->Length; ++i) {
|
|
t->Sorts[i] = SortPtr(Z3_get_quantifier_bound_sort(ctx(), ast, i));
|
|
t->Names[i] = gcnew Symbol(ctx(), Z3_get_quantifier_bound_name(ctx(), ast, i));
|
|
}
|
|
for (int i = 0; i < t->Patterns->Length; ++i) {
|
|
t->Patterns[i] = PatternPtr(Z3_get_quantifier_pattern_ast(ctx(), ast, i));
|
|
}
|
|
for (int i = 0; i < t->NoPatterns->Length; ++i) {
|
|
t->NoPatterns[i] = TermPtr(Z3_get_quantifier_no_pattern_ast(ctx(), ast, i));
|
|
}
|
|
return t;
|
|
};
|
|
|
|
array<TermPtr>^ RawContext::GetPatternTerms(PatternPtr p) {
|
|
unsigned np = Z3_get_pattern_num_terms(ctx(), get_pattern(p));
|
|
array<TermPtr>^ result = gcnew array<TermPtr>(np);
|
|
for (unsigned i = 0; i < np; ++i) {
|
|
result[i] = TermPtr(Z3_get_pattern(ctx(), get_pattern(p), i));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Symbol^ RawContext::GetDeclName(FuncDeclPtr d) {
|
|
return gcnew Symbol(ctx(), Z3_get_decl_name(ctx(), get_func_decl(d)));
|
|
}
|
|
|
|
Symbol^ RawContext::GetSortName(SortPtr ty) {
|
|
return gcnew Symbol(ctx(), Z3_get_sort_name(ctx(), get_sort(ty)));
|
|
}
|
|
|
|
SortPtr RawContext::GetSort(TermPtr a) {
|
|
return SortPtr(Z3_get_sort(ctx(), get_ast(a)));
|
|
}
|
|
|
|
array<SortPtr>^ RawContext::GetDomain(FuncDeclPtr d) {
|
|
unsigned num_args = Z3_get_domain_size(ctx(), get_func_decl(d));
|
|
array<SortPtr>^ result = gcnew array<SortPtr>(num_args);
|
|
for (unsigned i = 0; i < num_args; ++i) {
|
|
result[i] = TermPtr(Z3_get_domain(ctx(), get_func_decl(d), i));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
SortPtr RawContext::GetRange(FuncDeclPtr d) {
|
|
return SortPtr(Z3_get_range(ctx(), get_func_decl(d)));
|
|
}
|
|
|
|
SortKind RawContext::GetSortKind(SortPtr t) {
|
|
switch(Z3_get_sort_kind(ctx(), get_sort(t))) {
|
|
case Z3_UNINTERPRETED_SORT: return SortKind::Uninterpreted;
|
|
case Z3_BOOL_SORT: return SortKind::Bool;
|
|
case Z3_INT_SORT: return SortKind::Int;
|
|
case Z3_REAL_SORT: return SortKind::Real;
|
|
case Z3_BV_SORT: return SortKind::BitVector;
|
|
case Z3_ARRAY_SORT: return SortKind::Array;
|
|
case Z3_DATATYPE_SORT: return SortKind::Datatype;
|
|
case Z3_UNKNOWN_SORT: return SortKind::Unknown;
|
|
default: UNREACHABLE(); return SortKind::Unknown;
|
|
}
|
|
}
|
|
|
|
SearchFailureExplanation RawContext::GetSearchFailureExplanation() {
|
|
return ConvertExplanation(Z3_get_search_failure(ctx()));
|
|
}
|
|
|
|
unsigned RawContext::GetBvSortSize(SortPtr t) {
|
|
return Z3_get_bv_sort_size(ctx(), get_sort(t));
|
|
}
|
|
|
|
SortPtr RawContext::GetArraySortDomain(SortPtr t) {
|
|
return SortPtr(Z3_get_array_sort_domain(ctx(), get_sort(t)));
|
|
}
|
|
|
|
SortPtr RawContext::GetArraySortRange(SortPtr t) {
|
|
return SortPtr(Z3_get_array_sort_range(ctx(), get_sort(t)));
|
|
}
|
|
|
|
FuncDeclPtr RawContext::GetTupleConstructor(SortPtr t) {
|
|
return FuncDeclPtr(Z3_get_tuple_sort_mk_decl(ctx(), get_sort(t)));
|
|
}
|
|
|
|
array<FuncDeclPtr>^ RawContext::GetTupleFields(SortPtr t) {
|
|
unsigned num_args = Z3_get_tuple_sort_num_fields(ctx(), get_sort(t));
|
|
array<FuncDeclPtr>^ result = gcnew array<FuncDeclPtr>(num_args);
|
|
for (unsigned i = 0; i < num_args; ++i) {
|
|
result[i] = FuncDeclPtr(Z3_get_tuple_sort_field_decl(ctx(), get_sort(t), i));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void RawContext::Push() {
|
|
Z3_push(ctx());
|
|
}
|
|
|
|
void RawContext::Pop(unsigned num_scopes) {
|
|
Z3_pop(ctx(), num_scopes);
|
|
}
|
|
|
|
unsigned RawContext::GetNumScopes() {
|
|
return Z3_get_num_scopes(ctx());
|
|
}
|
|
|
|
void RawContext::PersistTerm(TermPtr t, unsigned num_scopes) {
|
|
Z3_persist_ast(ctx(), get_ast(t), num_scopes);
|
|
}
|
|
|
|
void RawContext::IncRef(IntPtr ast) {
|
|
Z3_inc_ref(ctx(), get_ast(ast));
|
|
// decrement reference counts of whatever is gc'ed.
|
|
if (s_nonempty) {
|
|
System::Threading::Monitor::Enter(s_monitor);
|
|
for (int i = 0; i < s_todec->Count; ++i) {
|
|
AstPtr a = s_todec[i].Key;
|
|
RawContext^ c = s_todec[i].Value;
|
|
SASSERT(c->ref_context().is_ref_counted());
|
|
Z3_dec_ref(c->ctx(), get_ast(a));
|
|
c->ref_context().dec_ref();
|
|
}
|
|
s_todec->Clear();
|
|
s_nonempty = false;
|
|
System::Threading::Monitor::Exit(s_monitor);
|
|
}
|
|
}
|
|
|
|
void RawContext::EnqueueDecRef(IntPtr ast) {
|
|
System::Threading::Monitor::Enter(s_monitor);
|
|
s_todec->Add(KeyValuePair<AstPtr,RawContext^>(ast, this));
|
|
s_nonempty = true;
|
|
System::Threading::Monitor::Exit(s_monitor);
|
|
}
|
|
|
|
void RawContext::AssertCnstr(TermPtr a) {
|
|
Z3_assert_cnstr(ctx(), get_ast(a));
|
|
}
|
|
|
|
LBool RawContext::CheckAndGetModel(RawModel^% m) {
|
|
m = nullptr;
|
|
Z3_model model = 0;
|
|
Z3_lbool lb = Z3_check_and_get_model(ctx(), & model);
|
|
|
|
if (model) {
|
|
m = gcnew RawModel(*m_context, model);
|
|
}
|
|
else {
|
|
m = nullptr;
|
|
}
|
|
return ToLBool(lb);
|
|
}
|
|
|
|
LBool RawContext::Check() {
|
|
Z3_lbool lb = Z3_check(ctx());
|
|
return ToLBool(lb);
|
|
}
|
|
|
|
LBool RawContext::CheckAssumptions(RawModel^% m, array<TermPtr>^ assumptions, TermPtr% proof, array<TermPtr>^% core) {
|
|
scoped_Z3_ast_array<Z3_ast> _assumptions(assumptions);
|
|
scoped_Z3_ast_array<Z3_ast> _core(assumptions);
|
|
unsigned core_size = 0;
|
|
Z3_ast _proof = 0;
|
|
Z3_model model = 0;
|
|
Z3_lbool lb = Z3_check_assumptions(
|
|
ctx(),
|
|
_assumptions.size(),
|
|
_assumptions.c_ptr(),
|
|
&model,
|
|
&_proof,
|
|
&core_size,
|
|
_core.c_ptr());
|
|
|
|
core = gcnew array<TermPtr>(core_size);
|
|
for (unsigned i = 0; i < core_size; ++i) {
|
|
core[i] = TermPtr(_core[i]);
|
|
}
|
|
if(_proof) {
|
|
proof = TermPtr(_proof);
|
|
}
|
|
if (model) {
|
|
m = gcnew RawModel(*m_context, model);
|
|
}
|
|
return ToLBool(lb);
|
|
}
|
|
|
|
void RawContext::SoftCheckCancel() {
|
|
Z3_soft_check_cancel(ctx());
|
|
}
|
|
|
|
LBool RawContext::GetImpliedEqualities(
|
|
[In] array<TermPtr>^ terms,
|
|
[Out] array<unsigned>^% class_ids) {
|
|
scoped_Z3_ast_array<Z3_ast> _terms(terms);
|
|
scoped_array<unsigned> _class_ids(_terms.size());
|
|
Z3_lbool lb = Z3_get_implied_equalities(ctx(), _terms.size(), _terms.c_ptr(), _class_ids.c_ptr());
|
|
class_ids = gcnew array<unsigned>(_terms.size());
|
|
for (unsigned i = 0; i < _terms.size(); ++i) {
|
|
class_ids[i] = _class_ids[i];
|
|
}
|
|
return ToLBool(lb);
|
|
}
|
|
|
|
LabeledLiterals^ RawContext::GetRelevantLabels() {
|
|
Z3_literals lbls = Z3_get_relevant_labels(ctx());
|
|
return gcnew LabeledLiterals(*m_context, lbls);
|
|
}
|
|
|
|
LabeledLiterals^ RawContext::GetRelevantLiterals() {
|
|
Z3_literals lbls = Z3_get_relevant_literals(ctx());
|
|
return gcnew LabeledLiterals(*m_context, lbls);
|
|
}
|
|
|
|
LabeledLiterals^ RawContext::GetGuessedLiterals() {
|
|
Z3_literals lbls = Z3_get_guessed_literals(ctx());
|
|
return gcnew LabeledLiterals(*m_context, lbls);
|
|
}
|
|
|
|
void RawContext::BlockLiterals(LabeledLiterals^ lbls) {
|
|
Z3_block_literals(ctx(), lbls->Get());
|
|
}
|
|
|
|
TermPtr RawContext::Simplify(TermPtr a) {
|
|
return TermPtr(Z3_simplify(ctx(), get_ast(a)));
|
|
}
|
|
|
|
|
|
String^ RawContext::ToString() {
|
|
return gcnew String(Z3_context_to_string(ctx()));
|
|
}
|
|
|
|
void RawContext::SetPrintMode(PrintMode mode) {
|
|
Z3_ast_print_mode m = Z3_PRINT_SMTLIB_FULL;
|
|
switch(mode) {
|
|
case PrintMode::SmtlibFull:
|
|
m = Z3_PRINT_SMTLIB_FULL;
|
|
break;
|
|
case PrintMode::LowLevel:
|
|
m = Z3_PRINT_LOW_LEVEL;
|
|
break;
|
|
case PrintMode::Smtlib2Compliant:
|
|
m = Z3_PRINT_SMTLIB2_COMPLIANT;
|
|
break;
|
|
case PrintMode::SmtlibCompliant:
|
|
m = Z3_PRINT_SMTLIB_COMPLIANT;
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
Z3_set_ast_print_mode(ctx(), m);
|
|
}
|
|
|
|
void RawContext::Display(System::IO::TextWriter^ w) {
|
|
w->Write(ToString());
|
|
}
|
|
|
|
String^ RawContext::BenchmarkToSmtlib(
|
|
String^ name,
|
|
String^ logic,
|
|
String^ status,
|
|
String^ attributes,
|
|
array<TermPtr>^ assumptions,
|
|
TermPtr formula) {
|
|
scoped_Z3_ast_array<Z3_ast> _assumptions(assumptions);
|
|
return gcnew String(Z3_benchmark_to_smtlib_string(
|
|
ctx(),
|
|
(name )?CreateString(name).c_str():0,
|
|
(logic )?CreateString(logic).c_str():0,
|
|
(status )?CreateString(status).c_str():0,
|
|
(attributes )?CreateString(attributes).c_str():0,
|
|
_assumptions.size(),
|
|
_assumptions.c_ptr(),
|
|
get_ast(formula)));
|
|
}
|
|
|
|
|
|
void RawContext::ParseSmtlibString(
|
|
String^ string,
|
|
[In] array<SortPtr>^ sorts,
|
|
[In] array<FuncDeclPtr>^ old_decls,
|
|
[Out] array<TermPtr>^% assumptions,
|
|
[Out] array<TermPtr>^% formulas,
|
|
[Out] array<FuncDeclPtr>^% new_decls,
|
|
[Out] array<SortPtr>^% new_sorts,
|
|
[Out] String^% parser_out
|
|
)
|
|
{
|
|
scoped_Z3_ast_array<Z3_sort> _types(sorts);
|
|
scoped_Z3_ast_array<Z3_func_decl> _decls(old_decls);
|
|
scoped_Z3_symbol_array _sort_names(_types.size());
|
|
scoped_Z3_symbol_array _decl_names(_decls.size());
|
|
for (unsigned i = 0; i < _sort_names.size(); ++i) {
|
|
_sort_names[i] = Z3_get_sort_name(ctx(), _types[i]);
|
|
}
|
|
for (unsigned i = 0; i < _decl_names.size(); ++i) {
|
|
_decl_names[i] = Z3_get_decl_name(ctx(), _decls[i]);
|
|
}
|
|
|
|
try {
|
|
Z3_parse_smtlib_string(
|
|
ctx(),
|
|
CreateString(string).c_str(),
|
|
_types.size(),
|
|
_sort_names.c_ptr(),
|
|
_types.c_ptr(),
|
|
_decls.size(),
|
|
_decl_names.c_ptr(),
|
|
_decls.c_ptr()
|
|
);
|
|
}
|
|
catch(...) {
|
|
parser_out = gcnew String(Z3_get_smtlib_error(ctx()));
|
|
throw;
|
|
}
|
|
parser_out = gcnew String(Z3_get_smtlib_error(ctx()));
|
|
|
|
unsigned count = Z3_get_smtlib_num_formulas(ctx());
|
|
formulas = gcnew array<TermPtr>(count);
|
|
for (unsigned i = 0; i < count; ++i) {
|
|
formulas[i] = TermPtr(Z3_get_smtlib_formula(ctx(), i));
|
|
}
|
|
|
|
count = Z3_get_smtlib_num_assumptions(ctx());
|
|
assumptions = gcnew array<TermPtr>(count);
|
|
for (unsigned i = 0; i < count; ++i) {
|
|
assumptions[i] = TermPtr(Z3_get_smtlib_assumption(ctx(), i));
|
|
}
|
|
|
|
count = Z3_get_smtlib_num_decls(ctx());
|
|
new_decls = gcnew array<FuncDeclPtr>(count);
|
|
for (unsigned i = 0; i < count; ++i) {
|
|
new_decls[i] = FuncDeclPtr(Z3_get_smtlib_decl(ctx(), i));
|
|
}
|
|
count = Z3_get_smtlib_num_sorts(ctx());
|
|
new_sorts = gcnew array<SortPtr>(count);
|
|
for (unsigned i = 0; i < count; ++i) {
|
|
new_sorts[i] = SortPtr(Z3_get_smtlib_sort(ctx(), i));
|
|
}
|
|
}
|
|
|
|
void RawContext::ParseSmtlibFile(
|
|
String^ file,
|
|
[In] array<SortPtr>^ sorts,
|
|
[In] array<FuncDeclPtr>^ old_decls,
|
|
[Out] array<TermPtr>^% assumptions,
|
|
[Out] array<TermPtr>^% formulas,
|
|
[Out] array<FuncDeclPtr>^% new_decls,
|
|
[Out] array<SortPtr>^% new_sorts,
|
|
[Out] String^% parser_out
|
|
)
|
|
{
|
|
scoped_Z3_ast_array<Z3_sort> _sorts(sorts);
|
|
scoped_Z3_ast_array<Z3_func_decl> _decls(old_decls);
|
|
scoped_Z3_symbol_array _sort_names(_sorts.size());
|
|
scoped_Z3_symbol_array _decl_names(_decls.size());
|
|
for (unsigned i = 0; i < _sort_names.size(); ++i) {
|
|
_sort_names[i] = Z3_get_sort_name(ctx(), _sorts[i]);
|
|
}
|
|
for (unsigned i = 0; i < _decl_names.size(); ++i) {
|
|
_decl_names[i] = Z3_get_decl_name(ctx(), _decls[i]);
|
|
}
|
|
|
|
try {
|
|
Z3_parse_smtlib_file(
|
|
ctx(),
|
|
CreateString(file).c_str(),
|
|
_sorts.size(),
|
|
_sort_names.c_ptr(),
|
|
_sorts.c_ptr(),
|
|
_decls.size(),
|
|
_decl_names.c_ptr(),
|
|
_decls.c_ptr()
|
|
);
|
|
}
|
|
catch(...) {
|
|
parser_out = gcnew String(Z3_get_smtlib_error(ctx()));
|
|
throw;
|
|
}
|
|
parser_out = gcnew String(Z3_get_smtlib_error(ctx()));
|
|
|
|
unsigned count = Z3_get_smtlib_num_formulas(ctx());
|
|
formulas = gcnew array<TermPtr>(count);
|
|
for (unsigned i = 0; i < count; ++i) {
|
|
formulas[i] = TermPtr(Z3_get_smtlib_formula(ctx(), i));
|
|
}
|
|
|
|
count = Z3_get_smtlib_num_assumptions(ctx());
|
|
assumptions = gcnew array<TermPtr>(count);
|
|
for (unsigned i = 0; i < count; ++i) {
|
|
assumptions[i] = TermPtr(Z3_get_smtlib_assumption(ctx(), i));
|
|
}
|
|
|
|
count = Z3_get_smtlib_num_decls(ctx());
|
|
new_decls = gcnew array<FuncDeclPtr>(count);
|
|
for (unsigned i = 0; i < count; ++i) {
|
|
new_decls[i] = FuncDeclPtr(Z3_get_smtlib_decl(ctx(), i));
|
|
}
|
|
count = Z3_get_smtlib_num_sorts(ctx());
|
|
new_sorts = gcnew array<SortPtr>(count);
|
|
for (unsigned i = 0; i < count; ++i) {
|
|
new_sorts[i] = SortPtr(Z3_get_smtlib_sort(ctx(), i));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TermPtr RawContext::ParseZ3String(String^ s) {
|
|
return TermPtr(Z3_parse_z3_string(ctx(), CreateString(s).c_str()));
|
|
}
|
|
|
|
TermPtr RawContext::ParseZ3File(String^ file) {
|
|
return TermPtr(Z3_parse_z3_file(ctx(), CreateString(file).c_str()));
|
|
}
|
|
|
|
|
|
#define PROCESS_SMTLIB2(_fn) \
|
|
scoped_Z3_ast_array<Z3_sort> _sorts(sorts); \
|
|
scoped_Z3_ast_array<Z3_func_decl> _decls(decls); \
|
|
scoped_Z3_symbol_array _sort_names(_sorts.size()); \
|
|
scoped_Z3_symbol_array _decl_names(_decls.size()); \
|
|
for (unsigned i = 0; i < _sort_names.size(); ++i) { \
|
|
_sort_names[i] = Z3_get_sort_name(ctx(), _sorts[i]); \
|
|
std::cout << Z3_get_symbol_string(ctx(), _sort_names[i]) << "\n"; \
|
|
} \
|
|
for (unsigned i = 0; i < _decl_names.size(); ++i) { \
|
|
_decl_names[i] = Z3_get_decl_name(ctx(), _decls[i]); \
|
|
std::cout << Z3_get_symbol_string(ctx(), _decl_names[i]) << "\n"; \
|
|
} \
|
|
return TermPtr(_fn(ctx(), CreateString(s).c_str(), \
|
|
_sorts.size(), _sort_names.c_ptr(), _sorts.c_ptr(), \
|
|
_decls.size(), _decl_names.c_ptr(), _decls.c_ptr())); \
|
|
|
|
|
|
TermPtr RawContext::ParseSmtlib2String(String^ s, array<SortPtr>^ sorts, array<FuncDeclPtr>^ decls) {
|
|
PROCESS_SMTLIB2(Z3_parse_smtlib2_string);
|
|
}
|
|
|
|
TermPtr RawContext::ParseSmtlib2File(String^ s, array<SortPtr>^ sorts, array<FuncDeclPtr>^ decls) {
|
|
PROCESS_SMTLIB2(Z3_parse_smtlib2_file);
|
|
}
|
|
|
|
TermPtr RawContext::ExecSmtlib2String(String^ s, array<SortPtr>^ sorts, array<FuncDeclPtr>^ decls) {
|
|
PROCESS_SMTLIB2(Z3_exec_smtlib2_string);
|
|
}
|
|
|
|
TermPtr RawContext::ExecSmtlib2File(String^ s, array<SortPtr>^ sorts, array<FuncDeclPtr>^ decls) {
|
|
PROCESS_SMTLIB2(Z3_exec_smtlib2_file);
|
|
}
|
|
|
|
void RawContext::SetErrorHandler(IErrorHandler^ h) {
|
|
m_error_handler = h;
|
|
}
|
|
|
|
|
|
String^ RawContext::GetErrorMessage(ErrorCode h) {
|
|
Z3_error_code code;
|
|
switch(h) {
|
|
case ErrorCode::Ok: code = Z3_OK; break;
|
|
case ErrorCode::TypeError: code = Z3_SORT_ERROR; break;
|
|
case ErrorCode::IndexOutOfBounds: code = Z3_IOB; break;
|
|
case ErrorCode::InvalidArgument: code = Z3_INVALID_ARG; break;
|
|
case ErrorCode::ParserError: code = Z3_PARSER_ERROR; break;
|
|
case ErrorCode::NoParser: code = Z3_NO_PARSER; break;
|
|
case ErrorCode::InvalidUsage: code = Z3_INVALID_USAGE; break;
|
|
case ErrorCode::InternalFatal:
|
|
case ErrorCode::FileAccessError:
|
|
code = Z3_INVALID_ARG;
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
code = Z3_INVALID_ARG;
|
|
}
|
|
return gcnew String(Z3_get_error_msg(code));
|
|
}
|
|
|
|
void RawContext::ResetMemory() {
|
|
Z3_reset_memory();
|
|
}
|
|
|
|
String^ RawContext::ToString(AstPtr a) {
|
|
return gcnew String(Z3_ast_to_string(ctx(), get_ast(a)));
|
|
}
|
|
|
|
void RawContext::Display(System::IO::TextWriter^ w, AstPtr a) {
|
|
w->Write(ToString(a));
|
|
}
|
|
|
|
|
|
void RawContext::GetVersion(unsigned% major, unsigned% minor, unsigned% build_number, unsigned% version_number) {
|
|
unsigned ma, mi, bn, vn;
|
|
Z3_get_version(&ma,&mi,&bn,&vn);
|
|
major = ma;
|
|
minor = mi;
|
|
build_number = bn;
|
|
version_number = vn;
|
|
}
|
|
|
|
// -----------------------------
|
|
// Ast
|
|
|
|
Ast::Ast(RawContext^ c, AstPtr a) : m_ast(a), m_ctx(c) {
|
|
SASSERT(m_ast != IntPtr(0));
|
|
if (c->ref_context().is_ref_counted()) {
|
|
c->IncRef(a);
|
|
c->ref_context().inc_ref();
|
|
}
|
|
}
|
|
|
|
Ast::!Ast() {
|
|
if (m_ctx->ref_context().is_ref_counted()) {
|
|
m_ctx->EnqueueDecRef(m_ast);
|
|
}
|
|
}
|
|
|
|
Ast::~Ast() {}
|
|
|
|
bool Ast::Equals(Object^ obj) {
|
|
if (!obj) {
|
|
return false;
|
|
}
|
|
Ast^ a = dynamic_cast<Ast^>(obj);
|
|
if (!a) {
|
|
return false;
|
|
}
|
|
return a->GetPtr() == GetPtr();
|
|
}
|
|
|
|
int Ast::GetHashCode() {
|
|
return GetId();
|
|
}
|
|
|
|
String^ Ast::ToString() {
|
|
return m_ctx->ToString(m_ast);
|
|
}
|
|
|
|
int Ast::CompareTo(Object^ other) {
|
|
Ast^ a = dynamic_cast<Ast^>(other);
|
|
if (!a) {
|
|
return -1;
|
|
}
|
|
return GetId() - a->GetId();
|
|
}
|
|
|
|
#if 0
|
|
bool Ast::operator==(Object^ other) {
|
|
return this->Equals(other);
|
|
}
|
|
|
|
bool Ast::operator!=(Object^ other) {
|
|
return !this->Equals(other);
|
|
}
|
|
#endif
|
|
|
|
String^ Sort::GetName() {
|
|
return m_ctx->GetSymbolString(m_ctx->GetSortName(m_ast));
|
|
}
|
|
|
|
String^ FuncDecl::GetDeclName() {
|
|
return m_ctx->GetSymbolString(m_ctx->GetDeclName(m_ast));
|
|
}
|
|
|
|
DeclKind FuncDecl::GetKind() {
|
|
return m_ctx->GetDeclKind(m_ast);
|
|
}
|
|
|
|
// ----------------------------
|
|
// Term
|
|
// Assumption: contexts are equal
|
|
// Note: overloading && and || is possible,
|
|
// but C# does not seem to perform the
|
|
// correct type inference when they are used.
|
|
|
|
Term^ Term::operator!(Term^ t) {
|
|
return gcnew Term(t->m_ctx, t->m_ctx->MkNot(t()));
|
|
}
|
|
|
|
Term^ Term::operator+(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkAdd(t1(), t2()));
|
|
}
|
|
|
|
Term^ Term::operator^(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkXor(t1(), t2()));
|
|
}
|
|
|
|
Term^ Term::operator&(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkAnd(t1(), t2()));
|
|
}
|
|
|
|
Term^ Term::operator|(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkOr(t1(), t2()));
|
|
}
|
|
Term^ Term::operator*(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkMul(t1(), t2()));
|
|
}
|
|
|
|
Term^ Term::operator-(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkSub(t1(), t2()));
|
|
}
|
|
|
|
Term^ Term::operator/(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkDiv(t1(), t2()));
|
|
}
|
|
|
|
Term^ Term::operator<(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkLt(t1(), t2()));
|
|
}
|
|
|
|
Term^ Term::operator<=(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkLe(t1(), t2()));
|
|
}
|
|
|
|
Term^ Term::operator>(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkGt(t1(), t2()));
|
|
}
|
|
|
|
Term^ Term::operator>=(Term^ t1, Term^ t2) {
|
|
return gcnew Term(t1->m_ctx, t1->m_ctx->MkGe(t1(), t2()));
|
|
}
|
|
|
|
Term^ Term::operator[](Term^ index) {
|
|
return gcnew Term(m_ctx, m_ctx->MkArraySelect(m_ast, index()));
|
|
}
|
|
|
|
TermKind Term::GetKind() {
|
|
return m_ctx->GetTermKind(m_ast);
|
|
}
|
|
|
|
FuncDecl^ Term::GetAppDecl() {
|
|
return gcnew FuncDecl(m_ctx, m_ctx->GetAppDecl(m_ast));
|
|
}
|
|
|
|
array<Term^>^ Term::GetAppArgs() {
|
|
return Context::CopyTermArray(m_ctx, m_ctx->GetAppArgs(m_ast));
|
|
}
|
|
|
|
Sort^ Term::GetSort() {
|
|
return gcnew Sort(m_ctx, m_ctx->GetSort(m_ast));
|
|
}
|
|
|
|
String^ Term::GetNumeralString() {
|
|
return m_ctx->GetNumeralString(m_ast);
|
|
}
|
|
|
|
unsigned Term::GetVarIndex() {
|
|
return m_ctx->GetVarIndex(m_ast);
|
|
}
|
|
|
|
Quantifier^ Term::GetQuantifier() {
|
|
return Context::GetQuantifier(m_ctx, this);
|
|
}
|
|
// -----------------------------
|
|
// Context
|
|
|
|
|
|
LBool Context::CheckAndGetModel(Model^% m) {
|
|
RawModel^ md = nullptr;
|
|
LBool is_sat = m_ctx->CheckAndGetModel(md);
|
|
if (md ) {
|
|
m = gcnew Model(md, this);
|
|
}
|
|
else {
|
|
md = nullptr;
|
|
}
|
|
return is_sat;
|
|
}
|
|
|
|
LBool Context::CheckAssumptions(
|
|
Model^% m, array<Term^>^ assumptions, Term^% proof, array<Term^>^% core) {
|
|
RawModel^ md = nullptr;
|
|
array<TermPtr>^ _core = nullptr;
|
|
TermPtr _proof;
|
|
LBool is_sat = m_ctx->CheckAssumptions(md, CopyArray(assumptions), _proof, _core);
|
|
core = nullptr;
|
|
proof = nullptr;
|
|
m = nullptr;
|
|
if (md ) {
|
|
m = gcnew Model(md, this);
|
|
}
|
|
if (_proof != TermPtr()) {
|
|
proof = gcnew Term(m_ctx, _proof);
|
|
}
|
|
if (_core ) {
|
|
core = CopyTermArray(_core);
|
|
}
|
|
return is_sat;
|
|
}
|
|
|
|
void Context::SoftCheckCancel() {
|
|
m_ctx->SoftCheckCancel();
|
|
}
|
|
|
|
|
|
LBool Context::GetImpliedEqualities(
|
|
[In] array<Term^>^ terms,
|
|
[Out] array<unsigned>^% class_ids) {
|
|
return m_ctx->GetImpliedEqualities(CopyArray(terms), class_ids);
|
|
}
|
|
|
|
|
|
|
|
Quantifier^ Context::GetQuantifier(RawContext^ ctx, Term^ t) {
|
|
RawQuantifier^ q0 = ctx->GetQuantifier(t());
|
|
Quantifier^ q = gcnew Quantifier();
|
|
q->IsForall = q0->IsForall;
|
|
q->Weight = q0->Weight;
|
|
q->Patterns = gcnew array<Pattern^>(q0->Patterns->Length);
|
|
for (int i = 0; i < q0->Patterns->Length; ++i) {
|
|
q->Patterns[i] = gcnew Pattern(ctx, q0->Patterns[i]);
|
|
}
|
|
q->NoPatterns = gcnew array<Term^>(q0->NoPatterns->Length);
|
|
for (int i = 0; i < q0->NoPatterns->Length; ++i) {
|
|
q->NoPatterns[i] = gcnew Term(ctx, q0->Patterns[i]);
|
|
}
|
|
q->Names = q0->Names;
|
|
q->Body = gcnew Term(ctx, q0->Body);
|
|
q->Sorts = CopySortArray(ctx, q0->Sorts);
|
|
return q;
|
|
}
|
|
|
|
|
|
Sort^ Context::MkTupleSort(
|
|
Symbol^ mk_tuple_name,
|
|
array<Symbol^>^ field_names,
|
|
array<Sort^>^ field_types,
|
|
FuncDecl^% mk_tuple_decl,
|
|
array<FuncDecl^>^ proj_decl
|
|
) {
|
|
array<SortPtr>^ ftypes = gcnew array<SortPtr>(field_types->Length);
|
|
for (int i = 0; i < field_types->Length; ++i) {
|
|
ftypes[i] = field_types[i]();
|
|
}
|
|
array<FuncDeclPtr>^ pdecls = gcnew array<FuncDeclPtr>(proj_decl->Length);
|
|
FuncDeclPtr mk_tupled;
|
|
SortPtr res = m_ctx->MkTupleSort(mk_tuple_name, field_names, ftypes, mk_tupled, pdecls);
|
|
for (int i = 0; i < pdecls->Length; ++i) {
|
|
proj_decl[i] = gcnew FuncDecl(m_ctx,pdecls[i]);
|
|
}
|
|
mk_tuple_decl = gcnew FuncDecl(m_ctx,mk_tupled);
|
|
return gcnew Sort(m_ctx,res);
|
|
}
|
|
|
|
Sort^ Context::MkTupleSort(
|
|
String^ mk_tuple_name,
|
|
array<String^>^ field_names,
|
|
array<Sort^>^ field_types,
|
|
FuncDecl^% mk_tuple_decl,
|
|
array<FuncDecl^>^ proj_decl
|
|
) {
|
|
array<SortPtr>^ ftypes = gcnew array<SortPtr>(field_types->Length);
|
|
for (int i = 0; i < field_types->Length; ++i) {
|
|
ftypes[i] = field_types[i]();
|
|
}
|
|
array<FuncDeclPtr>^ pdecls = gcnew array<FuncDeclPtr>(proj_decl->Length);
|
|
FuncDeclPtr mk_tupled;
|
|
SortPtr res = m_ctx->MkTupleSort(mk_tuple_name, field_names, ftypes, mk_tupled, pdecls);
|
|
for (int i = 0; i < pdecls->Length; ++i) {
|
|
proj_decl[i] = gcnew FuncDecl(m_ctx,pdecls[i]);
|
|
}
|
|
mk_tuple_decl = gcnew FuncDecl(m_ctx,mk_tupled);
|
|
return gcnew Sort(m_ctx,res);
|
|
}
|
|
|
|
Sort^ Context::MkEnumerationSort(
|
|
String^ name,
|
|
array<String^>^ enum_names,
|
|
array<FuncDecl^>^ enum_consts,
|
|
array<FuncDecl^>^ enum_testers) {
|
|
|
|
array<FuncDeclPtr>^ _enum_consts = CopyArray(enum_consts);
|
|
array<FuncDeclPtr>^ _enum_testers = CopyArray(enum_testers);
|
|
|
|
SortPtr s = m_ctx->MkEnumerationSort(name, enum_names, _enum_consts, _enum_testers);
|
|
|
|
for (int i = 0; i < enum_consts->Length; ++i) {
|
|
enum_consts[i] = gcnew FuncDecl(m_ctx, _enum_consts[i]);
|
|
enum_testers[i] = gcnew FuncDecl(m_ctx, _enum_testers[i]);
|
|
}
|
|
return gcnew Sort(m_ctx, s);
|
|
}
|
|
|
|
Sort^ Context::MkListSort(
|
|
String^ name,
|
|
Sort^ elem_sort,
|
|
FuncDecl^% nil_decl,
|
|
FuncDecl^% is_nil_decl,
|
|
FuncDecl^% cons_decl,
|
|
FuncDecl^% is_cons_decl,
|
|
FuncDecl^% head_decl,
|
|
FuncDecl^% tail_decl
|
|
) {
|
|
FuncDeclPtr a, b, c, d, e, f;
|
|
SortPtr s = m_ctx->MkListSort(name, elem_sort(), a, b, c, d, e, f);
|
|
nil_decl = gcnew FuncDecl(m_ctx, a);
|
|
is_nil_decl = gcnew FuncDecl(m_ctx, b);
|
|
cons_decl = gcnew FuncDecl(m_ctx, c);
|
|
is_cons_decl = gcnew FuncDecl(m_ctx, d);
|
|
head_decl = gcnew FuncDecl(m_ctx, e);
|
|
tail_decl = gcnew FuncDecl(m_ctx, f);
|
|
return gcnew Sort(m_ctx, s);
|
|
}
|
|
|
|
Constructor^ Context::MkConstructor(
|
|
String^ name,
|
|
String^ tester,
|
|
array<String^>^ field_names,
|
|
array<Sort^>^ field_sorts,
|
|
array<unsigned>^ field_refs
|
|
) {
|
|
return m_ctx->MkConstructor(name, tester, field_names, CopyArray(field_sorts), field_refs);
|
|
}
|
|
|
|
|
|
FuncDecl^ Context::GetConstructor(Constructor^ c) {
|
|
return gcnew FuncDecl(m_ctx, m_ctx->GetConstructor(c));
|
|
}
|
|
|
|
FuncDecl^ Context::GetTester(Constructor^ c) {
|
|
return gcnew FuncDecl(m_ctx, m_ctx->GetTester(c));
|
|
}
|
|
|
|
array<FuncDecl^>^ Context::GetAccessors(Constructor^ c) {
|
|
array<FuncDeclPtr>^ result = m_ctx->GetAccessors(c);
|
|
return CopyAstArray<FuncDecl, FuncDeclPtr>(result);
|
|
}
|
|
|
|
|
|
bool Model::TryGetArrayValue(Term^ v, ArrayValue^% av) {
|
|
RawArrayValue^ _av = nullptr;
|
|
if (m_model->TryGetArrayValue(v(), _av)) {
|
|
av = gcnew ArrayValue();
|
|
av->ElseCase = gcnew Term(m_ctx->GetContext, _av->ElseCase);
|
|
av->Domain = m_ctx->CopyAstArray<Term>(_av->Domain);
|
|
av->Range = m_ctx->CopyAstArray<Term>(_av->Range);
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
array<IParameter^>^ Context::GetDeclParameters(FuncDecl^ d) {
|
|
Z3_context ctx = m_ctx->ctx();
|
|
Z3_func_decl fd = get_func_decl(d());
|
|
unsigned num_params = Z3_get_decl_num_parameters(ctx, fd);
|
|
array<IParameter^>^ params = gcnew array<IParameter^>(num_params);
|
|
for (unsigned i = 0; i < num_params; ++i) {
|
|
switch(Z3_get_decl_parameter_kind(ctx, fd, i)) {
|
|
case Z3_PARAMETER_INT:
|
|
params[i] = gcnew IntParameter(Z3_get_decl_int_parameter(ctx, fd, i));
|
|
break;
|
|
case Z3_PARAMETER_DOUBLE:
|
|
params[i] = gcnew DoubleParameter(Z3_get_decl_double_parameter(ctx, fd, i));
|
|
break;
|
|
case Z3_PARAMETER_RATIONAL: {
|
|
Z3_string s = Z3_get_decl_rational_parameter(ctx, fd, i);
|
|
params[i] = gcnew RationalParameter(gcnew String(s));
|
|
break;
|
|
}
|
|
case Z3_PARAMETER_SYMBOL: {
|
|
Z3_symbol s = Z3_get_decl_symbol_parameter(ctx, fd, i);
|
|
params[i] = gcnew SymbolParameter(gcnew Symbol(ctx, s));
|
|
break;
|
|
}
|
|
case Z3_PARAMETER_SORT:
|
|
params[i] = gcnew SortParameter(gcnew Sort(m_ctx,SortPtr(Z3_get_decl_sort_parameter(ctx, fd, i))));
|
|
break;
|
|
case Z3_PARAMETER_AST:
|
|
params[i] = gcnew TermParameter(gcnew Term(m_ctx,TermPtr(Z3_get_decl_ast_parameter(ctx, fd, i))));
|
|
break;
|
|
case Z3_PARAMETER_FUNC_DECL:
|
|
params[i] = gcnew FuncDeclParameter(gcnew FuncDecl(m_ctx, FuncDeclPtr(Z3_get_decl_func_decl_parameter(ctx, fd, i))));
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
}
|
|
return params;
|
|
}
|
|
|
|
String^ Context::BenchmarkToSmtlib(
|
|
String^ name,
|
|
String^ logic,
|
|
String^ status,
|
|
String^ attributes,
|
|
array<Term^>^ assumptions,
|
|
Term^ formula) {
|
|
return m_ctx->BenchmarkToSmtlib(name, logic, status, attributes, CopyArray(assumptions), formula());
|
|
}
|
|
|
|
void Context::ParseSmtlibString(
|
|
String^ string,
|
|
[In] array<Sort^>^ types,
|
|
[In] array<FuncDecl^>^ old_decls,
|
|
[Out] array<Term^>^% assumptions,
|
|
[Out] array<Term^>^% formulas,
|
|
[Out] array<FuncDecl^>^% new_decls,
|
|
[Out] array<Sort^>^% new_sorts,
|
|
[Out] String^% parser_out
|
|
) {
|
|
array<TermPtr>^ _assumptions = nullptr;
|
|
array<TermPtr>^ _formulas = nullptr;
|
|
array<FuncDeclPtr>^ _new_decls = nullptr;
|
|
array<SortPtr>^ _new_sorts = nullptr;
|
|
m_ctx->ParseSmtlibString(string, CopyArray(types), CopyArray(old_decls),
|
|
_assumptions, _formulas, _new_decls, _new_sorts, parser_out);
|
|
assumptions = CopyTermArray(_assumptions);
|
|
formulas = CopyTermArray(_formulas);
|
|
new_decls = CopyAstArray<FuncDecl, FuncDeclPtr>(_new_decls);
|
|
new_sorts = CopyAstArray<Sort, SortPtr>(_new_sorts);
|
|
}
|
|
|
|
|
|
void Context::ParseSmtlibFile(
|
|
String^ file,
|
|
[In] array<Sort^>^ types,
|
|
[In] array<FuncDecl^>^ old_decls,
|
|
[Out] array<Term^>^% assumptions,
|
|
[Out] array<Term^>^% formulas,
|
|
[Out] array<FuncDecl^>^% new_decls,
|
|
[Out] array<Sort^>^% new_sorts,
|
|
[Out] String^% parser_out
|
|
) {
|
|
array<TermPtr>^ _assumptions = nullptr;
|
|
array<TermPtr>^ _formulas = nullptr;
|
|
array<FuncDeclPtr>^ _new_decls = nullptr;
|
|
array<SortPtr>^ _new_sorts = nullptr;
|
|
m_ctx->ParseSmtlibFile(file, CopyArray(types), CopyArray(old_decls),
|
|
_assumptions, _formulas, _new_decls, _new_sorts, parser_out);
|
|
assumptions = CopyAstArray<Term,TermPtr>(_assumptions);
|
|
formulas = CopyAstArray<Term,TermPtr>(_formulas);
|
|
new_decls = CopyAstArray<FuncDecl, FuncDeclPtr>(_new_decls);
|
|
new_sorts = CopyAstArray<Sort, SortPtr>(_new_sorts);
|
|
}
|
|
|
|
// -----------------------------
|
|
// Model
|
|
|
|
ArrayValue^ Model::Mk(RawArrayValue^ av) {
|
|
ArrayValue^ res = gcnew ArrayValue();
|
|
res->Domain = m_ctx->CopyTermArray(av->Domain);
|
|
res->Range = m_ctx->CopyTermArray(av->Range);
|
|
res->ElseCase = gcnew Term(m_ctx->GetContext, av->ElseCase);
|
|
return res;
|
|
}
|
|
|
|
FunctionEntry^ Model::Mk(RawFunctionEntry^ fe) {
|
|
FunctionEntry^ res = gcnew FunctionEntry();
|
|
res->Arguments = m_ctx->CopyTermArray(fe->Arguments);
|
|
res->Result = gcnew Term(m_ctx->GetContext, fe->Result);
|
|
return res;
|
|
}
|
|
|
|
FunctionGraph^ Model::Mk(RawFunctionGraph^ fg) {
|
|
FunctionGraph^ res = gcnew FunctionGraph();
|
|
res->Declaration = gcnew FuncDecl(m_ctx->GetContext, fg->Declaration);
|
|
res->Entries = gcnew array<FunctionEntry^>(fg->Entries->Length);
|
|
for (int i = 0; i < fg->Entries->Length; ++i) {
|
|
res->Entries[i] = Mk(fg->Entries[i]);
|
|
}
|
|
res->Else = gcnew Term(m_ctx->GetContext, fg->Else);
|
|
return res;
|
|
}
|
|
|
|
Dictionary<FuncDecl^, FunctionGraph^>^ Model::Mk(Dictionary<FuncDeclPtr, RawFunctionGraph^>^ fgs) {
|
|
Dictionary<FuncDecl^, FunctionGraph^>^ res =
|
|
gcnew Dictionary<FuncDecl^, FunctionGraph^>();
|
|
|
|
Dictionary<FuncDeclPtr, RawFunctionGraph^>::Enumerator e = fgs->GetEnumerator();
|
|
while(e.MoveNext()) {
|
|
KeyValuePair<FuncDeclPtr, RawFunctionGraph^>^ kv = e.Current;
|
|
res->Add(gcnew FuncDecl(m_ctx->GetContext, kv->Key), Mk(kv->Value));
|
|
}
|
|
return res;
|
|
}
|
|
|
|
Theory^ Context::MkTheory(String^ name) {
|
|
return gcnew Theory(this, name);
|
|
}
|