Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 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 |