cpp/cpp-checked.h.pre

   1
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4
   5 #include <functional>
   6 #include <ostream>
   7 #include <string>
   8
   9 namespace isl {
  10 namespace checked {
  11
  12 #define ISLPP_STRINGIZE_(X) #X
  13 #define ISLPP_STRINGIZE(X) ISLPP_STRINGIZE_(X)
  14
  15 #define ISLPP_ASSERT(test, message)                          \
  16   do {                                                       \
  17     if (test)                                                \
  18       break;                                                 \
  19     fputs("Assertion \"" #test "\" failed at " __FILE__      \
  20       ":" ISLPP_STRINGIZE(__LINE__) "\n  " message "\n",     \
  21       stderr);                                               \
  22     abort();                                                 \
  23   } while (0)
  24
  25 class boolean {
  26 private:
  27   mutable bool checked = false;
  28   isl_bool val;
  29
  30   friend boolean manage(isl_bool val);
  31   boolean(isl_bool val): val(val) {}
  32 public:
  33   boolean()
  34       : val(isl_bool_error) {}
  35   ~boolean() {
  36     ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");
  37   }
  38
  39   /* implicit */ boolean(bool val)
  40       : val(val ? isl_bool_true : isl_bool_false) {}
  41
  42   bool is_error() const { checked = true; return val == isl_bool_error; }
  43   bool is_false() const { checked = true; return val == isl_bool_false; }
  44   bool is_true() const { checked = true; return val == isl_bool_true; }
  45
  46   explicit operator bool() const {
  47     ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked error state");
  48     ISLPP_ASSERT(!is_error(), "IMPLEMENTATION ERROR: Unhandled error state");
  49     return is_true();
  50   }
  51
  52   boolean operator!() const {
  53     if (is_error())
  54       return *this;
  55     return !is_true();
  56   }
  57 };
  58
  59 inline boolean manage(isl_bool val) {
  60   return boolean(val);
  61 }
  62
  63 class ctx {
  64   isl_ctx *ptr;
  65 public:
  66   /* implicit */ ctx(isl_ctx *ctx)
  67       : ptr(ctx) {}
  68   isl_ctx *release() {
  69     auto tmp = ptr;
  70     ptr = nullptr;
  71     return tmp;
  72   }
  73   isl_ctx *get() {
  74     return ptr;
  75   }
  76 };
  77
  78 /* Class encapsulating an isl_stat value.
  79  */
  80 class stat {
  81 private:
  82         mutable bool checked = false;
  83         isl_stat val;
  84
  85         friend stat manage(isl_stat val);
  86         constexpr stat(isl_stat val) : val(val) {}
  87 public:
  88         static stat ok() {
  89                 return stat(isl_stat_ok);
  90         }
  91         static stat error() {
  92                 return stat(isl_stat_error);
  93         }
  94         stat() : val(isl_stat_error) {}
  95         ~stat() {
  96                 ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");
  97         }
  98
  99         isl_stat release() {
 100                 checked = true;
 101                 return val;
 102         }
 103
 104         bool is_error() const {
 105                 checked = true;
 106                 return val == isl_stat_error;
 107         }
 108         bool is_ok() const {
 109                 checked = true;
 110                 return val == isl_stat_ok;
 111         }
 112 };
 113
 114 inline stat manage(isl_stat val)
 115 {
 116         return stat(val);
 117 }
 118
 119 /* Class encapsulating an isl_size value.
 120  */
 121 class size {
 122 private:
 123         mutable bool checked = false;
 124         isl_size val;
 125
 126         friend size manage(isl_size val);
 127         size(isl_size val) : val(val) {}
 128 public:
 129         size() : val(isl_size_error) {}
 130         ~size() {
 131                 ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");
 132         }
 133
 134         isl_size release() {
 135                 auto tmp = val;
 136                 val = isl_size_error;
 137                 checked = true;
 138                 return tmp;
 139         }
 140
 141         bool is_error() const {
 142                 checked = true;
 143                 return val == isl_size_error;
 144         }
 145
 146         explicit operator unsigned() const {
 147                 ISLPP_ASSERT(checked,
 148                             "IMPLEMENTATION ERROR: Unchecked error state");
 149                 ISLPP_ASSERT(!is_error(),
 150                             "IMPLEMENTATION ERROR: Unhandled error state");
 151                 return val;
 152         }
 153 };
 154
 155 inline size manage(isl_size val)
 156 {
 157         return size(val);
 158 }
 159
 160 }
 161 } // namespace isl