isl_pip: allow existentially quantified variables in the context
[isl.git] / isl_id.c
blobd5c7c7115792f112f108a5db5323a070247fdced
1 /*
2 * Copyright 2008-2009 Katholieke Universiteit Leuven
4 * Use of this software is governed by the MIT license
6 * Written by Sven Verdoolaege, K.U.Leuven, Departement
7 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
8 */
10 #include <string.h>
11 #include <isl_ctx_private.h>
12 #include <isl_id_private.h>
14 #undef BASE
15 #define BASE id
17 #include <isl_list_templ.c>
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.
23 isl_id isl_id_none = {
24 .ref = -1,
25 .ctx = NULL,
26 .name = "#none",
27 .user = NULL
30 isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id)
32 return id ? id->ctx : NULL;
35 void *isl_id_get_user(__isl_keep isl_id *id)
37 return id ? id->user : NULL;
40 const char *isl_id_get_name(__isl_keep isl_id *id)
42 return id ? id->name : NULL;
45 static __isl_give isl_id *id_alloc(isl_ctx *ctx, const char *name, void *user)
47 const char *copy = name ? strdup(name) : NULL;
48 isl_id *id;
50 if (name && !copy)
51 return NULL;
52 id = isl_calloc_type(ctx, struct isl_id);
53 if (!id)
54 goto error;
56 id->ctx = ctx;
57 isl_ctx_ref(id->ctx);
58 id->ref = 1;
59 id->name = copy;
60 id->user = user;
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);
68 return id;
69 error:
70 free((char *)copy);
71 return NULL;
74 uint32_t isl_id_get_hash(__isl_keep isl_id *id)
76 return id ? id->hash : 0;
79 struct isl_name_and_user {
80 const char *name;
81 void *user;
84 static int isl_id_has_name_and_user(const void *entry, const void *val)
86 isl_id *id = (isl_id *)entry;
87 struct isl_name_and_user *nu = (struct isl_name_and_user *) val;
89 if (id->user != nu->user)
90 return 0;
91 if (id->name == nu->name)
92 return 1;
93 if (!id->name || !nu->name)
94 return 0;
96 return !strcmp(id->name, nu->name);
99 __isl_give isl_id *isl_id_alloc(isl_ctx *ctx, const char *name, void *user)
101 struct isl_hash_table_entry *entry;
102 uint32_t id_hash;
103 struct isl_name_and_user nu = { name, user };
105 if (!ctx)
106 return NULL;
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;
125 /* If the id has a negative refcount, then it is a static isl_id
126 * which should not be changed.
128 __isl_give isl_id *isl_id_copy(isl_id *id)
130 if (!id)
131 return NULL;
133 if (id->ref < 0)
134 return id;
136 id->ref++;
137 return id;
140 /* Compare two isl_ids.
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.
146 int isl_id_cmp(__isl_keep isl_id *id1, __isl_keep isl_id *id2)
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;
161 if (id1->user < id2->user)
162 return -1;
163 else
164 return 1;
167 static int isl_id_eq(const void *entry, const void *name)
169 return entry == name;
172 uint32_t isl_hash_id(uint32_t hash, __isl_keep isl_id *id)
174 if (id)
175 isl_hash_hash(hash, id->hash);
177 return hash;
180 /* Replace the free_user callback by "free_user".
182 __isl_give isl_id *isl_id_set_free_user(__isl_take isl_id *id,
183 void (*free_user)(void *user))
185 if (!id)
186 return NULL;
188 id->free_user = free_user;
190 return id;
193 /* If the id has a negative refcount, then it is a static isl_id
194 * and should not be freed.
196 __isl_null isl_id *isl_id_free(__isl_take isl_id *id)
198 struct isl_hash_table_entry *entry;
200 if (!id)
201 return NULL;
203 if (id->ref < 0)
204 return NULL;
206 if (--id->ref > 0)
207 return NULL;
209 entry = isl_hash_table_find(id->ctx, &id->ctx->id_table, id->hash,
210 isl_id_eq, id, 0);
211 if (!entry)
212 isl_die(id->ctx, isl_error_unknown,
213 "unable to find id", (void)0);
214 else
215 isl_hash_table_remove(id->ctx, &id->ctx->id_table, entry);
217 if (id->free_user)
218 id->free_user(id->user);
220 free((char *)id->name);
221 isl_ctx_deref(id->ctx);
222 free(id);
224 return NULL;
227 __isl_give isl_printer *isl_printer_print_id(__isl_take isl_printer *p,
228 __isl_keep isl_id *id)
230 if (!id)
231 goto error;
233 if (id->name)
234 p = isl_printer_print_str(p, id->name);
235 if (id->user) {
236 char buffer[50];
237 snprintf(buffer, sizeof(buffer), "@%p", id->user);
238 p = isl_printer_print_str(p, buffer);
240 return p;
241 error:
242 isl_printer_free(p);
243 return NULL;