include/isl/ctx.h

   1 /*
   2  * Copyright 2008-2009 Katholieke Universiteit Leuven
   3  *
   4  * Use of this software is governed by the MIT license
   5  *
   6  * Written by Sven Verdoolaege, K.U.Leuven, Departement
   7  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
   8  */
   9
  10 #ifndef ISL_CTX_H
  11 #define ISL_CTX_H
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15
  16 #include <isl/arg.h>
  17
  18 #ifndef __isl_give
  19 #define __isl_give
  20 #endif
  21 #ifndef __isl_take
  22 #define __isl_take
  23 #endif
  24 #ifndef __isl_keep
  25 #define __isl_keep
  26 #endif
  27 #ifndef __isl_null
  28 #define __isl_null
  29 #endif
  30 #ifndef __isl_export
  31 #define __isl_export
  32 #endif
  33 #ifndef __isl_overload
  34 #define __isl_overload
  35 #endif
  36 #ifndef __isl_constructor
  37 #define __isl_constructor
  38 #endif
  39 #ifndef __isl_subclass
  40 #define __isl_subclass(super)
  41 #endif
  42
  43 #if defined(__cplusplus)
  44 extern "C" {
  45 #endif
  46
  47 /* Nearly all isa functions require a struct isl_ctx allocated using
  48  * isl_ctx_alloc.  This ctx contains (or will contain) options that
  49  * control the behavior of the library and some caches.
  50  *
  51  * An object allocated within a given ctx should never be used inside
  52  * another ctx.  Functions for moving objects from one ctx to another
  53  * will be added as the need arises.
  54  *
  55  * A given context should only be used inside a single thread.
  56  * A global context for synchronization between different threads
  57  * as well as functions for moving a context to a different thread
  58  * will be added as the need arises.
  59  *
  60  * If anything goes wrong (out of memory, failed assertion), then
  61  * the library will currently simply abort.  This will be made
  62  * configurable in the future.
  63  * Users of the library should expect functions that return
  64  * a pointer to a structure, to return NULL, indicating failure.
  65  * Any function accepting a pointer to a structure will treat
  66  * a NULL argument as a failure, resulting in the function freeing
  67  * the remaining structures (if any) and returning NULL itself
  68  * (in case of pointer return type).
  69  * The only exception is the isl_ctx argument, which should never be NULL.
  70  */
  71 struct isl_stats {
  72         long    gbr_solved_lps;
  73 };
  74 enum isl_error {
  75         isl_error_none = 0,
  76         isl_error_abort,
  77         isl_error_alloc,
  78         isl_error_unknown,
  79         isl_error_internal,
  80         isl_error_invalid,
  81         isl_error_quota,
  82         isl_error_unsupported
  83 };
  84 typedef enum {
  85         isl_stat_error = -1,
  86         isl_stat_ok = 0
  87 } isl_stat;
  88 isl_stat isl_stat_non_null(void *obj);
  89 typedef enum {
  90         isl_bool_error = -1,
  91         isl_bool_false = 0,
  92         isl_bool_true = 1
  93 } isl_bool;
  94 isl_bool isl_bool_not(isl_bool b);
  95 isl_bool isl_bool_ok(int b);
  96 typedef int     isl_size;
  97 #define isl_size_error  ((int) -1)
  98 struct isl_ctx;
  99 typedef struct isl_ctx isl_ctx;
 100
 101 /* Some helper macros */
 102
 103 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
 104 #define ISL_DEPRECATED  __attribute__((__deprecated__))
 105 #else
 106 #define ISL_DEPRECATED
 107 #endif
 108
 109 #define ISL_FL_INIT(l, f)   (l) = (f)               /* Specific flags location. */
 110 #define ISL_FL_SET(l, f)    ((l) |= (f))
 111 #define ISL_FL_CLR(l, f)    ((l) &= ~(f))
 112 #define ISL_FL_ISSET(l, f)  (!!((l) & (f)))
 113
 114 #define ISL_F_INIT(p, f)    ISL_FL_INIT((p)->flags, f)  /* Structure element flags. */
 115 #define ISL_F_SET(p, f)     ISL_FL_SET((p)->flags, f)
 116 #define ISL_F_CLR(p, f)     ISL_FL_CLR((p)->flags, f)
 117 #define ISL_F_ISSET(p, f)   ISL_FL_ISSET((p)->flags, f)
 118
 119 void *isl_malloc_or_die(isl_ctx *ctx, size_t size);
 120 void *isl_calloc_or_die(isl_ctx *ctx, size_t nmemb, size_t size);
 121 void *isl_realloc_or_die(isl_ctx *ctx, void *ptr, size_t size);
 122
 123 #define isl_alloc(ctx,type,size)        ((type *)isl_malloc_or_die(ctx, size))
 124 #define isl_calloc(ctx,type,size)       ((type *)isl_calloc_or_die(ctx,\
 125                                                                     1, size))
 126 #define isl_realloc(ctx,ptr,type,size)  ((type *)isl_realloc_or_die(ctx,\
 127                                                                     ptr, size))
 128 #define isl_alloc_type(ctx,type)        isl_alloc(ctx,type,sizeof(type))
 129 #define isl_calloc_type(ctx,type)       isl_calloc(ctx,type,sizeof(type))
 130 #define isl_realloc_type(ctx,ptr,type)  isl_realloc(ctx,ptr,type,sizeof(type))
 131 #define isl_alloc_array(ctx,type,n)     isl_alloc(ctx,type,(n)*sizeof(type))
 132 #define isl_calloc_array(ctx,type,n)    ((type *)isl_calloc_or_die(ctx,\
 133                                                             n, sizeof(type)))
 134 #define isl_realloc_array(ctx,ptr,type,n) \
 135                                     isl_realloc(ctx,ptr,type,(n)*sizeof(type))
 136
 137 #define isl_die(ctx,errno,msg,code)                                     \
 138         do {                                                            \
 139                 isl_handle_error(ctx, errno, msg, __FILE__, __LINE__);  \
 140                 code;                                                   \
 141         } while (0)
 142
 143 void isl_handle_error(isl_ctx *ctx, enum isl_error error, const char *msg,
 144         const char *file, int line);
 145
 146 #define isl_assert4(ctx,test,code,errno)                                \
 147         do {                                                            \
 148                 if (test)                                               \
 149                         break;                                          \
 150                 isl_die(ctx, errno, "Assertion \"" #test "\" failed", code);    \
 151         } while (0)
 152 #define isl_assert(ctx,test,code)                                       \
 153         isl_assert4(ctx,test,code,isl_error_unknown)
 154
 155 #define isl_min(a,b)                    ((a < b) ? (a) : (b))
 156
 157 /* struct isl_ctx functions */
 158
 159 struct isl_options *isl_ctx_options(isl_ctx *ctx);
 160
 161 isl_ctx *isl_ctx_alloc_with_options(struct isl_args *args,
 162         __isl_take void *opt);
 163 isl_ctx *isl_ctx_alloc(void);
 164 void *isl_ctx_peek_options(isl_ctx *ctx, struct isl_args *args);
 165 int isl_ctx_parse_options(isl_ctx *ctx, int argc, char **argv, unsigned flags);
 166 void isl_ctx_ref(struct isl_ctx *ctx);
 167 void isl_ctx_deref(struct isl_ctx *ctx);
 168 void isl_ctx_free(isl_ctx *ctx);
 169
 170 void isl_ctx_abort(isl_ctx *ctx);
 171 void isl_ctx_resume(isl_ctx *ctx);
 172 int isl_ctx_aborted(isl_ctx *ctx);
 173
 174 void isl_ctx_set_max_operations(isl_ctx *ctx, unsigned long max_operations);
 175 unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
 176 void isl_ctx_reset_operations(isl_ctx *ctx);
 177
 178 #define ISL_ARG_CTX_DECL(prefix,st,args)                                \
 179 st *isl_ctx_peek_ ## prefix(isl_ctx *ctx);
 180
 181 #define ISL_ARG_CTX_DEF(prefix,st,args)                                 \
 182 st *isl_ctx_peek_ ## prefix(isl_ctx *ctx)                               \
 183 {                                                                       \
 184         return (st *)isl_ctx_peek_options(ctx, &(args));                \
 185 }
 186
 187 #define ISL_CTX_GET_INT_DEF(prefix,st,args,field)                       \
 188 int prefix ## _get_ ## field(isl_ctx *ctx)                              \
 189 {                                                                       \
 190         st *options;                                                    \
 191         options = isl_ctx_peek_ ## prefix(ctx);                         \
 192         if (!options)                                                   \
 193                 isl_die(ctx, isl_error_invalid,                         \
 194                         "isl_ctx does not reference " #prefix,          \
 195                         return -1);                                     \
 196         return options->field;                                          \
 197 }
 198
 199 #define ISL_CTX_SET_INT_DEF(prefix,st,args,field)                       \
 200 isl_stat prefix ## _set_ ## field(isl_ctx *ctx, int val)                \
 201 {                                                                       \
 202         st *options;                                                    \
 203         options = isl_ctx_peek_ ## prefix(ctx);                         \
 204         if (!options)                                                   \
 205                 isl_die(ctx, isl_error_invalid,                         \
 206                         "isl_ctx does not reference " #prefix,          \
 207                         return isl_stat_error);                         \
 208         options->field = val;                                           \
 209         return isl_stat_ok;                                             \
 210 }
 211
 212 #define ISL_CTX_GET_STR_DEF(prefix,st,args,field)                       \
 213 const char *prefix ## _get_ ## field(isl_ctx *ctx)                      \
 214 {                                                                       \
 215         st *options;                                                    \
 216         options = isl_ctx_peek_ ## prefix(ctx);                         \
 217         if (!options)                                                   \
 218                 isl_die(ctx, isl_error_invalid,                         \
 219                         "isl_ctx does not reference " #prefix,          \
 220                         return NULL);                                   \
 221         return options->field;                                          \
 222 }
 223
 224 #define ISL_CTX_SET_STR_DEF(prefix,st,args,field)                       \
 225 isl_stat prefix ## _set_ ## field(isl_ctx *ctx, const char *val)        \
 226 {                                                                       \
 227         st *options;                                                    \
 228         options = isl_ctx_peek_ ## prefix(ctx);                         \
 229         if (!options)                                                   \
 230                 isl_die(ctx, isl_error_invalid,                         \
 231                         "isl_ctx does not reference " #prefix,          \
 232                         return isl_stat_error);                         \
 233         if (!val)                                                       \
 234                 return isl_stat_error;                                  \
 235         free(options->field);                                           \
 236         options->field = strdup(val);                                   \
 237         if (!options->field)                                            \
 238                 return isl_stat_error;                                  \
 239         return isl_stat_ok;                                             \
 240 }
 241
 242 #define ISL_CTX_GET_BOOL_DEF(prefix,st,args,field)                      \
 243         ISL_CTX_GET_INT_DEF(prefix,st,args,field)
 244
 245 #define ISL_CTX_SET_BOOL_DEF(prefix,st,args,field)                      \
 246         ISL_CTX_SET_INT_DEF(prefix,st,args,field)
 247
 248 #define ISL_CTX_GET_CHOICE_DEF(prefix,st,args,field)                    \
 249         ISL_CTX_GET_INT_DEF(prefix,st,args,field)
 250
 251 #define ISL_CTX_SET_CHOICE_DEF(prefix,st,args,field)                    \
 252         ISL_CTX_SET_INT_DEF(prefix,st,args,field)
 253
 254 enum isl_error isl_ctx_last_error(isl_ctx *ctx);
 255 const char *isl_ctx_last_error_msg(isl_ctx *ctx);
 256 const char *isl_ctx_last_error_file(isl_ctx *ctx);
 257 int isl_ctx_last_error_line(isl_ctx *ctx);
 258 void isl_ctx_reset_error(isl_ctx *ctx);
 259 void isl_ctx_set_error(isl_ctx *ctx, enum isl_error error);
 260
 261 #if defined(__cplusplus)
 262 }
 263 #endif
 264
 265 #endif