?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
doc: update to removal of piplib as a submodule
[isl.git] / isl_input.c
blobbecced6d9bbd94de4d7609af509f36af0f8cb241
1 /*
2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 * Copyright 2010 INRIA Saclay
4 *
5 * Use of this software is governed by the GNU LGPLv2.1 license
6 *
7 * Written by Sven Verdoolaege, K.U.Leuven, Departement
8 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
9 * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
10 * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
11 */
12
13 #include <ctype.h>
14 #include <stdio.h>
15 #include <string.h>
16 #include <strings.h>
17 #include <isl_set.h>
18 #include <isl_seq.h>
19 #include <isl_div.h>
20 #include "isl_stream.h"
21 #include "isl_map_private.h"
22 #include "isl_obj.h"
23 #include "isl_polynomial_private.h"
24
25 struct variable {
26 char *name;
27 int pos;
28 struct variable *next;
29 };
30
31 struct vars {
32 struct isl_ctx *ctx;
33 int n;
34 struct variable *v;
35 };
36
37 static struct vars *vars_new(struct isl_ctx *ctx)
38 {
39 struct vars *v;
40 v = isl_alloc_type(ctx, struct vars);
41 if (!v)
42 return NULL;
43 v->ctx = ctx;
44 v->n = 0;
45 v->v = NULL;
46 return v;
47 }
48
49 static void variable_free(struct variable *var)
50 {
51 while (var) {
52 struct variable *next = var->next;
53 free(var->name);
54 free(var);
55 var = next;
56 }
57 }
58
59 static void vars_free(struct vars *v)
60 {
61 if (!v)
62 return;
63 variable_free(v->v);
64 free(v);
65 }
66
67 static void vars_drop(struct vars *v, int n)
68 {
69 struct variable *var;
70
71 if (!v)
72 return;
73
74 v->n -= n;
75
76 var = v->v;
77 while (--n >= 0) {
78 struct variable *next = var->next;
79 free(var->name);
80 free(var);
81 var = next;
82 }
83 v->v = var;
84 }
85
86 static struct variable *variable_new(struct vars *v, const char *name, int len,
87 int pos)
88 {
89 struct variable *var;
90 var = isl_alloc_type(v->ctx, struct variable);
91 if (!var)
92 goto error;
93 var->name = strdup(name);
94 var->name[len] = '\0';
95 var->pos = pos;
96 var->next = v->v;
97 return var;
98 error:
99 variable_free(v->v);
100 return NULL;
101 }
102
103 static int vars_pos(struct vars *v, const char *s, int len)
104 {
105 int pos;
106 struct variable *q;
107
108 if (len == -1)
109 len = strlen(s);
110 for (q = v->v; q; q = q->next) {
111 if (strncmp(q->name, s, len) == 0 && q->name[len] == '\0')
112 break;
113 }
114 if (q)
115 pos = q->pos;
116 else {
117 pos = v->n;
118 v->v = variable_new(v, s, len, v->n);
119 if (!v->v)
120 return -1;
121 v->n++;
122 }
123 return pos;
124 }
125
126 static __isl_give isl_basic_map *set_name(__isl_take isl_basic_map *bmap,
127 enum isl_dim_type type, unsigned pos, char *name)
128 {
129 char *prime;
130
131 if (!bmap)
132 return NULL;
133 if (!name)
134 return bmap;
135
136 prime = strchr(name, '\'');
137 if (prime)
138 *prime = '\0';
139 bmap->dim = isl_dim_set_name(bmap->dim, type, pos, name);
140 if (prime)
141 *prime = '\'';
142
143 if (!bmap->dim)
144 goto error;
145
146 return bmap;
147 error:
148 isl_basic_map_free(bmap);
149 return NULL;
150 }
151
152 static struct isl_vec *accept_affine(struct isl_stream *s, struct vars *v)
153 {
154 struct isl_token *tok = NULL;
155 struct isl_vec *aff;
156 int sign = 1;
157
158 aff = isl_vec_alloc(v->ctx, 1 + v->n);
159 isl_seq_clr(aff->el, aff->size);
160 if (!aff)
161 return NULL;
162
163 for (;;) {
164 tok = isl_stream_next_token(s);
165 if (!tok) {
166 isl_stream_error(s, NULL, "unexpected EOF");
167 goto error;
168 }
169 if (tok->type == ISL_TOKEN_IDENT) {
170 int n = v->n;
171 int pos = vars_pos(v, tok->u.s, -1);
172 if (pos < 0)
173 goto error;
174 if (pos >= n) {
175 isl_stream_error(s, tok, "unknown identifier");
176 isl_token_free(tok);
177 goto error;
178 }
179 if (sign > 0)
180 isl_int_add_ui(aff->el[1 + pos],
181 aff->el[1 + pos], 1);
182 else
183 isl_int_sub_ui(aff->el[1 + pos],
184 aff->el[1 + pos], 1);
185 sign = 1;
186 } else if (tok->type == ISL_TOKEN_VALUE) {
187 struct isl_token *tok2;
188 int n = v->n;
189 int pos = -1;
190 tok2 = isl_stream_next_token(s);
191 if (tok2 && tok2->type == ISL_TOKEN_IDENT) {
192 pos = vars_pos(v, tok2->u.s, -1);
193 if (pos < 0)
194 goto error;
195 if (pos >= n) {
196 isl_stream_error(s, tok2,
197 "unknown identifier");
198 isl_token_free(tok);
199 isl_token_free(tok2);
200 goto error;
201 }
202 isl_token_free(tok2);
203 } else if (tok2)
204 isl_stream_push_token(s, tok2);
205 if (sign < 0)
206 isl_int_neg(tok->u.v, tok->u.v);
207 isl_int_add(aff->el[1 + pos],
208 aff->el[1 + pos], tok->u.v);
209 sign = 1;
210 } else if (tok->type == '-') {
211 sign = -sign;
212 } else if (tok->type == '+') {
213 /* nothing */
214 } else {
215 isl_stream_push_token(s, tok);
216 break;
217 }
218 isl_token_free(tok);
219 }
220
221 return aff;
222 error:
223 isl_vec_free(aff);
224 return NULL;
225 }
226
227 static __isl_give isl_basic_map *read_var_list(struct isl_stream *s,
228 __isl_take isl_basic_map *bmap, enum isl_dim_type type, struct vars *v)
229 {
230 int i = 0;
231 struct isl_token *tok;
232
233 while ((tok = isl_stream_next_token(s)) != NULL) {
234 int new_name = 0;
235
236 if (tok->type == ISL_TOKEN_IDENT) {
237 int n = v->n;
238 int p = vars_pos(v, tok->u.s, -1);
239 if (p < 0)
240 goto error;
241 new_name = p >= n;
242 }
243
244 if (new_name) {
245 bmap = isl_basic_map_add(bmap, type, 1);
246 bmap = set_name(bmap, type, i, v->v->name);
247 isl_token_free(tok);
248 } else if (tok->type == ISL_TOKEN_IDENT ||
249 tok->type == ISL_TOKEN_VALUE) {
250 struct isl_vec *vec;
251 int k;
252 if (type == isl_dim_param) {
253 isl_stream_error(s, tok,
254 "expecting unique identifier");
255 goto error;
256 }
257 isl_stream_push_token(s, tok);
258 tok = NULL;
259 vec = accept_affine(s, v);
260 if (!vec)
261 goto error;
262 v->v = variable_new(v, "", 0, v->n);
263 if (!v->v)
264 goto error;
265 v->n++;
266 bmap = isl_basic_map_add(bmap, type, 1);
267 bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
268 k = isl_basic_map_alloc_equality(bmap);
269 if (k >= 0) {
270 isl_seq_cpy(bmap->eq[k], vec->el, vec->size);
271 isl_int_set_si(bmap->eq[k][vec->size], -1);
272 }
273 isl_vec_free(vec);
274 if (k < 0)
275 goto error;
276 } else
277 break;
278
279 tok = isl_stream_next_token(s);
280 if (!tok || tok->type != ',')
281 break;
282
283 isl_token_free(tok);
284 i++;
285 }
286 if (tok)
287 isl_stream_push_token(s, tok);
288
289 return bmap;
290 error:
291 isl_token_free(tok);
292 isl_basic_map_free(bmap);
293 return NULL;
294 }
295
296 static __isl_give isl_mat *accept_affine_list(struct isl_stream *s,
297 struct vars *v)
298 {
299 struct isl_vec *vec;
300 struct isl_mat *mat;
301 struct isl_token *tok = NULL;
302
303 vec = accept_affine(s, v);
304 mat = isl_mat_from_row_vec(vec);
305 if (!mat)
306 return NULL;
307
308 for (;;) {
309 tok = isl_stream_next_token(s);
310 if (!tok) {
311 isl_stream_error(s, NULL, "unexpected EOF");
312 goto error;
313 }
314 if (tok->type != ',') {
315 isl_stream_push_token(s, tok);
316 break;
317 }
318 isl_token_free(tok);
319
320 vec = accept_affine(s, v);
321 mat = isl_mat_vec_concat(mat, vec);
322 if (!mat)
323 return NULL;
324 }
325
326 return mat;
327 error:
328 isl_mat_free(mat);
329 return NULL;
330 }
331
332 static struct isl_basic_map *add_div_definition(struct isl_stream *s,
333 struct vars *v, struct isl_basic_map *bmap, int k)
334 {
335 struct isl_token *tok;
336 int seen_paren = 0;
337 struct isl_vec *aff;
338
339 if (isl_stream_eat(s, '['))
340 goto error;
341
342 tok = isl_stream_next_token(s);
343 if (!tok)
344 goto error;
345 if (tok->type == '(') {
346 seen_paren = 1;
347 isl_token_free(tok);
348 } else
349 isl_stream_push_token(s, tok);
350
351 aff = accept_affine(s, v);
352 if (!aff)
353 goto error;
354
355 isl_seq_cpy(bmap->div[k] + 1, aff->el, aff->size);
356
357 isl_vec_free(aff);
358
359 if (seen_paren && isl_stream_eat(s, ')'))
360 goto error;
361 if (isl_stream_eat(s, '/'))
362 goto error;
363
364 tok = isl_stream_next_token(s);
365 if (!tok)
366 goto error;
367 if (tok->type != ISL_TOKEN_VALUE) {
368 isl_stream_error(s, tok, "expected denominator");
369 isl_stream_push_token(s, tok);
370 goto error;
371 }
372 isl_int_set(bmap->div[k][0], tok->u.v);
373 isl_token_free(tok);
374
375 if (isl_stream_eat(s, ']'))
376 goto error;
377
378 if (isl_basic_map_add_div_constraints(bmap, k) < 0)
379 goto error;
380
381 return bmap;
382 error:
383 isl_basic_map_free(bmap);
384 return NULL;
385 }
386
387 static struct isl_basic_map *read_defined_var_list(struct isl_stream *s,
388 struct vars *v, struct isl_basic_map *bmap)
389 {
390 struct isl_token *tok;
391
392 while ((tok = isl_stream_next_token(s)) != NULL) {
393 int k;
394 int p;
395 int n = v->n;
396 unsigned total = isl_basic_map_total_dim(bmap);
397
398 if (tok->type != ISL_TOKEN_IDENT)
399 break;
400
401 p = vars_pos(v, tok->u.s, -1);
402 if (p < 0)
403 goto error;
404 if (p < n) {
405 isl_stream_error(s, tok, "expecting unique identifier");
406 goto error;
407 }
408 isl_token_free(tok);
409
410 bmap = isl_basic_map_cow(bmap);
411 bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim),
412 1, 0, 2);
413
414 if ((k = isl_basic_map_alloc_div(bmap)) < 0)
415 goto error;
416 isl_seq_clr(bmap->div[k], 1 + 1 + total);
417
418 tok = isl_stream_next_token(s);
419 if (tok && tok->type == '=') {
420 isl_token_free(tok);
421 bmap = add_div_definition(s, v, bmap, k);
422 tok = isl_stream_next_token(s);
423 }
424
425 if (!tok || tok->type != ',')
426 break;
427
428 isl_token_free(tok);
429 }
430 if (tok)
431 isl_stream_push_token(s, tok);
432
433 return bmap;
434 error:
435 isl_token_free(tok);
436 isl_basic_map_free(bmap);
437 return NULL;
438 }
439
440 static __isl_give isl_basic_map *read_tuple(struct isl_stream *s,
441 __isl_take isl_basic_map *bmap, enum isl_dim_type type, struct vars *v)
442 {
443 struct isl_token *tok;
444
445 tok = isl_stream_next_token(s);
446 if (!tok || tok->type != '[') {
447 isl_stream_error(s, tok, "expecting '['");
448 goto error;
449 }
450 isl_token_free(tok);
451 bmap = read_var_list(s, bmap, type, v);
452 tok = isl_stream_next_token(s);
453 if (!tok || tok->type != ']') {
454 isl_stream_error(s, tok, "expecting ']'");
455 goto error;
456 }
457 isl_token_free(tok);
458
459 return bmap;
460 error:
461 if (tok)
462 isl_token_free(tok);
463 isl_basic_map_free(bmap);
464 return NULL;
465 }
466
467 static struct isl_basic_map *add_constraints(struct isl_stream *s,
468 struct vars *v, struct isl_basic_map *bmap);
469
470 static struct isl_basic_map *add_exists(struct isl_stream *s,
471 struct vars *v, struct isl_basic_map *bmap)
472 {
473 struct isl_token *tok;
474 int n = v->n;
475 int extra;
476 int seen_paren = 0;
477 int i;
478 unsigned total;
479
480 tok = isl_stream_next_token(s);
481 if (!tok)
482 goto error;
483 if (tok->type == '(') {
484 seen_paren = 1;
485 isl_token_free(tok);
486 } else
487 isl_stream_push_token(s, tok);
488
489 bmap = read_defined_var_list(s, v, bmap);
490 if (!bmap)
491 goto error;
492
493 if (isl_stream_eat(s, ':'))
494 goto error;
495 bmap = add_constraints(s, v, bmap);
496 if (seen_paren && isl_stream_eat(s, ')'))
497 goto error;
498 return bmap;
499 error:
500 isl_basic_map_free(bmap);
501 return NULL;
502 }
503
504 static __isl_give isl_basic_map *construct_constraint(
505 __isl_take isl_basic_map *bmap, enum isl_token_type type,
506 isl_int *left, isl_int *right)
507 {
508 int k;
509 unsigned len;
510 struct isl_ctx *ctx;
511
512 if (!bmap)
513 return NULL;
514 len = 1 + isl_basic_map_total_dim(bmap);
515 ctx = bmap->ctx;
516
517 k = isl_basic_map_alloc_inequality(bmap);
518 if (k < 0)
519 goto error;
520 if (type == ISL_TOKEN_LE)
521 isl_seq_combine(bmap->ineq[k], ctx->negone, left,
522 ctx->one, right,
523 len);
524 else if (type == ISL_TOKEN_GE)
525 isl_seq_combine(bmap->ineq[k], ctx->one, left,
526 ctx->negone, right,
527 len);
528 else if (type == ISL_TOKEN_LT) {
529 isl_seq_combine(bmap->ineq[k], ctx->negone, left,
530 ctx->one, right,
531 len);
532 isl_int_sub_ui(bmap->ineq[k][0], bmap->ineq[k][0], 1);
533 } else if (type == ISL_TOKEN_GT) {
534 isl_seq_combine(bmap->ineq[k], ctx->one, left,
535 ctx->negone, right,
536 len);
537 isl_int_sub_ui(bmap->ineq[k][0], bmap->ineq[k][0], 1);
538 } else {
539 isl_seq_combine(bmap->ineq[k], ctx->one, left,
540 ctx->negone, right,
541 len);
542 isl_basic_map_inequality_to_equality(bmap, k);
543 }
544
545 return bmap;
546 error:
547 isl_basic_map_free(bmap);
548 return NULL;
549 }
550
551 static int is_comparator(struct isl_token *tok)
552 {
553 if (!tok)
554 return 0;
555
556 switch (tok->type) {
557 case ISL_TOKEN_LT:
558 case ISL_TOKEN_GT:
559 case ISL_TOKEN_LE:
560 case ISL_TOKEN_GE:
561 case '=':
562 return 1;
563 default:
564 return 0;
565 }
566 }
567
568 static struct isl_basic_map *add_constraint(struct isl_stream *s,
569 struct vars *v, struct isl_basic_map *bmap)
570 {
571 int i, j;
572 unsigned total = isl_basic_map_total_dim(bmap);
573 struct isl_token *tok = NULL;
574 struct isl_mat *aff1 = NULL, *aff2 = NULL;
575
576 tok = isl_stream_next_token(s);
577 if (!tok)
578 goto error;
579 if (tok->type == ISL_TOKEN_EXISTS) {
580 isl_token_free(tok);
581 return add_exists(s, v, bmap);
582 }
583 isl_stream_push_token(s, tok);
584 tok = NULL;
585
586 bmap = isl_basic_map_cow(bmap);
587
588 aff1 = accept_affine_list(s, v);
589 if (!aff1)
590 goto error;
591 tok = isl_stream_next_token(s);
592 if (!is_comparator(tok)) {
593 isl_stream_error(s, tok, "missing operator");
594 if (tok)
595 isl_stream_push_token(s, tok);
596 tok = NULL;
597 goto error;
598 }
599 isl_assert(aff1->ctx, aff1->n_col == 1 + total, goto error);
600 for (;;) {
601 aff2 = accept_affine_list(s, v);
602 if (!aff2)
603 goto error;
604 isl_assert(aff2->ctx, aff2->n_col == 1 + total, goto error);
605
606 bmap = isl_basic_map_extend_constraints(bmap, 0,
607 aff1->n_row * aff2->n_row);
608 for (i = 0; i < aff1->n_row; ++i)
609 for (j = 0; j < aff2->n_row; ++j)
610 bmap = construct_constraint(bmap, tok->type,
611 aff1->row[i], aff2->row[j]);
612 isl_token_free(tok);
613 isl_mat_free(aff1);
614 aff1 = aff2;
615
616 tok = isl_stream_next_token(s);
617 if (!is_comparator(tok)) {
618 if (tok)
619 isl_stream_push_token(s, tok);
620 break;
621 }
622 }
623 isl_mat_free(aff1);
624
625 return bmap;
626 error:
627 if (tok)
628 isl_token_free(tok);
629 isl_mat_free(aff1);
630 isl_mat_free(aff2);
631 isl_basic_map_free(bmap);
632 return NULL;
633 }
634
635 static struct isl_basic_map *add_constraints(struct isl_stream *s,
636 struct vars *v, struct isl_basic_map *bmap)
637 {
638 struct isl_token *tok;
639
640 for (;;) {
641 bmap = add_constraint(s, v, bmap);
642 if (!bmap)
643 return NULL;
644 tok = isl_stream_next_token(s);
645 if (!tok) {
646 isl_stream_error(s, NULL, "unexpected EOF");
647 goto error;
648 }
649 if (tok->type != ISL_TOKEN_AND)
650 break;
651 isl_token_free(tok);
652 }
653 isl_stream_push_token(s, tok);
654
655 return bmap;
656 error:
657 if (tok)
658 isl_token_free(tok);
659 isl_basic_map_free(bmap);
660 return NULL;
661 }
662
663 static struct isl_basic_map *read_disjunct(struct isl_stream *s,
664 struct vars *v, __isl_take isl_dim *dim)
665 {
666 int seen_paren = 0;
667 struct isl_token *tok;
668 struct isl_basic_map *bmap;
669
670 bmap = isl_basic_map_alloc_dim(dim, 0, 0, 0);
671 if (!bmap)
672 return NULL;
673
674 tok = isl_stream_next_token(s);
675 if (!tok)
676 goto error;
677 if (tok->type == '(') {
678 seen_paren = 1;
679 isl_token_free(tok);
680 } else
681 isl_stream_push_token(s, tok);
682
683 bmap = add_constraints(s, v, bmap);
684 bmap = isl_basic_map_simplify(bmap);
685 bmap = isl_basic_map_finalize(bmap);
686
687 if (seen_paren && isl_stream_eat(s, ')'))
688 goto error;
689
690 return bmap;
691 error:
692 isl_basic_map_free(bmap);
693 return NULL;
694 }
695
696 static struct isl_map *read_disjuncts(struct isl_stream *s,
697 struct vars *v, __isl_take isl_dim *dim)
698 {
699 struct isl_token *tok;
700 struct isl_map *map;
701
702 tok = isl_stream_next_token(s);
703 if (!tok) {
704 isl_stream_error(s, NULL, "unexpected EOF");
705 goto error;
706 }
707 if (tok->type == '}') {
708 isl_stream_push_token(s, tok);
709 return isl_map_universe(dim);
710 }
711 isl_stream_push_token(s, tok);
712
713 map = isl_map_empty(isl_dim_copy(dim));
714 for (;;) {
715 struct isl_basic_map *bmap;
716 int n = v->n;
717
718 bmap = read_disjunct(s, v, isl_dim_copy(dim));
719 map = isl_map_union(map, isl_map_from_basic_map(bmap));
720
721 vars_drop(v, v->n - n);
722
723 tok = isl_stream_next_token(s);
724 if (!tok || tok->type != ISL_TOKEN_OR)
725 break;
726 isl_token_free(tok);
727 }
728 if (tok)
729 isl_stream_push_token(s, tok);
730
731 isl_dim_free(dim);
732 return map;
733 error:
734 isl_dim_free(dim);
735 return NULL;
736 }
737
738 static int polylib_pos_to_isl_pos(__isl_keep isl_basic_map *bmap, int pos)
739 {
740 if (pos < isl_basic_map_dim(bmap, isl_dim_out))
741 return 1 + isl_basic_map_dim(bmap, isl_dim_param) +
742 isl_basic_map_dim(bmap, isl_dim_in) + pos;
743 pos -= isl_basic_map_dim(bmap, isl_dim_out);
744
745 if (pos < isl_basic_map_dim(bmap, isl_dim_in))
746 return 1 + isl_basic_map_dim(bmap, isl_dim_param) + pos;
747 pos -= isl_basic_map_dim(bmap, isl_dim_in);
748
749 if (pos < isl_basic_map_dim(bmap, isl_dim_div))
750 return 1 + isl_basic_map_dim(bmap, isl_dim_param) +
751 isl_basic_map_dim(bmap, isl_dim_in) +
752 isl_basic_map_dim(bmap, isl_dim_out) + pos;
753 pos -= isl_basic_map_dim(bmap, isl_dim_div);
754
755 if (pos < isl_basic_map_dim(bmap, isl_dim_param))
756 return 1 + pos;
757
758 return 0;
759 }
760
761 static __isl_give isl_basic_map *basic_map_read_polylib_constraint(
762 struct isl_stream *s, __isl_take isl_basic_map *bmap)
763 {
764 int j;
765 struct isl_token *tok;
766 int type;
767 int k;
768 isl_int *c;
769 unsigned nparam;
770 unsigned dim;
771
772 if (!bmap)
773 return NULL;
774
775 nparam = isl_basic_map_dim(bmap, isl_dim_param);
776 dim = isl_basic_map_dim(bmap, isl_dim_out);
777
778 tok = isl_stream_next_token(s);
779 if (!tok || tok->type != ISL_TOKEN_VALUE) {
780 isl_stream_error(s, tok, "expecting coefficient");
781 if (tok)
782 isl_stream_push_token(s, tok);
783 goto error;
784 }
785 if (!tok->on_new_line) {
786 isl_stream_error(s, tok, "coefficient should appear on new line");
787 isl_stream_push_token(s, tok);
788 goto error;
789 }
790
791 type = isl_int_get_si(tok->u.v);
792 isl_token_free(tok);
793
794 isl_assert(s->ctx, type == 0 || type == 1, goto error);
795 if (type == 0) {
796 k = isl_basic_map_alloc_equality(bmap);
797 c = bmap->eq[k];
798 } else {
799 k = isl_basic_map_alloc_inequality(bmap);
800 c = bmap->ineq[k];
801 }
802 if (k < 0)
803 goto error;
804
805 for (j = 0; j < 1 + isl_basic_map_total_dim(bmap); ++j) {
806 int pos;
807 tok = isl_stream_next_token(s);
808 if (!tok || tok->type != ISL_TOKEN_VALUE) {
809 isl_stream_error(s, tok, "expecting coefficient");
810 if (tok)
811 isl_stream_push_token(s, tok);
812 goto error;
813 }
814 if (tok->on_new_line) {
815 isl_stream_error(s, tok,
816 "coefficient should not appear on new line");
817 isl_stream_push_token(s, tok);
818 goto error;
819 }
820 pos = polylib_pos_to_isl_pos(bmap, j);
821 isl_int_set(c[pos], tok->u.v);
822 isl_token_free(tok);
823 }
824
825 return bmap;
826 error:
827 isl_basic_map_free(bmap);
828 return NULL;
829 }
830
831 static __isl_give isl_basic_map *basic_map_read_polylib(struct isl_stream *s,
832 int nparam)
833 {
834 int i;
835 struct isl_token *tok;
836 struct isl_token *tok2;
837 int n_row, n_col;
838 int on_new_line;
839 unsigned in = 0, out, local = 0;
840 struct isl_basic_map *bmap = NULL;
841
842 if (nparam < 0)
843 nparam = 0;
844
845 tok = isl_stream_next_token(s);
846 if (!tok) {
847 isl_stream_error(s, NULL, "unexpected EOF");
848 return NULL;
849 }
850 tok2 = isl_stream_next_token(s);
851 if (!tok2) {
852 isl_token_free(tok);
853 isl_stream_error(s, NULL, "unexpected EOF");
854 return NULL;
855 }
856 n_row = isl_int_get_si(tok->u.v);
857 n_col = isl_int_get_si(tok2->u.v);
858 on_new_line = tok2->on_new_line;
859 isl_token_free(tok2);
860 isl_token_free(tok);
861 isl_assert(s->ctx, !on_new_line, return NULL);
862 isl_assert(s->ctx, n_row >= 0, return NULL);
863 isl_assert(s->ctx, n_col >= 2 + nparam, return NULL);
864 tok = isl_stream_next_token_on_same_line(s);
865 if (tok) {
866 if (tok->type != ISL_TOKEN_VALUE) {
867 isl_stream_error(s, tok,
868 "expecting number of output dimensions");
869 isl_stream_push_token(s, tok);
870 goto error;
871 }
872 out = isl_int_get_si(tok->u.v);
873 isl_token_free(tok);
874
875 tok = isl_stream_next_token_on_same_line(s);
876 if (!tok || tok->type != ISL_TOKEN_VALUE) {
877 isl_stream_error(s, tok,
878 "expecting number of input dimensions");
879 if (tok)
880 isl_stream_push_token(s, tok);
881 goto error;
882 }
883 in = isl_int_get_si(tok->u.v);
884 isl_token_free(tok);
885
886 tok = isl_stream_next_token_on_same_line(s);
887 if (!tok || tok->type != ISL_TOKEN_VALUE) {
888 isl_stream_error(s, tok,
889 "expecting number of existentials");
890 if (tok)
891 isl_stream_push_token(s, tok);
892 goto error;
893 }
894 local = isl_int_get_si(tok->u.v);
895 isl_token_free(tok);
896
897 tok = isl_stream_next_token_on_same_line(s);
898 if (!tok || tok->type != ISL_TOKEN_VALUE) {
899 isl_stream_error(s, tok,
900 "expecting number of parameters");
901 if (tok)
902 isl_stream_push_token(s, tok);
903 goto error;
904 }
905 nparam = isl_int_get_si(tok->u.v);
906 isl_token_free(tok);
907 if (n_col != 1 + out + in + local + nparam + 1) {
908 isl_stream_error(s, NULL,
909 "dimensions don't match");
910 goto error;
911 }
912 } else
913 out = n_col - 2 - nparam;
914 bmap = isl_basic_map_alloc(s->ctx, nparam, in, out, local, n_row, n_row);
915 if (!bmap)
916 return NULL;
917
918 for (i = 0; i < local; ++i) {
919 int k = isl_basic_map_alloc_div(bmap);
920 if (k < 0)
921 goto error;
922 }
923
924 for (i = 0; i < n_row; ++i)
925 bmap = basic_map_read_polylib_constraint(s, bmap);
926
927 tok = isl_stream_next_token_on_same_line(s);
928 if (tok) {
929 isl_stream_error(s, tok, "unexpected extra token on line");
930 isl_stream_push_token(s, tok);
931 goto error;
932 }
933
934 bmap = isl_basic_map_simplify(bmap);
935 bmap = isl_basic_map_finalize(bmap);
936 return bmap;
937 error:
938 isl_basic_map_free(bmap);
939 return NULL;
940 }
941
942 static struct isl_map *map_read_polylib(struct isl_stream *s, int nparam)
943 {
944 struct isl_token *tok;
945 struct isl_token *tok2;
946 int i, n;
947 struct isl_map *map;
948
949 tok = isl_stream_next_token(s);
950 if (!tok) {
951 isl_stream_error(s, NULL, "unexpected EOF");
952 return NULL;
953 }
954 tok2 = isl_stream_next_token_on_same_line(s);
955 if (tok2) {
956 isl_stream_push_token(s, tok2);
957 isl_stream_push_token(s, tok);
958 return isl_map_from_basic_map(basic_map_read_polylib(s, nparam));
959 }
960 n = isl_int_get_si(tok->u.v);
961 isl_token_free(tok);
962
963 isl_assert(s->ctx, n >= 1, return NULL);
964
965 map = isl_map_from_basic_map(basic_map_read_polylib(s, nparam));
966
967 for (i = 1; i < n; ++i)
968 map = isl_map_union(map,
969 isl_map_from_basic_map(basic_map_read_polylib(s, nparam)));
970
971 return map;
972 }
973
974 static int optional_power(struct isl_stream *s)
975 {
976 int pow;
977 struct isl_token *tok;
978
979 tok = isl_stream_next_token(s);
980 if (!tok)
981 return 1;
982 if (tok->type != '^') {
983 isl_stream_push_token(s, tok);
984 return 1;
985 }
986 isl_token_free(tok);
987 tok = isl_stream_next_token(s);
988 if (!tok || tok->type != ISL_TOKEN_VALUE) {
989 isl_stream_error(s, tok, "expecting exponent");
990 if (tok)
991 isl_stream_push_token(s, tok);
992 return 1;
993 }
994 pow = isl_int_get_si(tok->u.v);
995 isl_token_free(tok);
996 return pow;
997 }
998
999 static __isl_give isl_div *read_div(struct isl_stream *s,
1000 __isl_keep isl_basic_map *bmap, struct vars *v)
1001 {
1002 unsigned total = isl_basic_map_total_dim(bmap);
1003 int k;
1004
1005 bmap = isl_basic_map_copy(bmap);
1006 bmap = isl_basic_map_cow(bmap);
1007 bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim),
1008 1, 0, 2);
1009
1010 if ((k = isl_basic_map_alloc_div(bmap)) < 0)
1011 goto error;
1012 isl_seq_clr(bmap->div[k], 1 + 1 + total);
1013 bmap = add_div_definition(s, v, bmap, k);
1014
1015 return isl_basic_map_div(bmap, k);
1016 error:
1017 isl_basic_map_free(bmap);
1018 return NULL;
1019 }
1020
1021 static __isl_give isl_qpolynomial *read_term(struct isl_stream *s,
1022 __isl_keep isl_basic_map *bmap, struct vars *v);
1023
1024 static __isl_give isl_qpolynomial *read_factor(struct isl_stream *s,
1025 __isl_keep isl_basic_map *bmap, struct vars *v)
1026 {
1027 struct isl_qpolynomial *qp;
1028 struct isl_token *tok;
1029
1030 tok = isl_stream_next_token(s);
1031 if (!tok) {
1032 isl_stream_error(s, NULL, "unexpected EOF");
1033 return NULL;
1034 }
1035 if (tok->type == '(') {
1036 isl_token_free(tok);
1037 qp = read_term(s, bmap, v);
1038 if (!qp)
1039 return NULL;
1040 if (isl_stream_eat(s, ')'))
1041 goto error;
1042 } else if (tok->type == ISL_TOKEN_VALUE) {
1043 struct isl_token *tok2;
1044 tok2 = isl_stream_next_token(s);
1045 if (tok2 && tok2->type == '/') {
1046 isl_token_free(tok2);
1047 tok2 = isl_stream_next_token(s);
1048 if (!tok2 || tok2->type != ISL_TOKEN_VALUE) {
1049 isl_stream_error(s, tok2, "expected denominator");
1050 isl_token_free(tok);
1051 isl_token_free(tok2);
1052 return NULL;
1053 }
1054 qp = isl_qpolynomial_rat_cst(isl_basic_map_get_dim(bmap),
1055 tok->u.v, tok2->u.v);
1056 isl_token_free(tok2);
1057 } else {
1058 isl_stream_push_token(s, tok2);
1059 qp = isl_qpolynomial_cst(isl_basic_map_get_dim(bmap),
1060 tok->u.v);
1061 }
1062 isl_token_free(tok);
1063 } else if (tok->type == ISL_TOKEN_INFTY) {
1064 isl_token_free(tok);
1065 qp = isl_qpolynomial_infty(isl_basic_map_get_dim(bmap));
1066 } else if (tok->type == ISL_TOKEN_NAN) {
1067 isl_token_free(tok);
1068 qp = isl_qpolynomial_nan(isl_basic_map_get_dim(bmap));
1069 } else if (tok->type == ISL_TOKEN_IDENT) {
1070 int n = v->n;
1071 int pos = vars_pos(v, tok->u.s, -1);
1072 int pow;
1073 isl_token_free(tok);
1074 if (pos < 0)
1075 goto error;
1076 if (pos >= n) {
1077 isl_stream_error(s, tok, "unknown identifier");
1078 return NULL;
1079 }
1080 pow = optional_power(s);
1081 qp = isl_qpolynomial_pow(isl_basic_map_get_dim(bmap), pos, pow);
1082 } else if (tok->type == '[') {
1083 isl_div *div;
1084 int pow;
1085
1086 isl_stream_push_token(s, tok);
1087 div = read_div(s, bmap, v);
1088 pow = optional_power(s);
1089 qp = isl_qpolynomial_div_pow(div, pow);
1090 } else if (tok->type == '-') {
1091 struct isl_qpolynomial *qp2;
1092
1093 isl_token_free(tok);
1094 qp = isl_qpolynomial_cst(isl_basic_map_get_dim(bmap),
1095 s->ctx->negone);
1096 qp2 = read_factor(s, bmap, v);
1097 qp = isl_qpolynomial_mul(qp, qp2);
1098 } else {
1099 isl_stream_error(s, tok, "unexpected isl_token");
1100 isl_stream_push_token(s, tok);
1101 return NULL;
1102 }
1103
1104 if (isl_stream_eat_if_available(s, '*') ||
1105 isl_stream_next_token_is(s, ISL_TOKEN_IDENT)) {
1106 struct isl_qpolynomial *qp2;
1107
1108 qp2 = read_factor(s, bmap, v);
1109 qp = isl_qpolynomial_mul(qp, qp2);
1110 }
1111
1112 return qp;
1113 error:
1114 isl_qpolynomial_free(qp);
1115 return NULL;
1116 }
1117
1118 static __isl_give isl_qpolynomial *read_term(struct isl_stream *s,
1119 __isl_keep isl_basic_map *bmap, struct vars *v)
1120 {
1121 struct isl_token *tok;
1122 struct isl_qpolynomial *qp;
1123
1124 qp = read_factor(s, bmap, v);
1125
1126 for (;;) {
1127 tok = isl_stream_next_token(s);
1128 if (!tok)
1129 return qp;
1130
1131 if (tok->type == '+') {
1132 struct isl_qpolynomial *qp2;
1133
1134 isl_token_free(tok);
1135 qp2 = read_factor(s, bmap, v);
1136 qp = isl_qpolynomial_add(qp, qp2);
1137 } else if (tok->type == '-') {
1138 struct isl_qpolynomial *qp2;
1139
1140 isl_token_free(tok);
1141 qp2 = read_factor(s, bmap, v);
1142 qp = isl_qpolynomial_sub(qp, qp2);
1143 } else if (tok->type == ISL_TOKEN_VALUE &&
1144 isl_int_is_neg(tok->u.v)) {
1145 struct isl_qpolynomial *qp2;
1146
1147 qp2 = isl_qpolynomial_cst(isl_basic_map_get_dim(bmap),
1148 tok->u.v);
1149 isl_token_free(tok);
1150 qp = isl_qpolynomial_add(qp, qp2);
1151 } else {
1152 isl_stream_push_token(s, tok);
1153 break;
1154 }
1155 }
1156
1157 return qp;
1158 }
1159
1160 static __isl_give isl_map *read_optional_disjuncts(struct isl_stream *s,
1161 __isl_take isl_basic_map *bmap, struct vars *v)
1162 {
1163 struct isl_token *tok;
1164 struct isl_map *map;
1165
1166 tok = isl_stream_next_token(s);
1167 if (!tok) {
1168 isl_stream_error(s, NULL, "unexpected EOF");
1169 goto error;
1170 }
1171 map = isl_map_from_basic_map(isl_basic_map_copy(bmap));
1172 if (tok->type == ':') {
1173 isl_token_free(tok);
1174 map = isl_map_intersect(map,
1175 read_disjuncts(s, v, isl_basic_map_get_dim(bmap)));
1176 } else
1177 isl_stream_push_token(s, tok);
1178
1179 isl_basic_map_free(bmap);
1180
1181 return map;
1182 error:
1183 isl_basic_map_free(bmap);
1184 return NULL;
1185 }
1186
1187 static struct isl_obj obj_read_poly(struct isl_stream *s,
1188 __isl_take isl_basic_map *bmap, struct vars *v, int n)
1189 {
1190 struct isl_obj obj = { isl_obj_pw_qpolynomial, NULL };
1191 struct isl_pw_qpolynomial *pwqp;
1192 struct isl_qpolynomial *qp;
1193 struct isl_map *map;
1194 struct isl_set *set;
1195
1196 bmap = isl_basic_map_reverse(bmap);
1197
1198 qp = read_term(s, bmap, v);
1199 map = read_optional_disjuncts(s, bmap, v);
1200 set = isl_set_from_map(map);
1201
1202 pwqp = isl_pw_qpolynomial_alloc(set, qp);
1203
1204 vars_drop(v, v->n - n);
1205
1206 obj.v = pwqp;
1207 return obj;
1208 }
1209
1210 static struct isl_obj obj_read_body(struct isl_stream *s,
1211 __isl_take isl_basic_map *bmap, struct vars *v, isl_obj_type type)
1212 {
1213 struct isl_map *map = NULL;
1214 struct isl_token *tok;
1215 struct isl_obj obj = { type, NULL };
1216 int n = v->n;
1217
1218 if (!isl_stream_next_token_is(s, '['))
1219 return obj_read_poly(s, bmap, v, n);
1220
1221 bmap = read_tuple(s, bmap, isl_dim_in, v);
1222 if (!bmap)
1223 goto error;
1224 tok = isl_stream_next_token(s);
1225 if (tok && tok->type == ISL_TOKEN_TO) {
1226 obj.type = isl_obj_map;
1227 isl_token_free(tok);
1228 tok = isl_stream_next_token(s);
1229 if (tok && tok->type != '[') {
1230 isl_stream_push_token(s, tok);
1231 return obj_read_poly(s, bmap, v, n);
1232 }
1233 isl_stream_push_token(s, tok);
1234 bmap = read_tuple(s, bmap, isl_dim_out, v);
1235 if (!bmap)
1236 goto error;
1237 } else {
1238 bmap = isl_basic_map_reverse(bmap);
1239 if (tok)
1240 isl_stream_push_token(s, tok);
1241 }
1242
1243 map = read_optional_disjuncts(s, bmap, v);
1244
1245 vars_drop(v, v->n - n);
1246
1247 obj.v = map;
1248 return obj;
1249 error:
1250 isl_basic_map_free(bmap);
1251 obj.type = isl_obj_none;
1252 return obj;
1253 }
1254
1255 static struct isl_obj obj_add(struct isl_ctx *ctx,
1256 struct isl_obj obj1, struct isl_obj obj2)
1257 {
1258 isl_assert(ctx, obj1.type == obj2.type, goto error);
1259 obj1.v = obj1.type->add(obj1.v, obj2.v);
1260 return obj1;
1261 error:
1262 obj1.type->free(obj1.v);
1263 obj2.type->free(obj2.v);
1264 obj1.type = isl_obj_none;
1265 obj1.v = NULL;
1266 return obj1;
1267 }
1268
1269 static struct isl_obj obj_read(struct isl_stream *s, int nparam)
1270 {
1271 struct isl_basic_map *bmap = NULL;
1272 struct isl_token *tok;
1273 struct vars *v = NULL;
1274 struct isl_obj obj = { isl_obj_set, NULL };
1275
1276 tok = isl_stream_next_token(s);
1277 if (!tok) {
1278 isl_stream_error(s, NULL, "unexpected EOF");
1279 goto error;
1280 }
1281 if (tok->type == ISL_TOKEN_VALUE) {
1282 struct isl_map *map;
1283 isl_stream_push_token(s, tok);
1284 map = map_read_polylib(s, nparam);
1285 if (!map)
1286 goto error;
1287 if (isl_map_dim(map, isl_dim_in) > 0)
1288 obj.type = isl_obj_map;
1289 obj.v = map;
1290 return obj;
1291 }
1292 v = vars_new(s->ctx);
1293 bmap = isl_basic_map_alloc(s->ctx, 0, 0, 0, 0, 0, 0);
1294 if (tok->type == '[') {
1295 isl_stream_push_token(s, tok);
1296 bmap = read_tuple(s, bmap, isl_dim_param, v);
1297 if (!bmap)
1298 goto error;
1299 if (nparam >= 0)
1300 isl_assert(s->ctx, nparam == v->n, goto error);
1301 tok = isl_stream_next_token(s);
1302 if (!tok || tok->type != ISL_TOKEN_TO) {
1303 isl_stream_error(s, tok, "expecting '->'");
1304 if (tok)
1305 isl_stream_push_token(s, tok);
1306 goto error;
1307 }
1308 isl_token_free(tok);
1309 tok = isl_stream_next_token(s);
1310 } if (nparam > 0)
1311 bmap = isl_basic_map_add(bmap, isl_dim_param, nparam);
1312 if (!tok || tok->type != '{') {
1313 isl_stream_error(s, tok, "expecting '{'");
1314 if (tok)
1315 isl_stream_push_token(s, tok);
1316 goto error;
1317 }
1318 isl_token_free(tok);
1319
1320 for (;;) {
1321 struct isl_obj o;
1322 tok = NULL;
1323 o = obj_read_body(s, isl_basic_map_copy(bmap), v, obj.type);
1324 if (o.type == isl_obj_none)
1325 break;
1326 if (!obj.v)
1327 obj = o;
1328 else {
1329 obj = obj_add(s->ctx, obj, o);
1330 if (obj.type == isl_obj_none)
1331 break;
1332 }
1333 tok = isl_stream_next_token(s);
1334 if (!tok || tok->type != ';')
1335 break;
1336 isl_token_free(tok);
1337 }
1338
1339 if (tok && tok->type == '}') {
1340 isl_token_free(tok);
1341 } else {
1342 isl_stream_error(s, tok, "unexpected isl_token");
1343 if (tok)
1344 isl_token_free(tok);
1345 goto error;
1346 }
1347 vars_free(v);
1348 isl_basic_map_free(bmap);
1349
1350 return obj;
1351 error:
1352 isl_basic_map_free(bmap);
1353 obj.type->free(obj.v);
1354 if (v)
1355 vars_free(v);
1356 obj.v = NULL;
1357 return obj;
1358 }
1359
1360 struct isl_obj isl_stream_read_obj(struct isl_stream *s)
1361 {
1362 return obj_read(s, -1);
1363 }
1364
1365 static struct isl_basic_map *basic_map_read(struct isl_stream *s, int nparam)
1366 {
1367 struct isl_obj obj;
1368 struct isl_map *map;
1369 struct isl_basic_map *bmap;
1370
1371 obj = obj_read(s, nparam);
1372 map = obj.v;
1373 if (!map)
1374 return NULL;
1375
1376 isl_assert(map->ctx, map->n <= 1, goto error);
1377
1378 if (map->n == 0)
1379 bmap = isl_basic_map_empty_like_map(map);
1380 else
1381 bmap = isl_basic_map_copy(map->p[0]);
1382
1383 isl_map_free(map);
1384
1385 return bmap;
1386 error:
1387 isl_map_free(map);
1388 return NULL;
1389 }
1390
1391 __isl_give isl_basic_map *isl_basic_map_read_from_file(isl_ctx *ctx,
1392 FILE *input, int nparam)
1393 {
1394 struct isl_basic_map *bmap;
1395 struct isl_stream *s = isl_stream_new_file(ctx, input);
1396 if (!s)
1397 return NULL;
1398 bmap = basic_map_read(s, nparam);
1399 isl_stream_free(s);
1400 return bmap;
1401 }
1402
1403 __isl_give isl_basic_set *isl_basic_set_read_from_file(isl_ctx *ctx,
1404 FILE *input, int nparam)
1405 {
1406 struct isl_basic_map *bmap;
1407 bmap = isl_basic_map_read_from_file(ctx, input, nparam);
1408 if (!bmap)
1409 return NULL;
1410 isl_assert(ctx, isl_basic_map_n_in(bmap) == 0, goto error);
1411 return (struct isl_basic_set *)bmap;
1412 error:
1413 isl_basic_map_free(bmap);
1414 return NULL;
1415 }
1416
1417 struct isl_basic_map *isl_basic_map_read_from_str(struct isl_ctx *ctx,
1418 const char *str, int nparam)
1419 {
1420 struct isl_basic_map *bmap;
1421 struct isl_stream *s = isl_stream_new_str(ctx, str);
1422 if (!s)
1423 return NULL;
1424 bmap = basic_map_read(s, nparam);
1425 isl_stream_free(s);
1426 return bmap;
1427 }
1428
1429 struct isl_basic_set *isl_basic_set_read_from_str(struct isl_ctx *ctx,
1430 const char *str, int nparam)
1431 {
1432 struct isl_basic_map *bmap;
1433 bmap = isl_basic_map_read_from_str(ctx, str, nparam);
1434 if (!bmap)
1435 return NULL;
1436 isl_assert(ctx, isl_basic_map_n_in(bmap) == 0, goto error);
1437 return (struct isl_basic_set *)bmap;
1438 error:
1439 isl_basic_map_free(bmap);
1440 return NULL;
1441 }
1442
1443 __isl_give isl_map *isl_map_read_from_file(struct isl_ctx *ctx,
1444 FILE *input, int nparam)
1445 {
1446 struct isl_obj obj;
1447 struct isl_map *map;
1448 struct isl_stream *s = isl_stream_new_file(ctx, input);
1449 if (!s)
1450 return NULL;
1451 obj = obj_read(s, nparam);
1452 isl_stream_free(s);
1453 return obj.v;
1454 }
1455
1456 __isl_give isl_map *isl_map_read_from_str(struct isl_ctx *ctx,
1457 const char *str, int nparam)
1458 {
1459 struct isl_obj obj;
1460 struct isl_map *map;
1461 struct isl_stream *s = isl_stream_new_str(ctx, str);
1462 if (!s)
1463 return NULL;
1464 obj = obj_read(s, nparam);
1465 isl_stream_free(s);
1466 return obj.v;
1467 }
1468
1469 __isl_give isl_set *isl_set_read_from_file(struct isl_ctx *ctx,
1470 FILE *input, int nparam)
1471 {
1472 struct isl_map *map;
1473 map = isl_map_read_from_file(ctx, input, nparam);
1474 if (!map)
1475 return NULL;
1476 isl_assert(ctx, isl_map_n_in(map) == 0, goto error);
1477 return (struct isl_set *)map;
1478 error:
1479 isl_map_free(map);
1480 return NULL;
1481 }
1482
1483 struct isl_set *isl_set_read_from_str(struct isl_ctx *ctx,
1484 const char *str, int nparam)
1485 {
1486 struct isl_map *map;
1487 map = isl_map_read_from_str(ctx, str, nparam);
1488 if (!map)
1489 return NULL;
1490 isl_assert(ctx, isl_map_n_in(map) == 0, goto error);
1491 return (struct isl_set *)map;
1492 error:
1493 isl_map_free(map);
1494 return NULL;
1495 }
1496
1497 static char *next_line(FILE *input, char *line, unsigned len)
1498 {
1499 char *p;
1500
1501 do {
1502 if (!(p = fgets(line, len, input)))
1503 return NULL;
1504 while (isspace(*p) && *p != '\n')
1505 ++p;
1506 } while (*p == '#' || *p == '\n');
1507
1508 return p;
1509 }
1510
1511 static struct isl_vec *isl_vec_read_from_file_polylib(struct isl_ctx *ctx,
1512 FILE *input)
1513 {
1514 struct isl_vec *vec = NULL;
1515 char line[1024];
1516 char val[1024];
1517 char *p;
1518 unsigned size;
1519 int j;
1520 int n;
1521 int offset;
1522
1523 isl_assert(ctx, next_line(input, line, sizeof(line)), return NULL);
1524 isl_assert(ctx, sscanf(line, "%u", &size) == 1, return NULL);
1525
1526 vec = isl_vec_alloc(ctx, size);
1527
1528 p = next_line(input, line, sizeof(line));
1529 isl_assert(ctx, p, goto error);
1530
1531 for (j = 0; j < size; ++j) {
1532 n = sscanf(p, "%s%n", val, &offset);
1533 isl_assert(ctx, n != 0, goto error);
1534 isl_int_read(vec->el[j], val);
1535 p += offset;
1536 }
1537
1538 return vec;
1539 error:
1540 isl_vec_free(vec);
1541 return NULL;
1542 }
1543
1544 struct isl_vec *isl_vec_read_from_file(struct isl_ctx *ctx,
1545 FILE *input, unsigned input_format)
1546 {
1547 if (input_format == ISL_FORMAT_POLYLIB)
1548 return isl_vec_read_from_file_polylib(ctx, input);
1549 else
1550 isl_assert(ctx, 0, return NULL);
1551 }
Integer set library