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 266
Indexes created Tue Feb 24 08:35:24 UTC 2026