?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
util.c: for_each_lower_upper_bound: drop unused variable
[barvinok.git] / iscc.c
blob1721a8e002891a20ec7c00038291d74529eacba8
1 #include <assert.h>
2 #include <ctype.h>
3 #include <stdio.h>
4 #include <string.h>
5 #include <unistd.h>
6 #include <isl/aff.h>
7 #include <isl/obj.h>
8 #include <isl/stream.h>
9 #include <isl/set.h>
10 #include <isl/map.h>
11 #include <isl/vertices.h>
12 #include <isl/flow.h>
13 #include <isl/schedule.h>
14 #include <isl/ast_build.h>
15 #include <isl_obj_list.h>
16 #include <isl_obj_str.h>
17 #include <barvinok/isl.h>
18 #include <barvinok/options.h>
19 #include "lattice_width.h"
20
21 #include "config.h"
22
23 #ifdef HAVE_SIGACTION
24 #include <signal.h>
25
26 static isl_ctx *main_ctx;
27
28 static void handler(int signum)
29 {
30 if (isl_ctx_aborted(main_ctx))
31 exit(EXIT_FAILURE);
32 isl_ctx_abort(main_ctx);
33 }
34
35 static struct sigaction sa_old;
36
37 static void install_signal_handler(isl_ctx *ctx)
38 {
39 struct sigaction sa;
40
41 main_ctx = ctx;
42
43 memset(&sa, 0, sizeof(struct sigaction));
44 sa.sa_handler = &handler;
45 sa.sa_flags = SA_RESTART;
46 sigaction(SIGINT, &sa, &sa_old);
47 }
48
49 static void remove_signal_handler(isl_ctx *ctx)
50 {
51 sigaction(SIGINT, &sa_old, NULL);
52 }
53
54 #else
55
56 static void install_signal_handler(isl_ctx *ctx)
57 {
58 }
59
60 static void remove_signal_handler(isl_ctx *ctx)
61 {
62 }
63
64 #endif
65
66 #ifdef HAVE_PET
67 #include <pet.h>
68 #else
69 struct pet_options;
70 int pet_options_set_autodetect(isl_ctx *ctx, int val)
71 {
72 return -1;
73 }
74 int pet_options_set_encapsulate_dynamic_control(isl_ctx *ctx, int val)
75 {
76 return -1;
77 }
78 #endif
79
80 static int iscc_bool_false = 0;
81 static int iscc_bool_true = 1;
82 static int iscc_bool_error = -1;
83
84 enum iscc_op { ISCC_READ, ISCC_WRITE, ISCC_SOURCE, ISCC_VERTICES,
85 ISCC_LAST, ISCC_ANY, ISCC_BEFORE, ISCC_UNDER,
86 ISCC_SCHEDULE,
87 ISCC_MINIMIZING, ISCC_RESPECTING,
88 ISCC_CODEGEN, ISCC_USING,
89 ISCC_TYPEOF, ISCC_PRINT, ISCC_ASSERT,
90 ISCC_N_OP };
91 static const char *op_name[ISCC_N_OP] = {
92 [ISCC_ASSERT] = "assert",
93 [ISCC_READ] = "read",
94 [ISCC_WRITE] = "write",
95 [ISCC_PRINT] = "print",
96 [ISCC_SOURCE] = "source",
97 [ISCC_VERTICES] = "vertices",
98 [ISCC_LAST] = "last",
99 [ISCC_ANY] = "any",
100 [ISCC_BEFORE] = "before",
101 [ISCC_UNDER] = "under",
102 [ISCC_SCHEDULE] = "schedule",
103 [ISCC_MINIMIZING] = "minimizing",
104 [ISCC_RESPECTING] = "respecting",
105 [ISCC_CODEGEN] = "codegen",
106 [ISCC_USING] = "using",
107 [ISCC_TYPEOF] = "typeof"
108 };
109 static enum isl_token_type iscc_op[ISCC_N_OP];
110
111 struct isl_arg_choice iscc_format[] = {
112 {"isl", ISL_FORMAT_ISL},
113 {"omega", ISL_FORMAT_OMEGA},
114 {"polylib", ISL_FORMAT_POLYLIB},
115 {"ext-polylib", ISL_FORMAT_EXT_POLYLIB},
116 {"latex", ISL_FORMAT_LATEX},
117 {"C", ISL_FORMAT_C},
118 {0}
119 };
120
121 struct iscc_options {
122 struct barvinok_options *barvinok;
123 struct pet_options *pet;
124 unsigned format;
125 int io;
126 };
127
128 ISL_ARGS_START(struct iscc_options, iscc_options_args)
129 ISL_ARG_CHILD(struct iscc_options, barvinok, "barvinok", &barvinok_options_args,
130 "barvinok options")
131 #ifdef HAVE_PET
132 ISL_ARG_CHILD(struct iscc_options, pet, "pet", &pet_options_args, "pet options")
133 #endif
134 ISL_ARG_CHOICE(struct iscc_options, format, 0, "format", \
135 iscc_format, ISL_FORMAT_ISL, "output format")
136 ISL_ARG_BOOL(struct iscc_options, io, 0, "io", 1,
137 "allow read and write operations")
138 ISL_ARGS_END
139
140 ISL_ARG_DEF(iscc_options, struct iscc_options, iscc_options_args)
141 ISL_ARG_CTX_DEF(iscc_options, struct iscc_options, iscc_options_args)
142
143 static void *isl_obj_bool_copy(void *v)
144 {
145 return v;
146 }
147
148 static void isl_obj_bool_free(void *v)
149 {
150 }
151
152 static __isl_give isl_printer *isl_obj_bool_print(__isl_take isl_printer *p,
153 void *v)
154 {
155 if (v == &iscc_bool_true)
156 return isl_printer_print_str(p, "True");
157 else if (v == &iscc_bool_false)
158 return isl_printer_print_str(p, "False");
159 else
160 return isl_printer_print_str(p, "Error");
161 }
162
163 static void *isl_obj_bool_add(void *v1, void *v2)
164 {
165 return v1;
166 }
167
168 struct isl_obj_vtable isl_obj_bool_vtable = {
169 isl_obj_bool_copy,
170 isl_obj_bool_add,
171 isl_obj_bool_print,
172 isl_obj_bool_free
173 };
174 #define isl_obj_bool (&isl_obj_bool_vtable)
175
176 int *iscc_bool_from_int(int res)
177 {
178 return res < 0 ? &iscc_bool_error :
179 res ? &iscc_bool_true : &iscc_bool_false;
180 }
181
182 /* Conjunction of "b1" and "b2".
183 * The result is returned as an integer because it is post-processed by
184 * iscc_bool_from_int.
185 */
186 static int isl_bool_and(isl_bool *b1, __isl_take isl_bool *b2)
187 {
188 if (b1 == &iscc_bool_error || b2 == &iscc_bool_error)
189 return -1;
190 return b1 == &iscc_bool_true && b2 == &iscc_bool_true;
191 }
192
193 /* Disjunction of "b1" and "b2".
194 * The result is returned as an integer because it is post-processed by
195 * iscc_bool_from_int.
196 */
197 static int isl_bool_or(isl_bool *b1, __isl_take isl_bool *b2)
198 {
199 if (b1 == &iscc_bool_error || b2 == &iscc_bool_error)
200 return -1;
201 return b1 == &iscc_bool_true || b2 == &iscc_bool_true;
202 }
203
204 static int isl_union_map_is_superset(__isl_take isl_union_map *map1,
205 __isl_take isl_union_map *map2)
206 {
207 return isl_union_map_is_subset(map2, map1);
208 }
209 static int isl_union_set_is_superset(__isl_take isl_union_set *set1,
210 __isl_take isl_union_set *set2)
211 {
212 return isl_union_set_is_subset(set2, set1);
213 }
214
215 static int isl_union_map_is_strict_superset(__isl_take isl_union_map *map1,
216 __isl_take isl_union_map *map2)
217 {
218 return isl_union_map_is_strict_subset(map2, map1);
219 }
220 static int isl_union_set_is_strict_superset(__isl_take isl_union_set *set1,
221 __isl_take isl_union_set *set2)
222 {
223 return isl_union_set_is_strict_subset(set2, set1);
224 }
225
226 extern struct isl_obj_vtable isl_obj_list_vtable;
227 #define isl_obj_list (&isl_obj_list_vtable)
228
229 typedef void *(*isc_bin_op_fn)(void *lhs, void *rhs);
230 typedef int (*isc_bin_test_fn)(void *lhs, void *rhs);
231 struct isc_bin_op {
232 enum isl_token_type op;
233 isl_obj_type lhs;
234 isl_obj_type rhs;
235 isl_obj_type res;
236 union {
237 isc_bin_op_fn fn;
238 isc_bin_test_fn test;
239 } o;
240 };
241 struct isc_named_bin_op {
242 char *name;
243 struct isc_bin_op op;
244 };
245 /* Compound binary operator.
246 * "full" is only used to generate a unique token number for op.op
247 * in register_named_ops.
248 * "op1" is the first part of the compound operator.
249 * "op2" is the second part of the compound operator.
250 */
251 struct iscc_compound_bin_op {
252 char *full;
253 enum isl_token_type op1;
254 enum isl_token_type op2;
255 struct isc_bin_op op;
256 };
257
258 struct iscc_at {
259 isl_union_pw_qpolynomial *upwqp;
260 isl_union_pw_qpolynomial *res;
261 };
262
263 static isl_stat eval_at(__isl_take isl_point *pnt, void *user)
264 {
265 struct iscc_at *at = (struct iscc_at *) user;
266 isl_val *v;
267 isl_qpolynomial *qp;
268 isl_set *set;
269
270 set = isl_set_from_point(isl_point_copy(pnt));
271 v = isl_union_pw_qpolynomial_eval(
272 isl_union_pw_qpolynomial_copy(at->upwqp), pnt);
273 qp = isl_qpolynomial_val_on_domain(isl_set_get_space(set), v);
274
275 at->res = isl_union_pw_qpolynomial_add(at->res,
276 isl_union_pw_qpolynomial_from_pw_qpolynomial(
277 isl_pw_qpolynomial_alloc(set, qp)));
278
279 return isl_stat_ok;
280 }
281
282 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_at(
283 __isl_take isl_union_pw_qpolynomial *upwqp,
284 __isl_take isl_union_set *uset)
285 {
286 struct iscc_at at;
287
288 at.upwqp = upwqp;
289 at.res = isl_union_pw_qpolynomial_zero(isl_union_set_get_space(uset));
290
291 isl_union_set_foreach_point(uset, eval_at, &at);
292
293 isl_union_pw_qpolynomial_free(upwqp);
294 isl_union_set_free(uset);
295
296 return at.res;
297 }
298
299 struct iscc_fold_at {
300 isl_union_pw_qpolynomial_fold *upwf;
301 isl_union_pw_qpolynomial *res;
302 };
303
304 static isl_stat eval_fold_at(__isl_take isl_point *pnt, void *user)
305 {
306 struct iscc_fold_at *at = (struct iscc_fold_at *) user;
307 isl_val *v;
308 isl_qpolynomial *qp;
309 isl_set *set;
310
311 set = isl_set_from_point(isl_point_copy(pnt));
312 v = isl_union_pw_qpolynomial_fold_eval(
313 isl_union_pw_qpolynomial_fold_copy(at->upwf), pnt);
314 qp = isl_qpolynomial_val_on_domain(isl_set_get_space(set), v);
315
316 at->res = isl_union_pw_qpolynomial_add(at->res,
317 isl_union_pw_qpolynomial_from_pw_qpolynomial(
318 isl_pw_qpolynomial_alloc(set, qp)));
319
320 return isl_stat_ok;
321 }
322
323 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_fold_at(
324 __isl_take isl_union_pw_qpolynomial_fold *upwf,
325 __isl_take isl_union_set *uset)
326 {
327 struct iscc_fold_at at;
328
329 at.upwf = upwf;
330 at.res = isl_union_pw_qpolynomial_zero(isl_union_set_get_space(uset));
331
332 isl_union_set_foreach_point(uset, eval_fold_at, &at);
333
334 isl_union_pw_qpolynomial_fold_free(upwf);
335 isl_union_set_free(uset);
336
337 return at.res;
338 }
339
340 static __isl_give isl_union_pw_qpolynomial_fold *union_pw_qpolynomial_add_union_pw_qpolynomial_fold(
341 __isl_take isl_union_pw_qpolynomial *upwqp,
342 __isl_take isl_union_pw_qpolynomial_fold *upwf)
343 {
344 return isl_union_pw_qpolynomial_fold_add_union_pw_qpolynomial(upwf,
345 upwqp);
346 }
347
348 static __isl_give struct isl_list *union_map_apply_union_pw_qpolynomial_fold(
349 __isl_take isl_union_map *umap,
350 __isl_take isl_union_pw_qpolynomial_fold *upwf)
351 {
352 isl_ctx *ctx;
353 struct isl_list *list;
354 int tight;
355
356 ctx = isl_union_map_get_ctx(umap);
357 list = isl_list_alloc(ctx, 2);
358 if (!list)
359 goto error2;
360
361 list->obj[0].type = isl_obj_union_pw_qpolynomial_fold;
362 list->obj[0].v = isl_union_map_apply_union_pw_qpolynomial_fold(umap,
363 upwf, &tight);
364 list->obj[1].type = isl_obj_bool;
365 list->obj[1].v = tight ? &iscc_bool_true : &iscc_bool_false;
366 if (tight < 0 || !list->obj[0].v)
367 goto error;
368
369 return list;
370 error2:
371 isl_union_map_free(umap);
372 isl_union_pw_qpolynomial_fold_free(upwf);
373 error:
374 isl_list_free(list);
375 return NULL;
376 }
377
378 static __isl_give struct isl_list *union_set_apply_union_pw_qpolynomial_fold(
379 __isl_take isl_union_set *uset,
380 __isl_take isl_union_pw_qpolynomial_fold *upwf)
381 {
382 isl_ctx *ctx;
383 struct isl_list *list;
384 int tight;
385
386 ctx = isl_union_set_get_ctx(uset);
387 list = isl_list_alloc(ctx, 2);
388 if (!list)
389 goto error2;
390
391 list->obj[0].type = isl_obj_union_pw_qpolynomial_fold;
392 list->obj[0].v = isl_union_set_apply_union_pw_qpolynomial_fold(uset,
393 upwf, &tight);
394 list->obj[1].type = isl_obj_bool;
395 list->obj[1].v = tight ? &iscc_bool_true : &iscc_bool_false;
396 if (tight < 0 || !list->obj[0].v)
397 goto error;
398
399 return list;
400 error2:
401 isl_union_set_free(uset);
402 isl_union_pw_qpolynomial_fold_free(upwf);
403 error:
404 isl_list_free(list);
405 return NULL;
406 }
407
408 static __isl_give isl_union_pw_qpolynomial *isl_val_mul_union_pw_qpolynomial(
409 __isl_take isl_val *v, __isl_take isl_union_pw_qpolynomial *upwqp)
410 {
411 return isl_union_pw_qpolynomial_scale_val(upwqp, v);
412 }
413
414 static __isl_give isl_union_pw_qpolynomial_fold *
415 int_val_mul_union_pw_qpolynomial_fold(__isl_take isl_val *v,
416 __isl_take isl_union_pw_qpolynomial_fold *upwf)
417 {
418 return isl_union_pw_qpolynomial_fold_scale_val(upwf, v);
419 }
420
421 /* Are the two strings "str1" and "str2" equal to each other?
422 */
423 static int str_eq(__isl_keep isl_str *str1, __isl_keep isl_str *str2)
424 {
425 if (!str1 || !str2)
426 return -1;
427
428 return !strcmp(str1->s, str2->s);
429 }
430
431 struct isc_bin_op bin_ops[] = {
432 { '+', isl_obj_bool, isl_obj_bool, isl_obj_bool,
433 (isc_bin_op_fn) &isl_bool_or },
434 { '*', isl_obj_bool, isl_obj_bool, isl_obj_bool,
435 (isc_bin_op_fn) &isl_bool_and },
436 { '+', isl_obj_val, isl_obj_val, isl_obj_val,
437 (isc_bin_op_fn) &isl_val_add },
438 { '-', isl_obj_val, isl_obj_val, isl_obj_val,
439 (isc_bin_op_fn) &isl_val_sub },
440 { '*', isl_obj_val, isl_obj_val, isl_obj_val,
441 (isc_bin_op_fn) &isl_val_mul },
442 { '+', isl_obj_pw_multi_aff, isl_obj_pw_multi_aff,
443 isl_obj_pw_multi_aff,
444 (isc_bin_op_fn) &isl_pw_multi_aff_add },
445 { '+', isl_obj_union_set, isl_obj_union_set,
446 isl_obj_union_set,
447 (isc_bin_op_fn) &isl_union_set_union },
448 { '+', isl_obj_union_map, isl_obj_union_map,
449 isl_obj_union_map,
450 (isc_bin_op_fn) &isl_union_map_union },
451 { '-', isl_obj_union_set, isl_obj_union_set,
452 isl_obj_union_set,
453 (isc_bin_op_fn) &isl_union_set_subtract },
454 { '-', isl_obj_union_map, isl_obj_union_map,
455 isl_obj_union_map,
456 (isc_bin_op_fn) &isl_union_map_subtract },
457 { '-', isl_obj_union_map, isl_obj_union_set,
458 isl_obj_union_map,
459 (isc_bin_op_fn) &isl_union_map_subtract_domain },
460 { '*', isl_obj_union_set, isl_obj_union_set,
461 isl_obj_union_set,
462 (isc_bin_op_fn) &isl_union_set_intersect },
463 { '*', isl_obj_union_map, isl_obj_union_map,
464 isl_obj_union_map,
465 (isc_bin_op_fn) &isl_union_map_intersect },
466 { '*', isl_obj_union_map, isl_obj_union_set,
467 isl_obj_union_map,
468 (isc_bin_op_fn) &isl_union_map_intersect_domain },
469 { '.', isl_obj_union_map, isl_obj_union_map,
470 isl_obj_union_map,
471 (isc_bin_op_fn) &isl_union_map_apply_range },
472 { '.', isl_obj_union_map, isl_obj_union_pw_qpolynomial,
473 isl_obj_union_pw_qpolynomial,
474 (isc_bin_op_fn) &isl_union_map_apply_union_pw_qpolynomial },
475 { '.', isl_obj_union_map, isl_obj_union_pw_qpolynomial_fold,
476 isl_obj_list,
477 (isc_bin_op_fn) &union_map_apply_union_pw_qpolynomial_fold },
478 { ISL_TOKEN_TO, isl_obj_union_set, isl_obj_union_set,
479 isl_obj_union_map,
480 (isc_bin_op_fn) &isl_union_map_from_domain_and_range },
481 { '=', isl_obj_union_set, isl_obj_union_set, isl_obj_bool,
482 { .test = (isc_bin_test_fn) &isl_union_set_is_equal } },
483 { '=', isl_obj_union_map, isl_obj_union_map, isl_obj_bool,
484 { .test = (isc_bin_test_fn) &isl_union_map_is_equal } },
485 { ISL_TOKEN_LE, isl_obj_union_set, isl_obj_union_set,
486 isl_obj_bool,
487 { .test = (isc_bin_test_fn) &isl_union_set_is_subset } },
488 { ISL_TOKEN_LE, isl_obj_union_map, isl_obj_union_map,
489 isl_obj_bool,
490 { .test = (isc_bin_test_fn) &isl_union_map_is_subset } },
491 { ISL_TOKEN_LT, isl_obj_union_set, isl_obj_union_set,
492 isl_obj_bool,
493 { .test = (isc_bin_test_fn) &isl_union_set_is_strict_subset } },
494 { ISL_TOKEN_LT, isl_obj_union_map, isl_obj_union_map,
495 isl_obj_bool,
496 { .test = (isc_bin_test_fn) &isl_union_map_is_strict_subset } },
497 { ISL_TOKEN_GE, isl_obj_union_set, isl_obj_union_set,
498 isl_obj_bool,
499 { .test = (isc_bin_test_fn) &isl_union_set_is_superset } },
500 { ISL_TOKEN_GE, isl_obj_union_map, isl_obj_union_map,
501 isl_obj_bool,
502 { .test = (isc_bin_test_fn) &isl_union_map_is_superset } },
503 { ISL_TOKEN_GT, isl_obj_union_set, isl_obj_union_set,
504 isl_obj_bool,
505 { .test =
506 (isc_bin_test_fn) &isl_union_set_is_strict_superset } },
507 { ISL_TOKEN_GT, isl_obj_union_map, isl_obj_union_map,
508 isl_obj_bool,
509 { .test =
510 (isc_bin_test_fn) &isl_union_map_is_strict_superset } },
511 { ISL_TOKEN_LEX_LE, isl_obj_union_set, isl_obj_union_set,
512 isl_obj_union_map,
513 (isc_bin_op_fn) &isl_union_set_lex_le_union_set },
514 { ISL_TOKEN_LEX_LT, isl_obj_union_set, isl_obj_union_set,
515 isl_obj_union_map,
516 (isc_bin_op_fn) &isl_union_set_lex_lt_union_set },
517 { ISL_TOKEN_LEX_GE, isl_obj_union_set, isl_obj_union_set,
518 isl_obj_union_map,
519 (isc_bin_op_fn) &isl_union_set_lex_ge_union_set },
520 { ISL_TOKEN_LEX_GT, isl_obj_union_set, isl_obj_union_set,
521 isl_obj_union_map,
522 (isc_bin_op_fn) &isl_union_set_lex_gt_union_set },
523 { ISL_TOKEN_LEX_LE, isl_obj_union_map, isl_obj_union_map,
524 isl_obj_union_map,
525 (isc_bin_op_fn) &isl_union_map_lex_le_union_map },
526 { ISL_TOKEN_LEX_LT, isl_obj_union_map, isl_obj_union_map,
527 isl_obj_union_map,
528 (isc_bin_op_fn) &isl_union_map_lex_lt_union_map },
529 { ISL_TOKEN_LEX_GE, isl_obj_union_map, isl_obj_union_map,
530 isl_obj_union_map,
531 (isc_bin_op_fn) &isl_union_map_lex_ge_union_map },
532 { ISL_TOKEN_LEX_GT, isl_obj_union_map, isl_obj_union_map,
533 isl_obj_union_map,
534 (isc_bin_op_fn) &isl_union_map_lex_gt_union_map },
535 { '.', isl_obj_union_pw_qpolynomial_fold,
536 isl_obj_union_pw_qpolynomial_fold,
537 isl_obj_union_pw_qpolynomial_fold,
538 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_fold },
539 { '+', isl_obj_union_pw_qpolynomial, isl_obj_union_pw_qpolynomial,
540 isl_obj_union_pw_qpolynomial,
541 (isc_bin_op_fn) &isl_union_pw_qpolynomial_add },
542 { '+', isl_obj_union_pw_qpolynomial,
543 isl_obj_union_pw_qpolynomial_fold,
544 isl_obj_union_pw_qpolynomial_fold,
545 (isc_bin_op_fn) &union_pw_qpolynomial_add_union_pw_qpolynomial_fold },
546 { '+', isl_obj_union_pw_qpolynomial_fold,
547 isl_obj_union_pw_qpolynomial,
548 isl_obj_union_pw_qpolynomial_fold,
549 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_add_union_pw_qpolynomial },
550 { '-', isl_obj_union_pw_qpolynomial, isl_obj_union_pw_qpolynomial,
551 isl_obj_union_pw_qpolynomial,
552 (isc_bin_op_fn) &isl_union_pw_qpolynomial_sub },
553 { '*', isl_obj_val, isl_obj_union_pw_qpolynomial,
554 isl_obj_union_pw_qpolynomial,
555 (isc_bin_op_fn) &isl_val_mul_union_pw_qpolynomial },
556 { '*', isl_obj_union_pw_qpolynomial, isl_obj_val,
557 isl_obj_union_pw_qpolynomial,
558 (isc_bin_op_fn) &isl_union_pw_qpolynomial_scale_val },
559 { '*', isl_obj_val, isl_obj_union_pw_qpolynomial_fold,
560 isl_obj_union_pw_qpolynomial_fold,
561 (isc_bin_op_fn) &int_val_mul_union_pw_qpolynomial_fold },
562 { '*', isl_obj_union_pw_qpolynomial_fold, isl_obj_val,
563 isl_obj_union_pw_qpolynomial_fold,
564 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_scale_val },
565 { '*', isl_obj_union_pw_qpolynomial, isl_obj_union_pw_qpolynomial,
566 isl_obj_union_pw_qpolynomial,
567 (isc_bin_op_fn) &isl_union_pw_qpolynomial_mul },
568 { '*', isl_obj_union_pw_qpolynomial, isl_obj_union_set,
569 isl_obj_union_pw_qpolynomial,
570 (isc_bin_op_fn) &isl_union_pw_qpolynomial_intersect_domain },
571 { '*', isl_obj_union_pw_qpolynomial_fold, isl_obj_union_set,
572 isl_obj_union_pw_qpolynomial_fold,
573 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_intersect_domain },
574 { '@', isl_obj_union_pw_qpolynomial, isl_obj_union_set,
575 isl_obj_union_pw_qpolynomial,
576 (isc_bin_op_fn) &isl_union_pw_qpolynomial_at },
577 { '@', isl_obj_union_pw_qpolynomial_fold, isl_obj_union_set,
578 isl_obj_union_pw_qpolynomial,
579 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_at },
580 { '%', isl_obj_union_set, isl_obj_union_set,
581 isl_obj_union_set,
582 (isc_bin_op_fn) &isl_union_set_gist },
583 { '%', isl_obj_union_map, isl_obj_union_map,
584 isl_obj_union_map,
585 (isc_bin_op_fn) &isl_union_map_gist },
586 { '%', isl_obj_union_map, isl_obj_union_set,
587 isl_obj_union_map,
588 (isc_bin_op_fn) &isl_union_map_gist_domain },
589 { '%', isl_obj_union_pw_qpolynomial, isl_obj_union_set,
590 isl_obj_union_pw_qpolynomial,
591 (isc_bin_op_fn) &isl_union_pw_qpolynomial_gist },
592 { '%', isl_obj_union_pw_qpolynomial_fold, isl_obj_union_set,
593 isl_obj_union_pw_qpolynomial_fold,
594 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_gist },
595 { ISL_TOKEN_EQ_EQ, isl_obj_union_pw_qpolynomial,
596 isl_obj_union_pw_qpolynomial, isl_obj_bool,
597 { .test = (isc_bin_test_fn)
598 &isl_union_pw_qpolynomial_plain_is_equal } },
599 { ISL_TOKEN_EQ_EQ, isl_obj_union_pw_qpolynomial_fold,
600 isl_obj_union_pw_qpolynomial_fold, isl_obj_bool,
601 { .test = (isc_bin_test_fn)
602 &isl_union_pw_qpolynomial_fold_plain_is_equal } },
603 { '+', isl_obj_str, isl_obj_str, isl_obj_str,
604 (isc_bin_op_fn) &isl_str_concat },
605 { '=', isl_obj_str, isl_obj_str, isl_obj_bool,
606 { .test = (isc_bin_test_fn) &str_eq } },
607 0
608 };
609
610 struct iscc_compound_bin_op compound_bin_ops[] = {
611 { "->*", ISL_TOKEN_TO, '*',
612 { -1, isl_obj_union_map, isl_obj_union_set,
613 isl_obj_union_map,
614 (isc_bin_op_fn) &isl_union_map_intersect_range } },
615 { "->-", ISL_TOKEN_TO, '-',
616 { -1, isl_obj_union_map, isl_obj_union_set,
617 isl_obj_union_map,
618 (isc_bin_op_fn) &isl_union_map_subtract_range } },
619 0
620 };
621
622 static __isl_give isl_union_map *map_after_map(__isl_take isl_union_map *umap1,
623 __isl_take isl_union_map *umap2)
624 {
625 return isl_union_map_apply_range(umap2, umap1);
626 }
627
628 static __isl_give isl_union_pw_qpolynomial *qpolynomial_after_map(
629 __isl_take isl_union_pw_qpolynomial *upwqp,
630 __isl_take isl_union_map *umap)
631 {
632 return isl_union_map_apply_union_pw_qpolynomial(umap, upwqp);
633 }
634
635 static __isl_give struct isl_list *qpolynomial_fold_after_map(
636 __isl_take isl_union_pw_qpolynomial_fold *upwf,
637 __isl_take isl_union_map *umap)
638 {
639 return union_map_apply_union_pw_qpolynomial_fold(umap, upwf);
640 }
641
642 struct isc_named_bin_op named_bin_ops[] = {
643 { "after", { -1, isl_obj_union_map, isl_obj_union_map,
644 isl_obj_union_map,
645 (isc_bin_op_fn) &map_after_map } },
646 { "after", { -1, isl_obj_union_pw_qpolynomial,
647 isl_obj_union_map, isl_obj_union_pw_qpolynomial,
648 (isc_bin_op_fn) &qpolynomial_after_map } },
649 { "after", { -1, isl_obj_union_pw_qpolynomial_fold,
650 isl_obj_union_map, isl_obj_list,
651 (isc_bin_op_fn) &qpolynomial_fold_after_map } },
652 { "before", { -1, isl_obj_union_map, isl_obj_union_map,
653 isl_obj_union_map,
654 (isc_bin_op_fn) &isl_union_map_apply_range } },
655 { "before", { -1, isl_obj_union_map,
656 isl_obj_union_pw_qpolynomial, isl_obj_union_pw_qpolynomial,
657 (isc_bin_op_fn) &isl_union_map_apply_union_pw_qpolynomial } },
658 { "before", { -1, isl_obj_union_map,
659 isl_obj_union_pw_qpolynomial_fold, isl_obj_list,
660 (isc_bin_op_fn) &union_map_apply_union_pw_qpolynomial_fold } },
661 { "cross", { -1, isl_obj_union_set, isl_obj_union_set,
662 isl_obj_union_set,
663 (isc_bin_op_fn) &isl_union_set_product } },
664 { "cross", { -1, isl_obj_union_map, isl_obj_union_map,
665 isl_obj_union_map,
666 (isc_bin_op_fn) &isl_union_map_product } },
667 NULL
668 };
669
670 __isl_give isl_set *union_set_sample(__isl_take isl_union_set *uset)
671 {
672 return isl_set_from_basic_set(isl_union_set_sample(uset));
673 }
674
675 __isl_give isl_map *union_map_sample(__isl_take isl_union_map *umap)
676 {
677 return isl_map_from_basic_map(isl_union_map_sample(umap));
678 }
679
680 static __isl_give struct isl_list *union_map_power(
681 __isl_take isl_union_map *umap)
682 {
683 isl_ctx *ctx;
684 struct isl_list *list;
685 int exact;
686
687 ctx = isl_union_map_get_ctx(umap);
688 list = isl_list_alloc(ctx, 2);
689 if (!list)
690 goto error2;
691
692 list->obj[0].type = isl_obj_union_map;
693 list->obj[0].v = isl_union_map_power(umap, &exact);
694 list->obj[1].type = isl_obj_bool;
695 list->obj[1].v = exact ? &iscc_bool_true : &iscc_bool_false;
696 if (exact < 0 || !list->obj[0].v)
697 goto error;
698
699 return list;
700 error2:
701 isl_union_map_free(umap);
702 error:
703 isl_list_free(list);
704 return NULL;
705 }
706
707 /* Compute a lower or upper bound on "upwqp" depending on "type" and
708 * return a list containing two elements, the bound and a boolean
709 * indicating whether the result is tight.
710 */
711 static __isl_give struct isl_list *union_pw_qpolynomial_bound(
712 __isl_take isl_union_pw_qpolynomial *upwqp, enum isl_fold type)
713 {
714 isl_ctx *ctx;
715 struct isl_list *list;
716 int tight;
717
718 ctx = isl_union_pw_qpolynomial_get_ctx(upwqp);
719 list = isl_list_alloc(ctx, 2);
720 if (!list)
721 goto error2;
722
723 list->obj[0].type = isl_obj_union_pw_qpolynomial_fold;
724 list->obj[0].v = isl_union_pw_qpolynomial_bound(upwqp, type, &tight);
725 list->obj[1].type = isl_obj_bool;
726 list->obj[1].v = tight ? &iscc_bool_true : &iscc_bool_false;
727 if (tight < 0 || !list->obj[0].v)
728 goto error;
729
730 return list;
731 error2:
732 isl_union_pw_qpolynomial_free(upwqp);
733 error:
734 isl_list_free(list);
735 return NULL;
736 }
737
738 /* Compute a lower bound on "upwqp" and return a list containing
739 * two elements, the bound and a booleanindicating whether
740 * the result is tight.
741 */
742 static __isl_give struct isl_list *union_pw_qpolynomial_lower_bound(
743 __isl_take isl_union_pw_qpolynomial *upwqp)
744 {
745 return union_pw_qpolynomial_bound(upwqp, isl_fold_min);
746 }
747
748 /* Compute a upper bound on "upwqp" and return a list containing
749 * two elements, the bound and a booleanindicating whether
750 * the result is tight.
751 */
752 static __isl_give struct isl_list *union_pw_qpolynomial_upper_bound(
753 __isl_take isl_union_pw_qpolynomial *upwqp)
754 {
755 return union_pw_qpolynomial_bound(upwqp, isl_fold_max);
756 }
757
758 #ifdef HAVE_PET
759 /* Collect all statement instances, except those of kill statements.
760 */
761 static __isl_give isl_union_set *collect_non_kill_instances(
762 struct pet_scop *scop)
763 {
764 int i;
765 isl_set *domain_i;
766 isl_union_set *domain;
767
768 if (!scop)
769 return NULL;
770
771 domain = isl_union_set_empty(isl_set_get_space(scop->context));
772
773 for (i = 0; i < scop->n_stmt; ++i) {
774 struct pet_stmt *stmt = scop->stmts[i];
775
776 if (pet_stmt_is_kill(stmt))
777 continue;
778 domain_i = isl_set_copy(stmt->domain);
779 if (scop->stmts[i]->n_arg > 0)
780 domain_i = isl_map_domain(isl_set_unwrap(domain_i));
781 domain = isl_union_set_add_set(domain, domain_i);
782 }
783
784 return domain;
785 }
786
787 static __isl_give isl_list *parse(__isl_take isl_str *str)
788 {
789 isl_ctx *ctx;
790 struct isl_list *list;
791 struct pet_scop *scop;
792 isl_schedule *sched;
793 isl_union_map *may_reads, *must_writes, *may_writes;
794 isl_union_set *domain;
795 struct iscc_options *options;
796
797 if (!str)
798 return NULL;
799 ctx = str->ctx;
800
801 options = isl_ctx_peek_iscc_options(ctx);
802 if (!options || !options->io) {
803 isl_str_free(str);
804 isl_die(ctx, isl_error_invalid,
805 "parse_file operation not allowed", return NULL);
806 }
807
808 list = isl_list_alloc(ctx, 5);
809 if (!list)
810 goto error;
811
812 scop = pet_scop_extract_from_C_source(ctx, str->s, NULL);
813 domain = collect_non_kill_instances(scop);
814 sched = pet_scop_get_schedule(scop);
815 sched = isl_schedule_intersect_domain(sched,
816 isl_union_set_copy(domain));
817 may_reads = pet_scop_get_may_reads(scop);
818 may_writes = pet_scop_get_may_writes(scop);
819 must_writes = pet_scop_get_must_writes(scop);
820 pet_scop_free(scop);
821
822 list->obj[0].type = isl_obj_union_set;
823 list->obj[0].v = domain;
824 list->obj[1].type = isl_obj_union_map;
825 list->obj[1].v = must_writes;
826 list->obj[2].type = isl_obj_union_map;
827 list->obj[2].v = may_writes;
828 list->obj[3].type = isl_obj_union_map;
829 list->obj[3].v = may_reads;
830 list->obj[4].type = isl_obj_schedule;
831 list->obj[4].v = sched;
832
833 if (!list->obj[0].v || !list->obj[1].v ||
834 !list->obj[2].v || !list->obj[3].v || !list->obj[4].v)
835 goto error;
836
837 isl_str_free(str);
838 return list;
839 error:
840 isl_list_free(list);
841 isl_str_free(str);
842 return NULL;
843 }
844 #endif
845
846 static isl_stat add_point(__isl_take isl_point *pnt, void *user)
847 {
848 isl_union_set **scan = (isl_union_set **) user;
849
850 *scan = isl_union_set_add_set(*scan, isl_set_from_point(pnt));
851
852 return isl_stat_ok;
853 }
854
855 static __isl_give isl_union_set *union_set_scan(__isl_take isl_union_set *uset)
856 {
857 isl_union_set *scan;
858
859 scan = isl_union_set_empty(isl_union_set_get_space(uset));
860
861 if (isl_union_set_foreach_point(uset, add_point, &scan) < 0) {
862 isl_union_set_free(scan);
863 return uset;
864 }
865
866 isl_union_set_free(uset);
867 return scan;
868 }
869
870 static __isl_give isl_union_map *union_map_scan(__isl_take isl_union_map *umap)
871 {
872 return isl_union_set_unwrap(union_set_scan(isl_union_map_wrap(umap)));
873 }
874
875 static __isl_give isl_union_pw_qpolynomial *union_pw_qpolynomial_poly(
876 __isl_take isl_union_pw_qpolynomial *upwqp)
877 {
878 return isl_union_pw_qpolynomial_to_polynomial(upwqp, 0);
879 }
880
881 static __isl_give isl_union_pw_qpolynomial *union_pw_qpolynomial_lpoly(
882 __isl_take isl_union_pw_qpolynomial *upwqp)
883 {
884 return isl_union_pw_qpolynomial_to_polynomial(upwqp, -1);
885 }
886
887 static __isl_give isl_union_pw_qpolynomial *union_pw_qpolynomial_upoly(
888 __isl_take isl_union_pw_qpolynomial *upwqp)
889 {
890 return isl_union_pw_qpolynomial_to_polynomial(upwqp, 1);
891 }
892
893 /* Return the domain of "schedule".
894 */
895 static __isl_give isl_union_set *schedule_domain(
896 __isl_take isl_schedule *schedule)
897 {
898 isl_union_set *domain;
899
900 domain = isl_schedule_get_domain(schedule);
901 isl_schedule_free(schedule);
902
903 return domain;
904 }
905
906 /* Convert "schedule" to a union map representation.
907 */
908 static __isl_give isl_union_map *schedule_map(__isl_take isl_schedule *schedule)
909 {
910 isl_union_map *map;
911
912 map = isl_schedule_get_map(schedule);
913 isl_schedule_free(schedule);
914
915 return map;
916 }
917
918 typedef void *(*isc_un_op_fn)(void *arg);
919 struct isc_un_op {
920 enum isl_token_type op;
921 isl_obj_type arg;
922 isl_obj_type res;
923 isc_un_op_fn fn;
924 };
925 struct isc_named_un_op {
926 char *name;
927 struct isc_un_op op;
928 };
929 struct isc_named_un_op named_un_ops[] = {
930 {"aff", { -1, isl_obj_union_map, isl_obj_union_map,
931 (isc_un_op_fn) &isl_union_map_affine_hull } },
932 {"aff", { -1, isl_obj_union_set, isl_obj_union_set,
933 (isc_un_op_fn) &isl_union_set_affine_hull } },
934 {"card", { -1, isl_obj_union_set,
935 isl_obj_union_pw_qpolynomial,
936 (isc_un_op_fn) &isl_union_set_card } },
937 {"card", { -1, isl_obj_union_map,
938 isl_obj_union_pw_qpolynomial,
939 (isc_un_op_fn) &isl_union_map_card } },
940 {"coalesce", { -1, isl_obj_union_set, isl_obj_union_set,
941 (isc_un_op_fn) &isl_union_set_coalesce } },
942 {"coalesce", { -1, isl_obj_union_map, isl_obj_union_map,
943 (isc_un_op_fn) &isl_union_map_coalesce } },
944 {"coalesce", { -1, isl_obj_union_pw_qpolynomial,
945 isl_obj_union_pw_qpolynomial,
946 (isc_un_op_fn) &isl_union_pw_qpolynomial_coalesce } },
947 {"coalesce", { -1, isl_obj_union_pw_qpolynomial_fold,
948 isl_obj_union_pw_qpolynomial_fold,
949 (isc_un_op_fn) &isl_union_pw_qpolynomial_fold_coalesce } },
950 {"coefficients", { -1, isl_obj_union_set,
951 isl_obj_union_set,
952 (isc_un_op_fn) &isl_union_set_coefficients } },
953 {"solutions", { -1, isl_obj_union_set, isl_obj_union_set,
954 (isc_un_op_fn) &isl_union_set_solutions } },
955 {"deltas", { -1, isl_obj_union_map, isl_obj_union_set,
956 (isc_un_op_fn) &isl_union_map_deltas } },
957 {"deltas_map", { -1, isl_obj_union_map, isl_obj_union_map,
958 (isc_un_op_fn) &isl_union_map_deltas_map } },
959 {"dom", { -1, isl_obj_schedule, isl_obj_union_set,
960 (isc_un_op_fn) &schedule_domain } },
961 {"dom", { -1, isl_obj_union_map, isl_obj_union_set,
962 (isc_un_op_fn) &isl_union_map_domain } },
963 {"dom", { -1, isl_obj_union_pw_qpolynomial, isl_obj_union_set,
964 (isc_un_op_fn) &isl_union_pw_qpolynomial_domain } },
965 {"dom", { -1, isl_obj_union_pw_qpolynomial_fold,
966 isl_obj_union_set,
967 (isc_un_op_fn) &isl_union_pw_qpolynomial_fold_domain } },
968 {"domain", { -1, isl_obj_schedule, isl_obj_union_set,
969 (isc_un_op_fn) &schedule_domain } },
970 {"domain", { -1, isl_obj_union_map, isl_obj_union_set,
971 (isc_un_op_fn) &isl_union_map_domain } },
972 {"domain", { -1, isl_obj_union_pw_qpolynomial,
973 isl_obj_union_set,
974 (isc_un_op_fn) &isl_union_pw_qpolynomial_domain } },
975 {"domain", { -1, isl_obj_union_pw_qpolynomial_fold,
976 isl_obj_union_set,
977 (isc_un_op_fn) &isl_union_pw_qpolynomial_fold_domain } },
978 {"domain_map", { -1, isl_obj_union_map, isl_obj_union_map,
979 (isc_un_op_fn) &isl_union_map_domain_map } },
980 {"ran", { -1, isl_obj_union_map, isl_obj_union_set,
981 (isc_un_op_fn) &isl_union_map_range } },
982 {"range", { -1, isl_obj_union_map, isl_obj_union_set,
983 (isc_un_op_fn) &isl_union_map_range } },
984 {"range_map", { -1, isl_obj_union_map, isl_obj_union_map,
985 (isc_un_op_fn) &isl_union_map_range_map } },
986 {"identity", { -1, isl_obj_union_set, isl_obj_union_map,
987 (isc_un_op_fn) &isl_union_set_identity } },
988 {"lattice_width", { -1, isl_obj_union_set,
989 isl_obj_union_pw_qpolynomial,
990 (isc_un_op_fn) &isl_union_set_lattice_width } },
991 {"lb", { -1, isl_obj_union_pw_qpolynomial, isl_obj_list,
992 (isc_un_op_fn) &union_pw_qpolynomial_lower_bound } },
993 {"lexmin", { -1, isl_obj_union_map, isl_obj_union_map,
994 (isc_un_op_fn) &isl_union_map_lexmin } },
995 {"lexmax", { -1, isl_obj_union_map, isl_obj_union_map,
996 (isc_un_op_fn) &isl_union_map_lexmax } },
997 {"lexmin", { -1, isl_obj_union_set, isl_obj_union_set,
998 (isc_un_op_fn) &isl_union_set_lexmin } },
999 {"lexmax", { -1, isl_obj_union_set, isl_obj_union_set,
1000 (isc_un_op_fn) &isl_union_set_lexmax } },
1001 {"lift", { -1, isl_obj_union_set, isl_obj_union_set,
1002 (isc_un_op_fn) &isl_union_set_lift } },
1003 {"map", { -1, isl_obj_schedule, isl_obj_union_map,
1004 (isc_un_op_fn) &schedule_map } },
1005 {"params", { -1, isl_obj_union_map, isl_obj_set,
1006 (isc_un_op_fn) &isl_union_map_params } },
1007 {"params", { -1, isl_obj_union_set, isl_obj_set,
1008 (isc_un_op_fn) &isl_union_set_params } },
1009 {"poly", { -1, isl_obj_union_map, isl_obj_union_map,
1010 (isc_un_op_fn) &isl_union_map_polyhedral_hull } },
1011 {"poly", { -1, isl_obj_union_set, isl_obj_union_set,
1012 (isc_un_op_fn) &isl_union_set_polyhedral_hull } },
1013 {"poly", { -1, isl_obj_union_pw_qpolynomial,
1014 isl_obj_union_pw_qpolynomial,
1015 (isc_un_op_fn) &union_pw_qpolynomial_poly } },
1016 {"lpoly", { -1, isl_obj_union_pw_qpolynomial,
1017 isl_obj_union_pw_qpolynomial,
1018 (isc_un_op_fn) &union_pw_qpolynomial_lpoly } },
1019 {"upoly", { -1, isl_obj_union_pw_qpolynomial,
1020 isl_obj_union_pw_qpolynomial,
1021 (isc_un_op_fn) &union_pw_qpolynomial_upoly } },
1022 #ifdef HAVE_PET
1023 {"parse_file", { -1, isl_obj_str, isl_obj_list,
1024 (isc_un_op_fn) &parse } },
1025 #endif
1026 {"pow", { -1, isl_obj_union_map, isl_obj_list,
1027 (isc_un_op_fn) &union_map_power } },
1028 {"sample", { -1, isl_obj_union_set, isl_obj_set,
1029 (isc_un_op_fn) &union_set_sample } },
1030 {"sample", { -1, isl_obj_union_map, isl_obj_map,
1031 (isc_un_op_fn) &union_map_sample } },
1032 {"scan", { -1, isl_obj_union_set, isl_obj_union_set,
1033 (isc_un_op_fn) &union_set_scan } },
1034 {"scan", { -1, isl_obj_union_map, isl_obj_union_map,
1035 (isc_un_op_fn) &union_map_scan } },
1036 {"sum", { -1, isl_obj_union_pw_qpolynomial,
1037 isl_obj_union_pw_qpolynomial,
1038 (isc_un_op_fn) &isl_union_pw_qpolynomial_sum } },
1039 {"ub", { -1, isl_obj_union_pw_qpolynomial, isl_obj_list,
1040 (isc_un_op_fn) &union_pw_qpolynomial_upper_bound } },
1041 {"unwrap", { -1, isl_obj_union_set, isl_obj_union_map,
1042 (isc_un_op_fn) &isl_union_set_unwrap } },
1043 {"wrap", { -1, isl_obj_union_map, isl_obj_union_set,
1044 (isc_un_op_fn) &isl_union_map_wrap } },
1045 {"zip", { -1, isl_obj_union_map, isl_obj_union_map,
1046 (isc_un_op_fn) &isl_union_map_zip } },
1047 NULL
1048 };
1049
1050 struct isl_named_obj {
1051 char *name;
1052 struct isl_obj obj;
1053 };
1054
1055 static void free_obj(struct isl_obj obj)
1056 {
1057 obj.type->free(obj.v);
1058 }
1059
1060 static int same_name(const void *entry, const void *val)
1061 {
1062 const struct isl_named_obj *named = (const struct isl_named_obj *)entry;
1063
1064 return !strcmp(named->name, val);
1065 }
1066
1067 static int do_assign(struct isl_ctx *ctx, struct isl_hash_table *table,
1068 char *name, struct isl_obj obj)
1069 {
1070 struct isl_hash_table_entry *entry;
1071 uint32_t name_hash;
1072 struct isl_named_obj *named;
1073
1074 name_hash = isl_hash_string(isl_hash_init(), name);
1075 entry = isl_hash_table_find(ctx, table, name_hash, same_name, name, 1);
1076 if (!entry)
1077 goto error;
1078 if (entry->data) {
1079 named = entry->data;
1080 free_obj(named->obj);
1081 free(name);
1082 } else {
1083 named = isl_alloc_type(ctx, struct isl_named_obj);
1084 if (!named)
1085 goto error;
1086 named->name = name;
1087 entry->data = named;
1088 }
1089 named->obj = obj;
1090
1091 return 0;
1092 error:
1093 free_obj(obj);
1094 free(name);
1095 return -1;
1096 }
1097
1098 static struct isl_obj stored_obj(struct isl_ctx *ctx,
1099 struct isl_hash_table *table, char *name)
1100 {
1101 struct isl_obj obj = { isl_obj_none, NULL };
1102 struct isl_hash_table_entry *entry;
1103 uint32_t name_hash;
1104
1105 name_hash = isl_hash_string(isl_hash_init(), name);
1106 entry = isl_hash_table_find(ctx, table, name_hash, same_name, name, 0);
1107 if (entry) {
1108 struct isl_named_obj *named;
1109 named = entry->data;
1110 obj = named->obj;
1111 } else if (isdigit(name[0]))
1112 fprintf(stderr, "unknown identifier '$%s'\n", name);
1113 else
1114 fprintf(stderr, "unknown identifier '%s'\n", name);
1115
1116 free(name);
1117 obj.v = obj.type->copy(obj.v);
1118 return obj;
1119 }
1120
1121 static int is_subtype(struct isl_obj obj, isl_obj_type super)
1122 {
1123 if (obj.type == super)
1124 return 1;
1125 if (obj.type == isl_obj_map && super == isl_obj_union_map)
1126 return 1;
1127 if (obj.type == isl_obj_set && super == isl_obj_union_set)
1128 return 1;
1129 if (obj.type == isl_obj_schedule && super == isl_obj_union_map)
1130 return 1;
1131 if (obj.type == isl_obj_pw_multi_aff && super == isl_obj_union_set) {
1132 isl_space *space = isl_pw_multi_aff_get_space(obj.v);
1133 int is_set = isl_space_is_set(space);
1134 isl_space_free(space);
1135 return is_set;
1136 }
1137 if (obj.type == isl_obj_pw_qpolynomial &&
1138 super == isl_obj_union_pw_qpolynomial)
1139 return 1;
1140 if (obj.type == isl_obj_pw_qpolynomial_fold &&
1141 super == isl_obj_union_pw_qpolynomial_fold)
1142 return 1;
1143 if (obj.type == isl_obj_union_set && isl_union_set_is_empty(obj.v))
1144 return 1;
1145 if (obj.type == isl_obj_list) {
1146 struct isl_list *list = obj.v;
1147 if (list->n == 2 && list->obj[1].type == isl_obj_bool)
1148 return is_subtype(list->obj[0], super);
1149 }
1150 if (super == isl_obj_str)
1151 return 1;
1152 return 0;
1153 }
1154
1155 static struct isl_obj obj_at(struct isl_obj obj, int i)
1156 {
1157 struct isl_list *list = obj.v;
1158
1159 obj = list->obj[i];
1160 obj.v = obj.type->copy(obj.v);
1161
1162 isl_list_free(list);
1163
1164 return obj;
1165 }
1166
1167 static struct isl_obj convert(isl_ctx *ctx, struct isl_obj obj,
1168 isl_obj_type type)
1169 {
1170 if (obj.type == type)
1171 return obj;
1172 if (obj.type == isl_obj_pw_multi_aff && type == isl_obj_union_set) {
1173 isl_set *set = isl_set_from_pw_multi_aff(obj.v);
1174 obj.type = isl_obj_union_set;
1175 obj.v = isl_union_set_from_set(set);
1176 return obj;
1177 }
1178 if (obj.type == isl_obj_map && type == isl_obj_union_map) {
1179 obj.type = isl_obj_union_map;
1180 obj.v = isl_union_map_from_map(obj.v);
1181 return obj;
1182 }
1183 if (obj.type == isl_obj_schedule && type == isl_obj_union_map) {
1184 obj.type = isl_obj_union_map;
1185 obj.v = schedule_map(obj.v);
1186 return obj;
1187 }
1188 if (obj.type == isl_obj_set && type == isl_obj_union_set) {
1189 obj.type = isl_obj_union_set;
1190 obj.v = isl_union_set_from_set(obj.v);
1191 return obj;
1192 }
1193 if (obj.type == isl_obj_pw_qpolynomial &&
1194 type == isl_obj_union_pw_qpolynomial) {
1195 obj.type = isl_obj_union_pw_qpolynomial;
1196 obj.v = isl_union_pw_qpolynomial_from_pw_qpolynomial(obj.v);
1197 return obj;
1198 }
1199 if (obj.type == isl_obj_pw_qpolynomial_fold &&
1200 type == isl_obj_union_pw_qpolynomial_fold) {
1201 obj.type = isl_obj_union_pw_qpolynomial_fold;
1202 obj.v = isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold(obj.v);
1203 return obj;
1204 }
1205 if (obj.type == isl_obj_union_set && isl_union_set_is_empty(obj.v)) {
1206 if (type == isl_obj_union_map) {
1207 obj.type = isl_obj_union_map;
1208 return obj;
1209 }
1210 if (type == isl_obj_union_pw_qpolynomial) {
1211 isl_space *dim = isl_union_set_get_space(obj.v);
1212 isl_union_set_free(obj.v);
1213 obj.v = isl_union_pw_qpolynomial_zero(dim);
1214 obj.type = isl_obj_union_pw_qpolynomial;
1215 return obj;
1216 }
1217 if (type == isl_obj_union_pw_qpolynomial_fold) {
1218 isl_space *dim = isl_union_set_get_space(obj.v);
1219 isl_union_set_free(obj.v);
1220 obj.v = isl_union_pw_qpolynomial_fold_zero(dim,
1221 isl_fold_list);
1222 obj.type = isl_obj_union_pw_qpolynomial_fold;
1223 return obj;
1224 }
1225 }
1226 if (obj.type == isl_obj_list) {
1227 struct isl_list *list = obj.v;
1228 if (list->n == 2 && list->obj[1].type == isl_obj_bool)
1229 return convert(ctx, obj_at(obj, 0), type);
1230 }
1231 if (type == isl_obj_str) {
1232 isl_str *str;
1233 isl_printer *p;
1234 char *s;
1235
1236 p = isl_printer_to_str(ctx);
1237 if (!p)
1238 goto error;
1239 p = obj.type->print(p, obj.v);
1240 s = isl_printer_get_str(p);
1241 isl_printer_free(p);
1242
1243 str = isl_str_from_string(ctx, s);
1244 if (!str)
1245 goto error;
1246 free_obj(obj);
1247 obj.v = str;
1248 obj.type = isl_obj_str;
1249 return obj;
1250
1251 }
1252 error:
1253 free_obj(obj);
1254 obj.type = isl_obj_none;
1255 obj.v = NULL;
1256 return obj;
1257 }
1258
1259 static struct isc_bin_op *read_bin_op_if_available(struct isl_stream *s,
1260 struct isl_obj lhs)
1261 {
1262 int i;
1263 int read_tok2 = 0;
1264 struct isl_token *tok, *tok2;
1265
1266 tok = isl_stream_next_token(s);
1267 if (!tok)
1268 return NULL;
1269
1270 for (i = 0; ; ++i) {
1271 if (!bin_ops[i].op)
1272 break;
1273 if (bin_ops[i].op != isl_token_get_type(tok))
1274 continue;
1275 if (!is_subtype(lhs, bin_ops[i].lhs))
1276 continue;
1277
1278 isl_token_free(tok);
1279 return &bin_ops[i];
1280 }
1281
1282 for (i = 0; ; ++i) {
1283 if (!named_bin_ops[i].name)
1284 break;
1285 if (named_bin_ops[i].op.op != isl_token_get_type(tok))
1286 continue;
1287 if (!is_subtype(lhs, named_bin_ops[i].op.lhs))
1288 continue;
1289
1290 isl_token_free(tok);
1291 return &named_bin_ops[i].op;
1292 }
1293
1294 for (i = 0; ; ++i) {
1295 if (!compound_bin_ops[i].full)
1296 break;
1297 if (compound_bin_ops[i].op1 != isl_token_get_type(tok))
1298 continue;
1299 if (!read_tok2)
1300 tok2 = isl_stream_next_token(s);
1301 read_tok2 = 1;
1302 if (compound_bin_ops[i].op2 != isl_token_get_type(tok2))
1303 continue;
1304 if (!is_subtype(lhs, compound_bin_ops[i].op.lhs))
1305 continue;
1306
1307 isl_token_free(tok2);
1308 isl_token_free(tok);
1309 return &compound_bin_ops[i].op;
1310 }
1311
1312 if (read_tok2)
1313 isl_stream_push_token(s, tok2);
1314 isl_stream_push_token(s, tok);
1315
1316 return NULL;
1317 }
1318
1319 static struct isc_un_op *read_prefix_un_op_if_available(struct isl_stream *s)
1320 {
1321 int i;
1322 struct isl_token *tok;
1323
1324 tok = isl_stream_next_token(s);
1325 if (!tok)
1326 return NULL;
1327
1328 for (i = 0; ; ++i) {
1329 if (!named_un_ops[i].name)
1330 break;
1331 if (named_un_ops[i].op.op != isl_token_get_type(tok))
1332 continue;
1333
1334 isl_token_free(tok);
1335 return &named_un_ops[i].op;
1336 }
1337
1338 isl_stream_push_token(s, tok);
1339
1340 return NULL;
1341 }
1342
1343 static struct isc_un_op *find_matching_un_op(struct isc_un_op *like,
1344 struct isl_obj arg)
1345 {
1346 int i;
1347
1348 for (i = 0; ; ++i) {
1349 if (!named_un_ops[i].name)
1350 break;
1351 if (named_un_ops[i].op.op != like->op)
1352 continue;
1353 if (!is_subtype(arg, named_un_ops[i].op.arg))
1354 continue;
1355
1356 return &named_un_ops[i].op;
1357 }
1358
1359 return NULL;
1360 }
1361
1362 static int is_assign(struct isl_stream *s)
1363 {
1364 struct isl_token *tok;
1365 struct isl_token *tok2;
1366 int assign;
1367
1368 tok = isl_stream_next_token(s);
1369 if (!tok)
1370 return 0;
1371 if (isl_token_get_type(tok) != ISL_TOKEN_IDENT) {
1372 isl_stream_push_token(s, tok);
1373 return 0;
1374 }
1375
1376 tok2 = isl_stream_next_token(s);
1377 if (!tok2) {
1378 isl_stream_push_token(s, tok);
1379 return 0;
1380 }
1381 assign = isl_token_get_type(tok2) == ISL_TOKEN_DEF;
1382 isl_stream_push_token(s, tok2);
1383 isl_stream_push_token(s, tok);
1384
1385 return assign;
1386 }
1387
1388 static struct isl_obj read_obj(struct isl_stream *s,
1389 struct isl_hash_table *table);
1390 static struct isl_obj read_expr(struct isl_stream *s,
1391 struct isl_hash_table *table);
1392
1393 static struct isl_obj read_un_op_expr(struct isl_stream *s,
1394 struct isl_hash_table *table, struct isc_un_op *op)
1395 {
1396 isl_ctx *ctx;
1397 struct isl_obj obj = { isl_obj_none, NULL };
1398
1399 obj = read_obj(s, table);
1400 if (!obj.v)
1401 goto error;
1402
1403 op = find_matching_un_op(op, obj);
1404
1405 ctx = isl_stream_get_ctx(s);
1406 if (!op)
1407 isl_die(ctx, isl_error_invalid,
1408 "no such unary operator defined on given operand",
1409 goto error);
1410
1411 obj = convert(ctx, obj, op->arg);
1412 obj.v = op->fn(obj.v);
1413 obj.type = op->res;
1414
1415 return obj;
1416 error:
1417 free_obj(obj);
1418 obj.type = isl_obj_none;
1419 obj.v = NULL;
1420 return obj;
1421 }
1422
1423 static struct isl_obj transitive_closure(struct isl_ctx *ctx, struct isl_obj obj)
1424 {
1425 struct isl_list *list;
1426 int exact;
1427
1428 if (obj.type != isl_obj_union_map)
1429 obj = convert(ctx, obj, isl_obj_union_map);
1430 isl_assert(ctx, obj.type == isl_obj_union_map, goto error);
1431 list = isl_list_alloc(ctx, 2);
1432 if (!list)
1433 goto error;
1434
1435 list->obj[0].type = isl_obj_union_map;
1436 list->obj[0].v = isl_union_map_transitive_closure(obj.v, &exact);
1437 list->obj[1].type = isl_obj_bool;
1438 list->obj[1].v = exact ? &iscc_bool_true : &iscc_bool_false;
1439 obj.v = list;
1440 obj.type = isl_obj_list;
1441 if (exact < 0 || !list->obj[0].v)
1442 goto error;
1443
1444 return obj;
1445 error:
1446 free_obj(obj);
1447 obj.type = isl_obj_none;
1448 obj.v = NULL;
1449 return obj;
1450 }
1451
1452 static struct isl_obj obj_at_index(struct isl_stream *s, struct isl_obj obj)
1453 {
1454 struct isl_list *list = obj.v;
1455 struct isl_token *tok;
1456 isl_ctx *ctx;
1457 isl_val *v;
1458 int i;
1459
1460 tok = isl_stream_next_token(s);
1461 if (!tok || isl_token_get_type(tok) != ISL_TOKEN_VALUE) {
1462 isl_stream_error(s, tok, "expecting index");
1463 if (tok)
1464 isl_stream_push_token(s, tok);
1465 goto error;
1466 }
1467 ctx = isl_stream_get_ctx(s);
1468 v = isl_token_get_val(ctx, tok);
1469 i = isl_val_get_num_si(v);
1470 isl_val_free(v);
1471 isl_token_free(tok);
1472 isl_assert(ctx, i < list->n, goto error);
1473 if (isl_stream_eat(s, ']'))
1474 goto error;
1475
1476 return obj_at(obj, i);
1477 error:
1478 free_obj(obj);
1479 obj.type = isl_obj_none;
1480 obj.v = NULL;
1481 return obj;
1482 }
1483
1484 static struct isl_obj apply(struct isl_stream *s, __isl_take isl_union_map *umap,
1485 struct isl_hash_table *table)
1486 {
1487 isl_ctx *ctx;
1488 struct isl_obj obj;
1489
1490 obj = read_expr(s, table);
1491 ctx = isl_stream_get_ctx(s);
1492 isl_assert(ctx, is_subtype(obj, isl_obj_union_set) ||
1493 is_subtype(obj, isl_obj_union_map), goto error);
1494
1495 if (obj.type == isl_obj_list) {
1496 struct isl_list *list = obj.v;
1497 if (list->n == 2 && list->obj[1].type == isl_obj_bool)
1498 obj = obj_at(obj, 0);
1499 }
1500 if (obj.type == isl_obj_set)
1501 obj = convert(ctx, obj, isl_obj_union_set);
1502 else if (obj.type == isl_obj_map)
1503 obj = convert(ctx, obj, isl_obj_union_map);
1504 if (obj.type == isl_obj_union_set) {
1505 obj.v = isl_union_set_apply(obj.v, umap);
1506 } else
1507 obj.v = isl_union_map_apply_range(obj.v, umap);
1508 if (!obj.v)
1509 goto error2;
1510
1511 if (isl_stream_eat(s, ')'))
1512 goto error2;
1513
1514 return obj;
1515 error:
1516 isl_union_map_free(umap);
1517 error2:
1518 free_obj(obj);
1519 obj.type = isl_obj_none;
1520 obj.v = NULL;
1521 return obj;
1522 }
1523
1524 static struct isl_obj apply_fun_set(struct isl_obj obj,
1525 __isl_take isl_union_set *uset)
1526 {
1527 if (obj.type == isl_obj_union_pw_qpolynomial) {
1528 obj.v = isl_union_set_apply_union_pw_qpolynomial(uset, obj.v);
1529 } else {
1530 obj.type = isl_obj_list;
1531 obj.v = union_set_apply_union_pw_qpolynomial_fold(uset, obj.v);
1532 }
1533 return obj;
1534 }
1535
1536 static struct isl_obj apply_fun_map(struct isl_obj obj,
1537 __isl_take isl_union_map *umap)
1538 {
1539 if (obj.type == isl_obj_union_pw_qpolynomial) {
1540 obj.v = isl_union_map_apply_union_pw_qpolynomial(umap, obj.v);
1541 } else {
1542 obj.type = isl_obj_list;
1543 obj.v = union_map_apply_union_pw_qpolynomial_fold(umap, obj.v);
1544 }
1545 return obj;
1546 }
1547
1548 static struct isl_obj apply_fun(struct isl_stream *s,
1549 struct isl_obj obj, struct isl_hash_table *table)
1550 {
1551 struct isl_obj arg;
1552 isl_ctx *ctx;
1553
1554 arg = read_expr(s, table);
1555 ctx = isl_stream_get_ctx(s);
1556 if (!is_subtype(arg, isl_obj_union_map) &&
1557 !is_subtype(arg, isl_obj_union_set))
1558 isl_die(ctx, isl_error_invalid,
1559 "expecting set of map argument", goto error);
1560
1561 if (arg.type == isl_obj_list) {
1562 struct isl_list *list = arg.v;
1563 if (list->n == 2 && list->obj[1].type == isl_obj_bool)
1564 arg = obj_at(arg, 0);
1565 }
1566 if (arg.type == isl_obj_set)
1567 arg = convert(ctx, arg, isl_obj_union_set);
1568 else if (arg.type == isl_obj_map)
1569 arg = convert(ctx, arg, isl_obj_union_map);
1570 if (arg.type == isl_obj_union_set)
1571 obj = apply_fun_set(obj, arg.v);
1572 else
1573 obj = apply_fun_map(obj, arg.v);
1574 if (!obj.v)
1575 goto error2;
1576
1577 if (isl_stream_eat(s, ')'))
1578 goto error2;
1579
1580 return obj;
1581 error:
1582 free_obj(arg);
1583 error2:
1584 free_obj(obj);
1585 obj.type = isl_obj_none;
1586 obj.v = NULL;
1587 return obj;
1588 }
1589
1590 struct add_vertex_data {
1591 struct isl_list *list;
1592 int i;
1593 };
1594
1595 static isl_stat add_vertex(__isl_take isl_vertex *vertex, void *user)
1596 {
1597 struct add_vertex_data *data = (struct add_vertex_data *)user;
1598 isl_multi_aff *ma;
1599 isl_set *dom;
1600
1601 ma = isl_vertex_get_expr(vertex);
1602 dom = isl_set_from_basic_set(isl_vertex_get_domain(vertex));
1603
1604 data->list->obj[data->i].type = isl_obj_pw_multi_aff;
1605 data->list->obj[data->i].v = isl_pw_multi_aff_alloc(dom, ma);
1606 data->i++;
1607
1608 isl_vertex_free(vertex);
1609
1610 return isl_stat_ok;
1611 }
1612
1613 static isl_stat set_vertices(__isl_take isl_set *set, void *user)
1614 {
1615 isl_ctx *ctx;
1616 isl_basic_set *hull;
1617 isl_vertices *vertices = NULL;
1618 struct isl_list *list = NULL;
1619 isl_stat r;
1620 struct add_vertex_data *data = (struct add_vertex_data *)user;
1621
1622 set = isl_set_remove_divs(set);
1623 hull = isl_set_convex_hull(set);
1624 vertices = isl_basic_set_compute_vertices(hull);
1625 isl_basic_set_free(hull);
1626
1627 list = data->list;
1628
1629 ctx = isl_vertices_get_ctx(vertices);
1630 data->list = isl_list_alloc(ctx, isl_vertices_get_n_vertices(vertices));
1631 if (!data->list)
1632 goto error;
1633
1634 data->i = 0;
1635 r = isl_vertices_foreach_vertex(vertices, &add_vertex, user);
1636
1637 data->list = isl_list_concat(list, data->list);
1638
1639 isl_vertices_free(vertices);
1640
1641 return r;
1642 error:
1643 data->list = list;
1644 isl_vertices_free(vertices);
1645 return isl_stat_error;
1646 }
1647
1648 static struct isl_obj vertices(struct isl_stream *s,
1649 struct isl_hash_table *table)
1650 {
1651 isl_ctx *ctx;
1652 struct isl_obj obj;
1653 struct isl_list *list = NULL;
1654 isl_union_set *uset = NULL;
1655 struct add_vertex_data data = { NULL };
1656
1657 obj = read_expr(s, table);
1658 ctx = isl_stream_get_ctx(s);
1659 obj = convert(ctx, obj, isl_obj_union_set);
1660 isl_assert(ctx, obj.type == isl_obj_union_set, goto error);
1661 uset = obj.v;
1662 obj.v = NULL;
1663
1664 list = isl_list_alloc(ctx, 0);
1665 if (!list)
1666 goto error;
1667
1668 data.list = list;
1669
1670 if (isl_union_set_foreach_set(uset, &set_vertices, &data) < 0)
1671 goto error;
1672
1673 isl_union_set_free(uset);
1674
1675 obj.type = isl_obj_list;
1676 obj.v = data.list;
1677
1678 return obj;
1679 error:
1680 isl_union_set_free(uset);
1681 isl_list_free(data.list);
1682 free_obj(obj);
1683 obj.type = isl_obj_none;
1684 obj.v = NULL;
1685 return obj;
1686 }
1687
1688 static struct isl_obj type_of(struct isl_stream *s,
1689 struct isl_hash_table *table)
1690 {
1691 struct isl_obj obj;
1692 const char *type = "unknown";
1693
1694 obj = read_expr(s, table);
1695
1696 if (obj.type == isl_obj_map ||
1697 obj.type == isl_obj_union_map)
1698 type = "map";
1699 if (obj.type == isl_obj_set ||
1700 obj.type == isl_obj_union_set)
1701 type = "set";
1702 if (obj.type == isl_obj_pw_multi_aff)
1703 type = "piecewise multi-quasiaffine expression";
1704 if (obj.type == isl_obj_pw_qpolynomial ||
1705 obj.type == isl_obj_union_pw_qpolynomial)
1706 type = "piecewise quasipolynomial";
1707 if (obj.type == isl_obj_pw_qpolynomial_fold ||
1708 obj.type == isl_obj_union_pw_qpolynomial_fold)
1709 type = "piecewise quasipolynomial fold";
1710 if (obj.type == isl_obj_list)
1711 type = "list";
1712 if (obj.type == isl_obj_bool)
1713 type = "boolean";
1714 if (obj.type == isl_obj_str)
1715 type = "string";
1716 if (obj.type == isl_obj_val)
1717 type = "value";
1718 if (obj.type == isl_obj_schedule)
1719 type = "schedule";
1720
1721 free_obj(obj);
1722 obj.type = isl_obj_str;
1723 obj.v = isl_str_from_string(isl_stream_get_ctx(s), strdup(type));
1724
1725 return obj;
1726 }
1727
1728 static __isl_give isl_union_set *read_set(struct isl_stream *s,
1729 struct isl_hash_table *table)
1730 {
1731 struct isl_obj obj;
1732 isl_ctx *ctx;
1733
1734 obj = read_obj(s, table);
1735 ctx = isl_stream_get_ctx(s);
1736 obj = convert(ctx, obj, isl_obj_union_set);
1737 isl_assert(ctx, obj.type == isl_obj_union_set, goto error);
1738 return obj.v;
1739 error:
1740 free_obj(obj);
1741 return NULL;
1742 }
1743
1744 static __isl_give isl_union_map *read_map(struct isl_stream *s,
1745 struct isl_hash_table *table)
1746 {
1747 struct isl_obj obj;
1748 isl_ctx *ctx;
1749
1750 obj = read_obj(s, table);
1751 ctx = isl_stream_get_ctx(s);
1752 obj = convert(ctx, obj, isl_obj_union_map);
1753 isl_assert(ctx, obj.type == isl_obj_union_map, goto error);
1754 return obj.v;
1755 error:
1756 free_obj(obj);
1757 return NULL;
1758 }
1759
1760 /* Read a schedule in the form of either a schedule (tree) or a union map
1761 * from "s" and store the schedule in "access".
1762 */
1763 static __isl_give isl_union_access_info *access_info_set_schedule(
1764 __isl_take isl_union_access_info *access, struct isl_stream *s,
1765 struct isl_hash_table *table)
1766 {
1767 struct isl_obj obj;
1768 isl_ctx *ctx;
1769
1770 obj = read_obj(s, table);
1771 if (obj.type == isl_obj_schedule)
1772 return isl_union_access_info_set_schedule(access, obj.v);
1773 ctx = isl_stream_get_ctx(s);
1774 obj = convert(ctx, obj, isl_obj_union_map);
1775
1776 return isl_union_access_info_set_schedule_map(access, obj.v);
1777 }
1778
1779 static struct isl_obj last_any(struct isl_stream *s,
1780 struct isl_hash_table *table, __isl_take isl_union_map *must_source,
1781 __isl_take isl_union_map *may_source)
1782 {
1783 struct isl_obj obj = { isl_obj_none, NULL };
1784 isl_union_access_info *access;
1785 isl_union_flow *flow;
1786 isl_union_map *sink = NULL;
1787 isl_union_map *may_dep;
1788
1789 if (isl_stream_eat(s, iscc_op[ISCC_BEFORE]))
1790 goto error;
1791
1792 sink = read_map(s, table);
1793 if (!sink)
1794 goto error;
1795
1796 if (isl_stream_eat(s, iscc_op[ISCC_UNDER]))
1797 goto error;
1798
1799 access = isl_union_access_info_from_sink(sink);
1800 access = isl_union_access_info_set_must_source(access, must_source);
1801 access = isl_union_access_info_set_may_source(access, may_source);
1802 access = access_info_set_schedule(access, s, table);
1803 flow = isl_union_access_info_compute_flow(access);
1804 may_dep = isl_union_flow_get_may_dependence(flow);
1805 isl_union_flow_free(flow);
1806
1807 if (!may_dep)
1808 return obj;
1809
1810 obj.type = isl_obj_union_map;
1811 obj.v = may_dep;
1812
1813 return obj;
1814 error:
1815 isl_union_map_free(may_source);
1816 isl_union_map_free(must_source);
1817 isl_union_map_free(sink);
1818 free_obj(obj);
1819 obj.type = isl_obj_none;
1820 obj.v = NULL;
1821 return obj;
1822 }
1823
1824 static struct isl_obj any(struct isl_stream *s, struct isl_hash_table *table)
1825 {
1826 struct isl_obj obj = { isl_obj_none, NULL };
1827 isl_union_access_info *access;
1828 isl_union_flow *flow;
1829 isl_union_map *may_source = NULL;
1830 isl_union_map *sink = NULL;
1831 isl_union_map *may_dep;
1832
1833 may_source = read_map(s, table);
1834 if (!may_source)
1835 goto error;
1836
1837 if (isl_stream_eat_if_available(s, iscc_op[ISCC_LAST])) {
1838 isl_union_map *must_source;
1839 must_source = read_map(s, table);
1840 if (!must_source)
1841 goto error;
1842 return last_any(s, table, must_source, may_source);
1843 }
1844
1845 if (isl_stream_eat(s, iscc_op[ISCC_BEFORE]))
1846 goto error;
1847
1848 sink = read_map(s, table);
1849 if (!sink)
1850 goto error;
1851
1852 if (isl_stream_eat(s, iscc_op[ISCC_UNDER]))
1853 goto error;
1854
1855 access = isl_union_access_info_from_sink(sink);
1856 access = isl_union_access_info_set_may_source(access, may_source);
1857 access = access_info_set_schedule(access, s, table);
1858 flow = isl_union_access_info_compute_flow(access);
1859 may_dep = isl_union_flow_get_may_dependence(flow);
1860 isl_union_flow_free(flow);
1861
1862 if (!may_dep)
1863 return obj;
1864
1865 obj.type = isl_obj_union_map;
1866 obj.v = may_dep;
1867
1868 return obj;
1869 error:
1870 isl_union_map_free(may_source);
1871 isl_union_map_free(sink);
1872 free_obj(obj);
1873 obj.type = isl_obj_none;
1874 obj.v = NULL;
1875 return obj;
1876 }
1877
1878 static struct isl_obj last(struct isl_stream *s, struct isl_hash_table *table)
1879 {
1880 struct isl_obj obj = { isl_obj_none, NULL };
1881 struct isl_list *list = NULL;
1882 isl_union_access_info *access;
1883 isl_union_flow *flow;
1884 isl_union_map *must_source = NULL;
1885 isl_union_map *sink = NULL;
1886 isl_union_map *must_dep;
1887 isl_union_map *must_no_source;
1888
1889 must_source = read_map(s, table);
1890 if (!must_source)
1891 goto error;
1892
1893 if (isl_stream_eat_if_available(s, iscc_op[ISCC_ANY])) {
1894 isl_union_map *may_source;
1895 may_source = read_map(s, table);
1896 if (!may_source)
1897 goto error;
1898 return last_any(s, table, must_source, may_source);
1899 }
1900
1901 list = isl_list_alloc(isl_stream_get_ctx(s), 2);
1902 if (!list)
1903 goto error;
1904
1905 if (isl_stream_eat(s, iscc_op[ISCC_BEFORE]))
1906 goto error;
1907
1908 sink = read_map(s, table);
1909 if (!sink)
1910 goto error;
1911
1912 if (isl_stream_eat(s, iscc_op[ISCC_UNDER]))
1913 goto error;
1914
1915 access = isl_union_access_info_from_sink(sink);
1916 access = isl_union_access_info_set_must_source(access, must_source);
1917 access = access_info_set_schedule(access, s, table);
1918 flow = isl_union_access_info_compute_flow(access);
1919 must_dep = isl_union_flow_get_must_dependence(flow);
1920 must_no_source = isl_union_flow_get_must_no_source(flow);
1921 isl_union_flow_free(flow);
1922
1923 list->obj[0].type = isl_obj_union_map;
1924 list->obj[0].v = must_dep;
1925 list->obj[1].type = isl_obj_union_map;
1926 list->obj[1].v = must_no_source;
1927
1928 if (!must_dep || !must_no_source) {
1929 isl_list_free(list);
1930 return obj;
1931 }
1932
1933 obj.v = list;
1934 obj.type = isl_obj_list;
1935
1936 return obj;
1937 error:
1938 isl_list_free(list);
1939 isl_union_map_free(must_source);
1940 isl_union_map_free(sink);
1941 free_obj(obj);
1942 obj.type = isl_obj_none;
1943 obj.v = NULL;
1944 return obj;
1945 }
1946
1947 static __isl_give isl_schedule *get_schedule(struct isl_stream *s,
1948 struct isl_hash_table *table)
1949 {
1950 isl_union_set *domain;
1951 isl_union_map *validity;
1952 isl_union_map *proximity;
1953
1954 domain = read_set(s, table);
1955 if (!domain)
1956 return NULL;
1957
1958 validity = isl_union_map_empty(isl_union_set_get_space(domain));
1959 proximity = isl_union_map_empty(isl_union_set_get_space(domain));
1960
1961 for (;;) {
1962 isl_union_map *umap;
1963 if (isl_stream_eat_if_available(s, iscc_op[ISCC_RESPECTING])) {
1964 umap = read_map(s, table);
1965 validity = isl_union_map_union(validity, umap);
1966 } else if (isl_stream_eat_if_available(s, iscc_op[ISCC_MINIMIZING])) {
1967 umap = read_map(s, table);
1968 proximity = isl_union_map_union(proximity, umap);
1969 } else
1970 break;
1971 }
1972
1973 return isl_union_set_compute_schedule(domain, validity, proximity);
1974 }
1975
1976 static struct isl_obj schedule(struct isl_stream *s,
1977 struct isl_hash_table *table)
1978 {
1979 struct isl_obj obj = { isl_obj_none, NULL };
1980 isl_schedule *schedule;
1981
1982 schedule = get_schedule(s, table);
1983
1984 obj.v = schedule;
1985 obj.type = isl_obj_schedule;
1986
1987 return obj;
1988 }
1989
1990 /* Read a schedule for code generation in the form of either
1991 * a schedule tree or a union map.
1992 * If the input is a set rather than a map, then we construct
1993 * an identity union map schedule on the given set.
1994 */
1995 static struct isl_obj get_codegen_schedule(struct isl_stream *s,
1996 struct isl_hash_table *table)
1997 {
1998 struct isl_obj obj;
1999 isl_ctx *ctx;
2000
2001 obj = read_obj(s, table);
2002 ctx = isl_stream_get_ctx(s);
2003
2004 if (obj.type == isl_obj_schedule)
2005 return obj;
2006 if (is_subtype(obj, isl_obj_union_set)) {
2007 obj = convert(ctx, obj, isl_obj_union_set);
2008 obj.v = isl_union_set_identity(obj.v);
2009 obj.type = isl_obj_union_map;
2010 }
2011 if (is_subtype(obj, isl_obj_union_map))
2012 return convert(ctx, obj, isl_obj_union_map);
2013
2014 free_obj(obj);
2015 obj.v = NULL;
2016 obj.type = isl_obj_none;
2017 isl_die(ctx, isl_error_invalid, "expecting schedule, set or map",
2018 return obj);
2019 }
2020
2021 /* Generate an AST for the given schedule and options and return the AST.
2022 */
2023 static __isl_give isl_ast_node *get_ast_from_union_map(
2024 __isl_take isl_union_map *schedule, __isl_take isl_union_map *options)
2025 {
2026 isl_space *space;
2027 isl_set *context;
2028 isl_ast_build *build;
2029 isl_ast_node *tree;
2030
2031 space = isl_union_map_get_space(schedule);
2032 context = isl_set_universe(isl_space_params(space));
2033
2034 build = isl_ast_build_from_context(context);
2035 build = isl_ast_build_set_options(build, options);
2036 tree = isl_ast_build_ast_from_schedule(build, schedule);
2037 isl_ast_build_free(build);
2038
2039 return tree;
2040 }
2041
2042 /* Generate an AST for the given schedule and return the AST.
2043 */
2044 static __isl_give isl_ast_node *get_ast_from_schedule(
2045 __isl_take isl_schedule *schedule)
2046 {
2047 isl_ast_build *build;
2048 isl_ast_node *tree;
2049
2050 build = isl_ast_build_alloc(isl_schedule_get_ctx(schedule));
2051 tree = isl_ast_build_node_from_schedule(build, schedule);
2052 isl_ast_build_free(build);
2053
2054 return tree;
2055 }
2056
2057 /* Print the AST "tree" on the printer "p".
2058 */
2059 static __isl_give isl_printer *print_ast(__isl_take isl_printer *p,
2060 __isl_take isl_ast_node *tree)
2061 {
2062 int format;
2063
2064 format = isl_printer_get_output_format(p);
2065 p = isl_printer_set_output_format(p, ISL_FORMAT_C);
2066 p = isl_printer_print_ast_node(p, tree);
2067 p = isl_printer_set_output_format(p, format);
2068
2069 isl_ast_node_free(tree);
2070
2071 return p;
2072 }
2073
2074 /* Perform the codegen operation.
2075 * In particular, read a schedule, check if the user has specified any options
2076 * and then generate an AST from the schedule (and options) and print it.
2077 * In case the schedule is specified as a schedule tree, the AST generation
2078 * options are embedded in the schedule, so they are not read in separately.
2079 */
2080 static __isl_give isl_printer *codegen(struct isl_stream *s,
2081 struct isl_hash_table *table, __isl_take isl_printer *p)
2082 {
2083 struct isl_obj obj;
2084 isl_ast_node *tree;
2085
2086 obj = get_codegen_schedule(s, table);
2087 if (!obj.v)
2088 return p;
2089
2090 if (obj.type == isl_obj_schedule) {
2091 isl_schedule *schedule = obj.v;
2092
2093 tree = get_ast_from_schedule(schedule);
2094 } else {
2095 isl_union_map *schedule = obj.v;
2096 isl_union_map *options;
2097
2098 if (isl_stream_eat_if_available(s, iscc_op[ISCC_USING]))
2099 options = read_map(s, table);
2100 else
2101 options = isl_union_map_empty(
2102 isl_union_map_get_space(schedule));
2103
2104 tree = get_ast_from_union_map(schedule, options);
2105 }
2106
2107 if (tree)
2108 p = print_ast(p, tree);
2109
2110 isl_stream_eat(s, ';');
2111
2112 return p;
2113 }
2114
2115 static struct isl_obj power(struct isl_stream *s, struct isl_obj obj)
2116 {
2117 struct isl_token *tok;
2118 isl_ctx *ctx;
2119 isl_val *v;
2120
2121 ctx = isl_stream_get_ctx(s);
2122 if (isl_stream_eat_if_available(s, '+'))
2123 return transitive_closure(ctx, obj);
2124
2125 isl_assert(ctx, is_subtype(obj, isl_obj_union_map), goto error);
2126 if (obj.type != isl_obj_union_map)
2127 obj = convert(ctx, obj, isl_obj_union_map);
2128
2129 tok = isl_stream_next_token(s);
2130 if (!tok || isl_token_get_type(tok) != ISL_TOKEN_VALUE) {
2131 isl_stream_error(s, tok, "expecting integer exponent");
2132 if (tok)
2133 isl_stream_push_token(s, tok);
2134 goto error;
2135 }
2136
2137 v = isl_token_get_val(ctx, tok);
2138 if (isl_val_is_zero(v)) {
2139 isl_stream_error(s, tok, "expecting non-zero exponent");
2140 isl_val_free(v);
2141 if (tok)
2142 isl_stream_push_token(s, tok);
2143 goto error;
2144 }
2145
2146 obj.v = isl_union_map_fixed_power_val(obj.v, v);
2147 isl_token_free(tok);
2148 if (!obj.v)
2149 goto error;
2150
2151 return obj;
2152 error:
2153 free_obj(obj);
2154 obj.type = isl_obj_none;
2155 obj.v = NULL;
2156 return obj;
2157 }
2158
2159 static struct isl_obj check_assert(struct isl_stream *s,
2160 struct isl_hash_table *table)
2161 {
2162 struct isl_obj obj;
2163 isl_ctx *ctx;
2164
2165 obj = read_expr(s, table);
2166 ctx = isl_stream_get_ctx(s);
2167 if (obj.type != isl_obj_bool)
2168 isl_die(ctx, isl_error_invalid,
2169 "expecting boolean expression", goto error);
2170 if (obj.v != &iscc_bool_true)
2171 isl_die(ctx, isl_error_unknown,
2172 "assertion failed", abort());
2173 error:
2174 free_obj(obj);
2175 obj.type = isl_obj_none;
2176 obj.v = NULL;
2177 return obj;
2178 }
2179
2180 static struct isl_obj read_from_file(struct isl_stream *s)
2181 {
2182 isl_ctx *ctx;
2183 struct isl_obj obj;
2184 struct isl_token *tok;
2185 struct isl_stream *s_file;
2186 struct iscc_options *options;
2187 char *name;
2188 FILE *file;
2189
2190 tok = isl_stream_next_token(s);
2191 if (!tok || isl_token_get_type(tok) != ISL_TOKEN_STRING) {
2192 isl_stream_error(s, tok, "expecting filename");
2193 isl_token_free(tok);
2194 goto error;
2195 }
2196
2197 ctx = isl_stream_get_ctx(s);
2198 options = isl_ctx_peek_iscc_options(ctx);
2199 if (!options || !options->io) {
2200 isl_token_free(tok);
2201 isl_die(ctx, isl_error_invalid,
2202 "read operation not allowed", goto error);
2203 }
2204
2205 name = isl_token_get_str(ctx, tok);
2206 isl_token_free(tok);
2207 file = fopen(name, "r");
2208 free(name);
2209 isl_assert(ctx, file, goto error);
2210
2211 s_file = isl_stream_new_file(ctx, file);
2212 if (!s_file) {
2213 fclose(file);
2214 goto error;
2215 }
2216
2217 obj = isl_stream_read_obj(s_file);
2218
2219 isl_stream_free(s_file);
2220 fclose(file);
2221
2222 return obj;
2223 error:
2224 obj.type = isl_obj_none;
2225 obj.v = NULL;
2226 return obj;
2227 }
2228
2229 static struct isl_obj write_to_file(struct isl_stream *s,
2230 struct isl_hash_table *table)
2231 {
2232 struct isl_obj obj = { isl_obj_none, NULL };
2233 struct isl_token *tok;
2234 struct iscc_options *options;
2235 char *name;
2236 FILE *file;
2237 isl_ctx *ctx;
2238 isl_printer *p;
2239
2240 tok = isl_stream_next_token(s);
2241 if (!tok || isl_token_get_type(tok) != ISL_TOKEN_STRING) {
2242 isl_stream_error(s, tok, "expecting filename");
2243 isl_token_free(tok);
2244 goto error;
2245 }
2246
2247 obj = read_expr(s, table);
2248
2249 ctx = isl_stream_get_ctx(s);
2250 options = isl_ctx_peek_iscc_options(ctx);
2251 if (!options || !options->io) {
2252 isl_token_free(tok);
2253 isl_die(ctx, isl_error_invalid,
2254 "write operation not allowed", goto error);
2255 }
2256
2257 name = isl_token_get_str(ctx, tok);
2258 isl_token_free(tok);
2259 file = fopen(name, "w");
2260 free(name);
2261 if (!file)
2262 isl_die(ctx, isl_error_unknown,
2263 "could not open file for writing", goto error);
2264
2265 p = isl_printer_to_file(ctx, file);
2266 p = isl_printer_set_output_format(p, options->format);
2267 p = obj.type->print(p, obj.v);
2268 p = isl_printer_end_line(p);
2269 isl_printer_free(p);
2270
2271 fclose(file);
2272 error:
2273 free_obj(obj);
2274 obj.type = isl_obj_none;
2275 obj.v = NULL;
2276 return obj;
2277 }
2278
2279 static struct isl_obj read_string_if_available(struct isl_stream *s)
2280 {
2281 struct isl_token *tok;
2282 struct isl_obj obj = { isl_obj_none, NULL };
2283
2284 tok = isl_stream_next_token(s);
2285 if (!tok)
2286 return obj;
2287 if (isl_token_get_type(tok) == ISL_TOKEN_STRING) {
2288 isl_str *str;
2289 str = isl_str_alloc(isl_stream_get_ctx(s));
2290 if (!str)
2291 goto error;
2292 str->s = isl_token_get_str(isl_stream_get_ctx(s), tok);
2293 isl_token_free(tok);
2294 obj.v = str;
2295 obj.type = isl_obj_str;
2296 } else
2297 isl_stream_push_token(s, tok);
2298 return obj;
2299 error:
2300 isl_token_free(tok);
2301 return obj;
2302 }
2303
2304 static struct isl_obj read_bool_if_available(struct isl_stream *s)
2305 {
2306 struct isl_token *tok;
2307 struct isl_obj obj = { isl_obj_none, NULL };
2308 int type;
2309
2310 tok = isl_stream_next_token(s);
2311 if (!tok)
2312 return obj;
2313 type = isl_token_get_type(tok);
2314 if (type == ISL_TOKEN_FALSE || type == ISL_TOKEN_TRUE) {
2315 int is_true = type == ISL_TOKEN_TRUE;
2316 isl_token_free(tok);
2317 obj.v = is_true ? &iscc_bool_true : &iscc_bool_false;
2318 obj.type = isl_obj_bool;
2319 } else
2320 isl_stream_push_token(s, tok);
2321 return obj;
2322 }
2323
2324 static __isl_give char *read_ident(struct isl_stream *s)
2325 {
2326 char *name;
2327 isl_val *v;
2328 struct isl_token *tok, *tok2;
2329
2330 name = isl_stream_read_ident_if_available(s);
2331 if (name)
2332 return name;
2333
2334 tok = isl_stream_next_token(s);
2335 if (!tok)
2336 return NULL;
2337 if (isl_token_get_type(tok) != '$') {
2338 isl_stream_push_token(s, tok);
2339 return NULL;
2340 }
2341 tok2 = isl_stream_next_token(s);
2342 if (!tok2 || isl_token_get_type(tok2) != ISL_TOKEN_VALUE) {
2343 if (tok2)
2344 isl_stream_push_token(s, tok2);
2345 isl_stream_push_token(s, tok);
2346 return NULL;
2347 }
2348
2349 v = isl_token_get_val(isl_stream_get_ctx(s), tok2);
2350 name = isl_val_to_str(v);
2351 isl_val_free(v);
2352 isl_token_free(tok);
2353 isl_token_free(tok2);
2354
2355 return name;
2356 }
2357
2358 static struct isl_obj read_list(struct isl_stream *s,
2359 struct isl_hash_table *table, struct isl_obj obj)
2360 {
2361 struct isl_list *list;
2362
2363 list = isl_list_alloc(isl_stream_get_ctx(s), 2);
2364 if (!list)
2365 goto error;
2366 list->obj[0] = obj;
2367 list->obj[1] = read_obj(s, table);
2368 obj.v = list;
2369 obj.type = isl_obj_list;
2370
2371 if (!list->obj[1].v)
2372 goto error;
2373
2374 while (isl_stream_eat_if_available(s, ',')) {
2375 obj.v = list = isl_list_add_obj(list, read_obj(s, table));
2376 if (!obj.v)
2377 goto error;
2378 }
2379
2380 return obj;
2381 error:
2382 free_obj(obj);
2383 obj.type = isl_obj_none;
2384 obj.v = NULL;
2385 return obj;
2386 }
2387
2388 static struct isl_obj read_obj(struct isl_stream *s,
2389 struct isl_hash_table *table)
2390 {
2391 isl_ctx *ctx;
2392 struct isl_obj obj = { isl_obj_none, NULL };
2393 char *name = NULL;
2394 struct isc_un_op *op = NULL;
2395
2396 obj = read_string_if_available(s);
2397 if (obj.v)
2398 return obj;
2399 obj = read_bool_if_available(s);
2400 if (obj.v)
2401 return obj;
2402 ctx = isl_stream_get_ctx(s);
2403 if (isl_stream_eat_if_available(s, '(')) {
2404 if (isl_stream_next_token_is(s, ')')) {
2405 obj.type = isl_obj_list;
2406 obj.v = isl_list_alloc(ctx, 0);
2407 } else {
2408 obj = read_expr(s, table);
2409 if (obj.v && isl_stream_eat_if_available(s, ','))
2410 obj = read_list(s, table, obj);
2411 }
2412 if (!obj.v || isl_stream_eat(s, ')'))
2413 goto error;
2414 } else {
2415 op = read_prefix_un_op_if_available(s);
2416 if (op)
2417 return read_un_op_expr(s, table, op);
2418
2419 if (isl_stream_eat_if_available(s, iscc_op[ISCC_ASSERT]))
2420 return check_assert(s, table);
2421 if (isl_stream_eat_if_available(s, iscc_op[ISCC_READ]))
2422 return read_from_file(s);
2423 if (isl_stream_eat_if_available(s, iscc_op[ISCC_WRITE]))
2424 return write_to_file(s, table);
2425 if (isl_stream_eat_if_available(s, iscc_op[ISCC_VERTICES]))
2426 return vertices(s, table);
2427 if (isl_stream_eat_if_available(s, iscc_op[ISCC_ANY]))
2428 return any(s, table);
2429 if (isl_stream_eat_if_available(s, iscc_op[ISCC_LAST]))
2430 return last(s, table);
2431 if (isl_stream_eat_if_available(s, iscc_op[ISCC_SCHEDULE]))
2432 return schedule(s, table);
2433 if (isl_stream_eat_if_available(s, iscc_op[ISCC_TYPEOF]))
2434 return type_of(s, table);
2435
2436 name = read_ident(s);
2437 if (name)
2438 obj = stored_obj(ctx, table, name);
2439 else
2440 obj = isl_stream_read_obj(s);
2441 if (!obj.v)
2442 goto error;
2443 }
2444
2445 if (isl_stream_eat_if_available(s, '^'))
2446 obj = power(s, obj);
2447 else if (obj.type == isl_obj_list && isl_stream_eat_if_available(s, '['))
2448 obj = obj_at_index(s, obj);
2449 else if (is_subtype(obj, isl_obj_union_map) &&
2450 isl_stream_eat_if_available(s, '(')) {
2451 obj = convert(ctx, obj, isl_obj_union_map);
2452 obj = apply(s, obj.v, table);
2453 } else if (is_subtype(obj, isl_obj_union_pw_qpolynomial) &&
2454 isl_stream_eat_if_available(s, '(')) {
2455 obj = convert(ctx, obj, isl_obj_union_pw_qpolynomial);
2456 obj = apply_fun(s, obj, table);
2457 } else if (is_subtype(obj, isl_obj_union_pw_qpolynomial_fold) &&
2458 isl_stream_eat_if_available(s, '(')) {
2459 obj = convert(ctx, obj, isl_obj_union_pw_qpolynomial_fold);
2460 obj = apply_fun(s, obj, table);
2461 }
2462
2463 return obj;
2464 error:
2465 free_obj(obj);
2466 obj.type = isl_obj_none;
2467 obj.v = NULL;
2468 return obj;
2469 }
2470
2471 static struct isc_bin_op *find_matching_bin_op(struct isc_bin_op *like,
2472 struct isl_obj lhs, struct isl_obj rhs)
2473 {
2474 int i;
2475
2476 for (i = 0; ; ++i) {
2477 if (!bin_ops[i].op)
2478 break;
2479 if (bin_ops[i].op != like->op)
2480 continue;
2481 if (!is_subtype(lhs, bin_ops[i].lhs))
2482 continue;
2483 if (!is_subtype(rhs, bin_ops[i].rhs))
2484 continue;
2485
2486 return &bin_ops[i];
2487 }
2488
2489 for (i = 0; ; ++i) {
2490 if (!named_bin_ops[i].name)
2491 break;
2492 if (named_bin_ops[i].op.op != like->op)
2493 continue;
2494 if (!is_subtype(lhs, named_bin_ops[i].op.lhs))
2495 continue;
2496 if (!is_subtype(rhs, named_bin_ops[i].op.rhs))
2497 continue;
2498
2499 return &named_bin_ops[i].op;
2500 }
2501
2502 for (i = 0; ; ++i) {
2503 if (!compound_bin_ops[i].full)
2504 break;
2505 if (compound_bin_ops[i].op.op != like->op)
2506 continue;
2507 if (!is_subtype(lhs, compound_bin_ops[i].op.lhs))
2508 continue;
2509 if (!is_subtype(rhs, compound_bin_ops[i].op.rhs))
2510 continue;
2511
2512 return &compound_bin_ops[i].op;
2513 }
2514
2515 return NULL;
2516 }
2517
2518 static int next_is_neg_int(struct isl_stream *s)
2519 {
2520 struct isl_token *tok;
2521 int ret;
2522
2523 tok = isl_stream_next_token(s);
2524 if (tok && isl_token_get_type(tok) == ISL_TOKEN_VALUE) {
2525 isl_val *v;
2526 v = isl_token_get_val(isl_stream_get_ctx(s), tok);
2527 ret = isl_val_is_neg(v);
2528 isl_val_free(v);
2529 } else
2530 ret = 0;
2531 isl_stream_push_token(s, tok);
2532
2533 return ret;
2534 }
2535
2536 static struct isl_obj call_bin_op(isl_ctx *ctx, struct isc_bin_op *op,
2537 struct isl_obj lhs, struct isl_obj rhs)
2538 {
2539 struct isl_obj obj;
2540
2541 lhs = convert(ctx, lhs, op->lhs);
2542 rhs = convert(ctx, rhs, op->rhs);
2543 if (op->res != isl_obj_bool)
2544 obj.v = op->o.fn(lhs.v, rhs.v);
2545 else {
2546 int res = op->o.test(lhs.v, rhs.v);
2547 free_obj(lhs);
2548 free_obj(rhs);
2549 obj.v = iscc_bool_from_int(res);
2550 }
2551 obj.type = op->res;
2552
2553 return obj;
2554 }
2555
2556 static struct isl_obj read_expr(struct isl_stream *s,
2557 struct isl_hash_table *table)
2558 {
2559 isl_ctx *ctx;
2560 struct isl_obj obj = { isl_obj_none, NULL };
2561 struct isl_obj right_obj = { isl_obj_none, NULL };
2562
2563 obj = read_obj(s, table);
2564 ctx = isl_stream_get_ctx(s);
2565 for (; obj.v;) {
2566 struct isc_bin_op *op = NULL;
2567
2568 op = read_bin_op_if_available(s, obj);
2569 if (!op)
2570 break;
2571
2572 right_obj = read_obj(s, table);
2573
2574 op = find_matching_bin_op(op, obj, right_obj);
2575
2576 if (!op)
2577 isl_die(ctx, isl_error_invalid,
2578 "no such binary operator defined on given operands",
2579 goto error);
2580
2581 obj = call_bin_op(ctx, op, obj, right_obj);
2582 }
2583
2584 if (obj.type == isl_obj_val && next_is_neg_int(s)) {
2585 right_obj = read_obj(s, table);
2586 obj.v = isl_val_add(obj.v, right_obj.v);
2587 }
2588
2589 return obj;
2590 error:
2591 free_obj(right_obj);
2592 free_obj(obj);
2593 obj.type = isl_obj_none;
2594 obj.v = NULL;
2595 return obj;
2596 }
2597
2598 static __isl_give isl_printer *source_file(struct isl_stream *s,
2599 struct isl_hash_table *table, __isl_take isl_printer *p);
2600
2601 /* Print "obj" to the printer "p".
2602 * If the object is a schedule, then print it in block format.
2603 */
2604 static __isl_give isl_printer *print_obj(__isl_take isl_printer *p,
2605 struct isl_obj obj)
2606 {
2607 if (obj.type != isl_obj_schedule)
2608 return obj.type->print(p, obj.v);
2609
2610 p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_BLOCK);
2611 p = obj.type->print(p, obj.v);
2612 p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_FLOW);
2613
2614 return p;
2615 }
2616
2617 static __isl_give isl_printer *read_line(struct isl_stream *s,
2618 struct isl_hash_table *table, __isl_take isl_printer *p, int tty)
2619 {
2620 isl_ctx *ctx;
2621 struct isl_obj obj = { isl_obj_none, NULL };
2622 char *lhs = NULL;
2623 int assign = 0;
2624 int only_print = 0;
2625 char buf[30];
2626
2627 if (!p)
2628 return NULL;
2629 if (isl_stream_is_empty(s))
2630 return p;
2631
2632 if (isl_stream_eat_if_available(s, iscc_op[ISCC_SOURCE]))
2633 return source_file(s, table, p);
2634 if (isl_stream_eat_if_available(s, iscc_op[ISCC_CODEGEN]))
2635 return codegen(s, table, p);
2636
2637 assign = is_assign(s);
2638 if (assign) {
2639 lhs = isl_stream_read_ident_if_available(s);
2640 if (isl_stream_eat(s, ISL_TOKEN_DEF))
2641 goto error;
2642 } else if (isl_stream_eat_if_available(s, iscc_op[ISCC_PRINT]))
2643 only_print = 1;
2644 else if (!tty)
2645 only_print = 1;
2646
2647 obj = read_expr(s, table);
2648 ctx = isl_stream_get_ctx(s);
2649 if (isl_stream_eat(s, ';'))
2650 goto error;
2651
2652 if (only_print) {
2653 if (obj.type != isl_obj_none && obj.v != NULL) {
2654 p = print_obj(p, obj);
2655 p = isl_printer_end_line(p);
2656 }
2657 free_obj(obj);
2658 return p;
2659 }
2660 if (!assign && obj.type != isl_obj_none && obj.v != NULL) {
2661 static int count = 0;
2662 snprintf(buf, sizeof(buf), "$%d", count++);
2663 lhs = strdup(buf + 1);
2664
2665 p = isl_printer_print_str(p, buf);
2666 p = isl_printer_print_str(p, " := ");
2667 p = obj.type->print(p, obj.v);
2668 p = isl_printer_end_line(p);
2669 }
2670 if (lhs && do_assign(ctx, table, lhs, obj))
2671 return p;
2672
2673 return p;
2674 error:
2675 isl_stream_flush_tokens(s);
2676 isl_stream_skip_line(s);
2677 free(lhs);
2678 free_obj(obj);
2679 return p;
2680 }
2681
2682 static isl_stat free_cb(void **entry, void *user)
2683 {
2684 struct isl_named_obj *named = *entry;
2685
2686 free_obj(named->obj);
2687 free(named->name);
2688 free(named);
2689
2690 return isl_stat_ok;
2691 }
2692
2693 static void register_named_ops(struct isl_stream *s)
2694 {
2695 int i;
2696
2697 for (i = 0; i < ISCC_N_OP; ++i) {
2698 iscc_op[i] = isl_stream_register_keyword(s, op_name[i]);
2699 assert(iscc_op[i] != ISL_TOKEN_ERROR);
2700 }
2701
2702 for (i = 0; ; ++i) {
2703 if (!named_un_ops[i].name)
2704 break;
2705 named_un_ops[i].op.op = isl_stream_register_keyword(s,
2706 named_un_ops[i].name);
2707 assert(named_un_ops[i].op.op != ISL_TOKEN_ERROR);
2708 }
2709
2710 for (i = 0; ; ++i) {
2711 if (!named_bin_ops[i].name)
2712 break;
2713 named_bin_ops[i].op.op = isl_stream_register_keyword(s,
2714 named_bin_ops[i].name);
2715 assert(named_bin_ops[i].op.op != ISL_TOKEN_ERROR);
2716 }
2717
2718 for (i = 0; ; ++i) {
2719 if (!compound_bin_ops[i].full)
2720 break;
2721 compound_bin_ops[i].op.op = isl_stream_register_keyword(s,
2722 compound_bin_ops[i].full);
2723 assert(compound_bin_ops[i].op.op != ISL_TOKEN_ERROR);
2724 }
2725 }
2726
2727 static __isl_give isl_printer *source_file(struct isl_stream *s,
2728 struct isl_hash_table *table, __isl_take isl_printer *p)
2729 {
2730 isl_ctx *ctx;
2731 struct isl_token *tok;
2732 struct isl_stream *s_file;
2733 struct iscc_options *options;
2734 char *name;
2735 FILE *file;
2736
2737 tok = isl_stream_next_token(s);
2738 if (!tok || isl_token_get_type(tok) != ISL_TOKEN_STRING) {
2739 isl_stream_error(s, tok, "expecting filename");
2740 isl_token_free(tok);
2741 return p;
2742 }
2743
2744 isl_stream_eat(s, ';');
2745
2746 ctx = isl_stream_get_ctx(s);
2747 options = isl_ctx_peek_iscc_options(ctx);
2748 if (!options || !options->io) {
2749 isl_token_free(tok);
2750 isl_die(ctx, isl_error_invalid,
2751 "source operation not allowed", return p);
2752 }
2753
2754 name = isl_token_get_str(ctx, tok);
2755 isl_token_free(tok);
2756 file = fopen(name, "r");
2757 free(name);
2758 isl_assert(ctx, file, return p);
2759
2760 s_file = isl_stream_new_file(ctx, file);
2761 if (!s_file) {
2762 fclose(file);
2763 return p;
2764 }
2765
2766 register_named_ops(s_file);
2767
2768 while (!isl_stream_is_empty(s_file))
2769 p = read_line(s_file, table, p, 0);
2770
2771 isl_stream_free(s_file);
2772 fclose(file);
2773
2774 return p;
2775 }
2776
2777 int main(int argc, char **argv)
2778 {
2779 struct isl_ctx *ctx;
2780 struct isl_stream *s;
2781 struct isl_hash_table *table;
2782 struct iscc_options *options;
2783 isl_printer *p;
2784 int tty = isatty(0);
2785
2786 options = iscc_options_new_with_defaults();
2787 assert(options);
2788
2789 ctx = isl_ctx_alloc_with_options(&iscc_options_args, options);
2790 pet_options_set_autodetect(ctx, 1);
2791 pet_options_set_encapsulate_dynamic_control(ctx, 1);
2792 argc = isl_ctx_parse_options(ctx, argc, argv, ISL_ARG_ALL);
2793 s = isl_stream_new_file(ctx, stdin);
2794 assert(s);
2795 table = isl_hash_table_alloc(ctx, 10);
2796 assert(table);
2797 p = isl_printer_to_file(ctx, stdout);
2798 p = isl_printer_set_output_format(p, options->format);
2799 assert(p);
2800
2801 register_named_ops(s);
2802
2803 install_signal_handler(ctx);
2804
2805 while (p) {
2806 int empty;
2807
2808 empty = isl_stream_is_empty(s);
2809 if (empty && isl_ctx_last_error(ctx) != isl_error_abort)
2810 break;
2811 if (!empty)
2812 p = read_line(s, table, p, tty);
2813 if (isl_ctx_last_error(ctx) == isl_error_abort) {
2814 fprintf(stderr, "Interrupted\n");
2815 isl_ctx_resume(ctx);
2816 isl_ctx_reset_error(ctx);
2817 }
2818 }
2819
2820 remove_signal_handler(ctx);
2821
2822 isl_printer_free(p);
2823 isl_hash_table_foreach(ctx, table, free_cb, NULL);
2824 isl_hash_table_free(ctx, table);
2825 isl_stream_free(s);
2826 isl_ctx_free(ctx);
2827
2828 return 0;
2829 }
lattice point enumeration library