1/// These are automatically generated checked C++ bindings for isl.
2///
3/// isl is a library for computing with integer sets and maps described by
4/// Presburger formulas. On top of this, isl provides various tools for
5/// polyhedral compilation, ranging from dependence analysis over scheduling
6/// to AST generation.
7
8#ifndef ISL_CPP_CHECKED
9#define ISL_CPP_CHECKED
10
11#include <stdio.h>
12#include <stdlib.h>
13
14#include <functional>
15#include <memory>
16#include <ostream>
17#include <string>
18#include <type_traits>
19
20namespace isl {
21namespace checked {
22
23#define ISLPP_STRINGIZE_(X) #X
24#define ISLPP_STRINGIZE(X) ISLPP_STRINGIZE_(X)
25
26#define ISLPP_ASSERT(test, message)                          \
27  do {                                                       \
28    if (test)                                                \
29      break;                                                 \
30    fputs("Assertion \"" #test "\" failed at " __FILE__      \
31      ":" ISLPP_STRINGIZE(__LINE__) "\n  " message "\n",     \
32      stderr);                                               \
33    abort();                                                 \
34  } while (0)
35
36/* Class used to check that isl::checked::boolean,
37 * isl::checked::stat and isl::checked::size values are checked for errors.
38 */
39struct checker {
40	bool checked = false;
41	~checker() {
42		ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");
43	}
44};
45
46class boolean {
47private:
48  mutable std::shared_ptr<checker> check = std::make_shared<checker>();
49  isl_bool val;
50
51  friend boolean manage(isl_bool val);
52  boolean(isl_bool val): val(val) {}
53public:
54  static boolean error() {
55    return boolean(isl_bool_error);
56  }
57  boolean()
58      : val(isl_bool_error) {}
59
60  /* implicit */ boolean(bool val)
61      : val(val ? isl_bool_true : isl_bool_false) {}
62
63  isl_bool release() {
64    auto tmp = val;
65    val = isl_bool_error;
66    check->checked = true;
67    return tmp;
68  }
69
70  bool is_error() const { check->checked = true; return val == isl_bool_error; }
71  bool is_false() const { check->checked = true; return val == isl_bool_false; }
72  bool is_true() const { check->checked = true; return val == isl_bool_true; }
73
74  explicit operator bool() const {
75    ISLPP_ASSERT(check->checked, "IMPLEMENTATION ERROR: Unchecked error state");
76    ISLPP_ASSERT(!is_error(), "IMPLEMENTATION ERROR: Unhandled error state");
77    return is_true();
78  }
79
80  boolean negate() {
81    if (val == isl_bool_true)
82      val = isl_bool_false;
83    else if (val == isl_bool_false)
84      val = isl_bool_true;
85    return *this;
86  }
87
88  boolean operator!() const {
89    return boolean(*this).negate();
90  }
91};
92
93inline boolean manage(isl_bool val) {
94  return boolean(val);
95}
96
97class ctx {
98  isl_ctx *ptr;
99public:
100  /* implicit */ ctx(isl_ctx *ctx)
101      : ptr(ctx) {}
102  isl_ctx *release() {
103    auto tmp = ptr;
104    ptr = nullptr;
105    return tmp;
106  }
107  isl_ctx *get() {
108    return ptr;
109  }
110};
111
112/* Class encapsulating an isl_stat value.
113 */
114class stat {
115private:
116	mutable std::shared_ptr<checker> check = std::make_shared<checker>();
117	isl_stat val;
118
119	friend stat manage(isl_stat val);
120	stat(isl_stat val) : val(val) {}
121public:
122	static stat ok() {
123		return stat(isl_stat_ok);
124	}
125	static stat error() {
126		return stat(isl_stat_error);
127	}
128	stat() : val(isl_stat_error) {}
129
130	isl_stat release() {
131		check->checked = true;
132		return val;
133	}
134
135	bool is_error() const {
136		check->checked = true;
137		return val == isl_stat_error;
138	}
139	bool is_ok() const {
140		check->checked = true;
141		return val == isl_stat_ok;
142	}
143};
144
145inline stat manage(isl_stat val)
146{
147	return stat(val);
148}
149
150/* Class encapsulating an isl_size value.
151 */
152class size {
153private:
154	mutable std::shared_ptr<checker> check = std::make_shared<checker>();
155	isl_size val;
156
157	friend size manage(isl_size val);
158	size(isl_size val) : val(val) {}
159public:
160	size() : val(isl_size_error) {}
161
162	isl_size release() {
163		auto tmp = val;
164		val = isl_size_error;
165		check->checked = true;
166		return tmp;
167	}
168
169	bool is_error() const {
170		check->checked = true;
171		return val == isl_size_error;
172	}
173
174	explicit operator unsigned() const {
175		ISLPP_ASSERT(check->checked,
176			    "IMPLEMENTATION ERROR: Unchecked error state");
177		ISLPP_ASSERT(!is_error(),
178			    "IMPLEMENTATION ERROR: Unhandled error state");
179		return val;
180	}
181};
182
183inline size manage(isl_size val)
184{
185	return size(val);
186}
187
188}
189} // namespace isl
190
191