isl_id.c

   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 #include <string.h>
  11 #include <isl_ctx_private.h>
  12 #include <isl_id_private.h>
  13
  14 #undef EL_BASE
  15 #define EL_BASE id
  16
  17 #include <isl_list_templ.c>
  18
  19 /* A special, static isl_id to use as domains (and ranges)
  20  * of sets and parameters domains.
  21  * The user should never get a hold on this isl_id.
  22  */
  23 isl_id isl_id_none = {
  24         .ref = -1,
  25         .ctx = NULL,
  26         .name = "#none",
  27         .user = NULL
  28 };
  29
  30 isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id)
  31 {
  32         return id ? id->ctx : NULL;
  33 }
  34
  35 void *isl_id_get_user(__isl_keep isl_id *id)
  36 {
  37         return id ? id->user : NULL;
  38 }
  39
  40 const char *isl_id_get_name(__isl_keep isl_id *id)
  41 {
  42         return id ? id->name : NULL;
  43 }
  44
  45 static __isl_give isl_id *id_alloc(isl_ctx *ctx, const char *name, void *user)
  46 {
  47         const char *copy = name ? strdup(name) : NULL;
  48         isl_id *id;
  49
  50         if (name && !copy)
  51                 return NULL;
  52         id = isl_calloc_type(ctx, struct isl_id);
  53         if (!id)
  54                 goto error;
  55
  56         id->ctx = ctx;
  57         isl_ctx_ref(id->ctx);
  58         id->ref = 1;
  59         id->name = copy;
  60         id->user = user;
  61
  62         id->hash = isl_hash_init();
  63         if (name)
  64                 id->hash = isl_hash_string(id->hash, name);
  65         else
  66                 id->hash = isl_hash_builtin(id->hash, user);
  67
  68         return id;
  69 error:
  70         free((char *)copy);
  71         return NULL;
  72 }
  73
  74 uint32_t isl_id_get_hash(__isl_keep isl_id *id)
  75 {
  76         return id ? id->hash : 0;
  77 }
  78
  79 struct isl_name_and_user {
  80         const char *name;
  81         void *user;
  82 };
  83
  84 static isl_bool isl_id_has_name_and_user(const void *entry, const void *val)
  85 {
  86         isl_id *id = (isl_id *)entry;
  87         struct isl_name_and_user *nu = (struct isl_name_and_user *) val;
  88
  89         if (id->user != nu->user)
  90                 return isl_bool_false;
  91         if (id->name == nu->name)
  92                 return isl_bool_true;
  93         if (!id->name || !nu->name)
  94                 return isl_bool_false;
  95
  96         return isl_bool_ok(!strcmp(id->name, nu->name));
  97 }
  98
  99 __isl_give isl_id *isl_id_alloc(isl_ctx *ctx, const char *name, void *user)
 100 {
 101         struct isl_hash_table_entry *entry;
 102         uint32_t id_hash;
 103         struct isl_name_and_user nu = { name, user };
 104
 105         if (!ctx)
 106                 return NULL;
 107
 108         id_hash = isl_hash_init();
 109         if (name)
 110                 id_hash = isl_hash_string(id_hash, name);
 111         else
 112                 id_hash = isl_hash_builtin(id_hash, user);
 113         entry = isl_hash_table_find(ctx, &ctx->id_table, id_hash,
 114                                         isl_id_has_name_and_user, &nu, 1);
 115         if (!entry)
 116                 return NULL;
 117         if (entry->data)
 118                 return isl_id_copy(entry->data);
 119         entry->data = id_alloc(ctx, name, user);
 120         if (!entry->data)
 121                 ctx->id_table.n--;
 122         return entry->data;
 123 }
 124
 125 /* If the id has a negative refcount, then it is a static isl_id
 126  * which should not be changed.
 127  */
 128 __isl_give isl_id *isl_id_copy(isl_id *id)
 129 {
 130         if (!id)
 131                 return NULL;
 132
 133         if (id->ref < 0)
 134                 return id;
 135
 136         id->ref++;
 137         return id;
 138 }
 139
 140 /* Compare two isl_ids.
 141  *
 142  * The order is fairly arbitrary.  We do keep the comparison of
 143  * the user pointers as a last resort since these pointer values
 144  * may not be stable across different systems or even different runs.
 145  */
 146 int isl_id_cmp(__isl_keep isl_id *id1, __isl_keep isl_id *id2)
 147 {
 148         if (id1 == id2)
 149                 return 0;
 150         if (!id1)
 151                 return -1;
 152         if (!id2)
 153                 return 1;
 154         if (!id1->name != !id2->name)
 155                 return !id1->name - !id2->name;
 156         if (id1->name) {
 157                 int cmp = strcmp(id1->name, id2->name);
 158                 if (cmp != 0)
 159                         return cmp;
 160         }
 161         if (id1->user < id2->user)
 162                 return -1;
 163         else
 164                 return 1;
 165 }
 166
 167 static isl_bool isl_id_eq(const void *entry, const void *name)
 168 {
 169         return isl_bool_ok(entry == name);
 170 }
 171
 172 uint32_t isl_hash_id(uint32_t hash, __isl_keep isl_id *id)
 173 {
 174         if (id)
 175                 isl_hash_hash(hash, id->hash);
 176
 177         return hash;
 178 }
 179
 180 /* Replace the free_user callback by "free_user".
 181  */
 182 __isl_give isl_id *isl_id_set_free_user(__isl_take isl_id *id,
 183         void (*free_user)(void *user))
 184 {
 185         if (!id)
 186                 return NULL;
 187
 188         id->free_user = free_user;
 189
 190         return id;
 191 }
 192
 193 /* If the id has a negative refcount, then it is a static isl_id
 194  * and should not be freed.
 195  */
 196 __isl_null isl_id *isl_id_free(__isl_take isl_id *id)
 197 {
 198         struct isl_hash_table_entry *entry;
 199
 200         if (!id)
 201                 return NULL;
 202
 203         if (id->ref < 0)
 204                 return NULL;
 205
 206         if (--id->ref > 0)
 207                 return NULL;
 208
 209         entry = isl_hash_table_find(id->ctx, &id->ctx->id_table, id->hash,
 210                                         isl_id_eq, id, 0);
 211         if (!entry)
 212                 return NULL;
 213         if (entry == isl_hash_table_entry_none)
 214                 isl_die(id->ctx, isl_error_unknown,
 215                         "unable to find id", (void)0);
 216         else
 217                 isl_hash_table_remove(id->ctx, &id->ctx->id_table, entry);
 218
 219         if (id->free_user)
 220                 id->free_user(id->user);
 221
 222         free((char *)id->name);
 223         isl_ctx_deref(id->ctx);
 224         free(id);
 225
 226         return NULL;
 227 }
 228
 229 __isl_give isl_printer *isl_printer_print_id(__isl_take isl_printer *p,
 230         __isl_keep isl_id *id)
 231 {
 232         if (!id)
 233                 goto error;
 234
 235         if (id->name)
 236                 p = isl_printer_print_str(p, id->name);
 237         if (id->user) {
 238                 char buffer[50];
 239                 snprintf(buffer, sizeof(buffer), "@%p", id->user);
 240                 p = isl_printer_print_str(p, buffer);
 241         }
 242         return p;
 243 error:
 244         isl_printer_free(p);
 245         return NULL;
 246 }
 247
 248 /* Read an isl_id from "s" based on its name.
 249  */
 250 __isl_give isl_id *isl_stream_read_id(__isl_keep isl_stream *s)
 251 {
 252         struct isl_token *tok;
 253         char *str;
 254         isl_ctx *ctx;
 255         isl_id *id;
 256
 257         if (!s)
 258                 return NULL;
 259         tok = isl_stream_next_token(s);
 260         if (!tok) {
 261                 isl_stream_error(s, NULL, "unexpected EOF");
 262                 return NULL;
 263         }
 264         ctx = isl_stream_get_ctx(s);
 265         str = isl_token_get_str(ctx, tok);
 266         isl_token_free(tok);
 267         if (!str)
 268                 return NULL;
 269         id = isl_id_alloc(ctx, str, NULL);
 270         free(str);
 271
 272         return id;
 273 }
 274
 275 /* Read an isl_id object from the string "str".
 276  */
 277 __isl_give isl_id *isl_id_read_from_str(isl_ctx *ctx, const char *str)
 278 {
 279         isl_id *id;
 280         isl_stream *s = isl_stream_new_str(ctx, str);
 281         if (!s)
 282                 return NULL;
 283         id = isl_stream_read_id(s);
 284         isl_stream_free(s);
 285         return id;
 286 }
 287
 288 /* Is "id1" (obviously) equal to "id2"?
 289  *
 290  * isl_id objects can be compared by pointer value, but
 291  * isl_multi_*_plain_is_equal needs an isl_*_plain_is_equal.
 292  */
 293 static isl_bool isl_id_plain_is_equal(__isl_keep isl_id *id1,
 294         __isl_keep isl_id *id2)
 295 {
 296         if (!id1 || !id2)
 297                 return isl_bool_error;
 298         return id1 == id2;
 299 }
 300
 301 #undef BASE
 302 #define BASE id
 303
 304 #include <isl_multi_no_domain_templ.c>
 305 #include <isl_multi_no_explicit_domain.c>
 306 #include <isl_multi_templ.c>