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