nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 *
4 * Use of this software is governed by the GNU LGPLv2.1 license
5 *
6 * Written by Sven Verdoolaege, K.U.Leuven, Departement
7 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
8 */
9  
10 #include <isl_ctx_private.h>
11 #include <isl/seq.h>
12 #include <isl/vec.h>
13  
14 isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec)
15 {
16 return vec ? vec->ctx : NULL;
17 }
18  
19 struct isl_vec *isl_vec_alloc(struct isl_ctx *ctx, unsigned size)
20 {
21 struct isl_vec *vec;
22  
23 vec = isl_alloc_type(ctx, struct isl_vec);
24 if (!vec)
25 return NULL;
26  
27 vec->block = isl_blk_alloc(ctx, size);
28 if (isl_blk_is_error(vec->block))
29 goto error;
30  
31 vec->ctx = ctx;
32 isl_ctx_ref(ctx);
33 vec->ref = 1;
34 vec->size = size;
35 vec->el = vec->block.data;
36  
37 return vec;
38 error:
39 isl_blk_free(ctx, vec->block);
40 return NULL;
41 }
42  
43 __isl_give isl_vec *isl_vec_extend(__isl_take isl_vec *vec, unsigned size)
44 {
45 if (!vec)
46 return NULL;
47 if (size <= vec->size)
48 return vec;
49  
50 vec = isl_vec_cow(vec);
51 if (!vec)
52 return NULL;
53  
54 vec->block = isl_blk_extend(vec->ctx, vec->block, size);
55 if (!vec->block.data)
56 goto error;
57  
58 vec->size = size;
59 vec->el = vec->block.data;
60  
61 return vec;
62 error:
63 isl_vec_free(vec);
64 return NULL;
65 }
66  
67 __isl_give isl_vec *isl_vec_zero_extend(__isl_take isl_vec *vec, unsigned size)
68 {
69 int extra;
70  
71 if (!vec)
72 return NULL;
73 if (size <= vec->size)
74 return vec;
75  
76 vec = isl_vec_cow(vec);
77 if (!vec)
78 return NULL;
79  
80 extra = size - vec->size;
81 vec = isl_vec_extend(vec, size);
82 if (!vec)
83 return NULL;
84  
85 isl_seq_clr(vec->el + size - extra, extra);
86  
87 return vec;
88 }
89  
90 struct isl_vec *isl_vec_copy(struct isl_vec *vec)
91 {
92 if (!vec)
93 return NULL;
94  
95 vec->ref++;
96 return vec;
97 }
98  
99 struct isl_vec *isl_vec_dup(struct isl_vec *vec)
100 {
101 struct isl_vec *vec2;
102  
103 if (!vec)
104 return NULL;
105 vec2 = isl_vec_alloc(vec->ctx, vec->size);
106 isl_seq_cpy(vec2->el, vec->el, vec->size);
107 return vec2;
108 }
109  
110 struct isl_vec *isl_vec_cow(struct isl_vec *vec)
111 {
112 struct isl_vec *vec2;
113 if (!vec)
114 return NULL;
115  
116 if (vec->ref == 1)
117 return vec;
118  
119 vec2 = isl_vec_dup(vec);
120 isl_vec_free(vec);
121 return vec2;
122 }
123  
124 void isl_vec_free(struct isl_vec *vec)
125 {
126 if (!vec)
127 return;
128  
129 if (--vec->ref > 0)
130 return;
131  
132 isl_ctx_deref(vec->ctx);
133 isl_blk_free(vec->ctx, vec->block);
134 free(vec);
135 }
136  
137 int isl_vec_size(__isl_keep isl_vec *vec)
138 {
139 return vec ? vec->size : -1;
140 }
141  
142 int isl_vec_get_element(__isl_keep isl_vec *vec, int pos, isl_int *v)
143 {
144 if (!vec)
145 return -1;
146  
147 if (pos < 0 || pos >= vec->size)
148 isl_die(vec->ctx, isl_error_invalid, "position out of range",
149 return -1);
150 isl_int_set(*v, vec->el[pos]);
151 return 0;
152 }
153  
154 __isl_give isl_vec *isl_vec_set_element(__isl_take isl_vec *vec,
155 int pos, isl_int v)
156 {
157 vec = isl_vec_cow(vec);
158 if (!vec)
159 return NULL;
160 if (pos < 0 || pos >= vec->size)
161 isl_die(vec->ctx, isl_error_invalid, "position out of range",
162 goto error);
163 isl_int_set(vec->el[pos], v);
164 return vec;
165 error:
166 isl_vec_free(vec);
167 return NULL;
168 }
169  
170 __isl_give isl_vec *isl_vec_set_element_si(__isl_take isl_vec *vec,
171 int pos, int v)
172 {
173 vec = isl_vec_cow(vec);
174 if (!vec)
175 return NULL;
176 if (pos < 0 || pos >= vec->size)
177 isl_die(vec->ctx, isl_error_invalid, "position out of range",
178 goto error);
179 isl_int_set_si(vec->el[pos], v);
180 return vec;
181 error:
182 isl_vec_free(vec);
183 return NULL;
184 }
185  
186 int isl_vec_is_equal(__isl_keep isl_vec *vec1, __isl_keep isl_vec *vec2)
187 {
188 if (!vec1 || !vec2)
189 return -1;
190  
191 if (vec1->size != vec2->size)
192 return 0;
193  
194 return isl_seq_eq(vec1->el, vec2->el, vec1->size);
195 }
196  
197 __isl_give isl_printer *isl_printer_print_vec(__isl_take isl_printer *printer,
198 __isl_keep isl_vec *vec)
199 {
200 int i;
201  
202 if (!printer || !vec)
203 goto error;
204  
205 printer = isl_printer_print_str(printer, "[");
206 for (i = 0; i < vec->size; ++i) {
207 if (i)
208 printer = isl_printer_print_str(printer, ",");
209 printer = isl_printer_print_isl_int(printer, vec->el[i]);
210 }
211 printer = isl_printer_print_str(printer, "]");
212  
213 return printer;
214 error:
215 isl_printer_free(printer);
216 return NULL;
217 }
218  
219 void isl_vec_dump(struct isl_vec *vec)
220 {
221 isl_printer *printer;
222  
223 if (!vec)
224 return;
225  
226 printer = isl_printer_to_file(vec->ctx, stderr);
227 printer = isl_printer_print_vec(printer, vec);
228 printer = isl_printer_end_line(printer);
229  
230 isl_printer_free(printer);
231 }
232  
233 __isl_give isl_vec *isl_vec_set(__isl_take isl_vec *vec, isl_int v)
234 {
235 vec = isl_vec_cow(vec);
236 if (!vec)
237 return NULL;
238 isl_seq_set(vec->el, v, vec->size);
239 return vec;
240 }
241  
242 __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec, int v)
243 {
244 vec = isl_vec_cow(vec);
245 if (!vec)
246 return NULL;
247 isl_seq_set_si(vec->el, v, vec->size);
248 return vec;
249 }
250  
251 __isl_give isl_vec *isl_vec_clr(__isl_take isl_vec *vec)
252 {
253 vec = isl_vec_cow(vec);
254 if (!vec)
255 return NULL;
256 isl_seq_clr(vec->el, vec->size);
257 return vec;
258 }
259  
260 void isl_vec_lcm(struct isl_vec *vec, isl_int *lcm)
261 {
262 isl_seq_lcm(vec->block.data, vec->size, lcm);
263 }
264  
265 /* Given a rational vector, with the denominator in the first element
266 * of the vector, round up all coordinates.
267 */
268 struct isl_vec *isl_vec_ceil(struct isl_vec *vec)
269 {
270 vec = isl_vec_cow(vec);
271 if (!vec)
272 return NULL;
273  
274 isl_seq_cdiv_q(vec->el + 1, vec->el + 1, vec->el[0], vec->size - 1);
275  
276 isl_int_set_si(vec->el[0], 1);
277  
278 return vec;
279 }
280  
281 struct isl_vec *isl_vec_normalize(struct isl_vec *vec)
282 {
283 if (!vec)
284 return NULL;
285 isl_seq_normalize(vec->ctx, vec->el, vec->size);
286 return vec;
287 }
288  
289 __isl_give isl_vec *isl_vec_neg(__isl_take isl_vec *vec)
290 {
291 vec = isl_vec_cow(vec);
292 if (!vec)
293 return NULL;
294 isl_seq_neg(vec->el, vec->el, vec->size);
295 return vec;
296 }
297  
298 __isl_give isl_vec *isl_vec_scale(__isl_take isl_vec *vec, isl_int m)
299 {
300 if (isl_int_is_one(m))
301 return vec;
302 vec = isl_vec_cow(vec);
303 if (!vec)
304 return NULL;
305 isl_seq_scale(vec->el, vec->el, m, vec->size);
306 return vec;
307 }
308  
309 __isl_give isl_vec *isl_vec_add(__isl_take isl_vec *vec1,
310 __isl_take isl_vec *vec2)
311 {
312 vec1 = isl_vec_cow(vec1);
313 if (!vec1 || !vec2)
314 goto error;
315  
316 isl_assert(vec1->ctx, vec1->size == vec2->size, goto error);
317  
318 isl_seq_combine(vec1->el, vec1->ctx->one, vec1->el,
319 vec1->ctx->one, vec2->el, vec1->size);
320  
321 isl_vec_free(vec2);
322 return vec1;
323 error:
324 isl_vec_free(vec1);
325 isl_vec_free(vec2);
326 return NULL;
327 }
328  
329 static int qsort_int_cmp(const void *p1, const void *p2)
330 {
331 const isl_int *i1 = (const isl_int *) p1;
332 const isl_int *i2 = (const isl_int *) p2;
333  
334 return isl_int_cmp(*i1, *i2);
335 }
336  
337 __isl_give isl_vec *isl_vec_sort(__isl_take isl_vec *vec)
338 {
339 if (!vec)
340 return NULL;
341  
342 qsort(vec->el, vec->size, sizeof(*vec->el), &qsort_int_cmp);
343  
344 return vec;
345 }
346  
347 __isl_give isl_vec *isl_vec_drop_els(__isl_take isl_vec *vec,
348 unsigned pos, unsigned n)
349 {
350 if (n == 0)
351 return vec;
352 vec = isl_vec_cow(vec);
353 if (!vec)
354 return NULL;
355  
356 if (pos + n > vec->size)
357 isl_die(vec->ctx, isl_error_invalid,
358 "range out of bounds", goto error);
359  
360 if (pos + n != vec->size)
361 isl_seq_cpy(vec->el + pos, vec->el + pos + n,
362 vec->size - pos - n);
363  
364 vec->size -= n;
365  
366 return vec;
367 error:
368 isl_vec_free(vec);
369 return NULL;
370 }
371  
372 __isl_give isl_vec *isl_vec_insert_els(__isl_take isl_vec *vec,
373 unsigned pos, unsigned n)
374 {
375 isl_vec *ext = NULL;
376  
377 if (n == 0)
378 return vec;
379 if (!vec)
380 return NULL;
381  
382 if (pos > vec->size)
383 isl_die(vec->ctx, isl_error_invalid,
384 "position out of bounds", goto error);
385  
386 ext = isl_vec_alloc(vec->ctx, vec->size + n);
387 if (!ext)
388 goto error;
389  
390 isl_seq_cpy(ext->el, vec->el, pos);
391 isl_seq_cpy(ext->el + pos + n, vec->el + pos, vec->size - pos);
392  
393 isl_vec_free(vec);
394 return ext;
395 error:
396 isl_vec_free(vec);
397 isl_vec_free(ext);
398 return NULL;
399 }
400  
401 __isl_give isl_vec *isl_vec_insert_zero_els(__isl_take isl_vec *vec,
402 unsigned pos, unsigned n)
403 {
404 vec = isl_vec_insert_els(vec, pos, n);
405 if (!vec)
406 return NULL;
407  
408 isl_seq_clr(vec->el + pos, n);
409  
410 return vec;
411 }