iscc.c

   1 #include <assert.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <isl/obj.h>
   5 #include <isl/stream.h>
   6 #include <isl/vertices.h>
   7 #include <isl_obj_list.h>
   8 #include <isl_obj_str.h>
   9 #include <barvinok/isl.h>
  10 #include <barvinok/options.h>
  11
  12 #include "config.h"
  13
  14 #ifdef HAVE_CLOOG
  15 #include <cloog/isl/cloog.h>
  16 #endif
  17
  18 static int isl_bool_false = 0;
  19 static int isl_bool_true = 1;
  20 static int isl_bool_error = -1;
  21
  22 enum iscc_op { ISCC_READ, ISCC_SOURCE, ISCC_VERTICES,
  23                ISCC_LAST, ISCC_ANY, ISCC_BEFORE, ISCC_UNDER, ISCC_N_OP };
  24 static const char *op_name[ISCC_N_OP] = {
  25         [ISCC_READ] = "read",
  26         [ISCC_SOURCE] = "source",
  27         [ISCC_VERTICES] = "vertices",
  28         [ISCC_LAST] = "last",
  29         [ISCC_ANY] = "any",
  30         [ISCC_BEFORE] = "before",
  31         [ISCC_UNDER] = "under"
  32 };
  33 static enum isl_token_type iscc_op[ISCC_N_OP];
  34
  35 struct isl_arg_choice iscc_format[] = {
  36         {"isl",         ISL_FORMAT_ISL},
  37         {"omega",       ISL_FORMAT_OMEGA},
  38         {"polylib",     ISL_FORMAT_POLYLIB},
  39         {"ext-polylib", ISL_FORMAT_EXT_POLYLIB},
  40         {"latex",       ISL_FORMAT_LATEX},
  41         {"C",           ISL_FORMAT_C},
  42         {0}
  43 };
  44
  45 struct iscc_options {
  46         struct barvinok_options *barvinok;
  47         unsigned                 format;
  48 };
  49
  50 struct isl_arg iscc_options_arg[] = {
  51 ISL_ARG_CHILD(struct iscc_options, barvinok, "barvinok", barvinok_options_arg,
  52         "barvinok options")
  53 ISL_ARG_CHOICE(struct iscc_options, format, 0, "format", \
  54         iscc_format,    ISL_FORMAT_ISL, "output format")
  55 ISL_ARG_END
  56 };
  57
  58 ISL_ARG_DEF(iscc_options, struct iscc_options, iscc_options_arg)
  59
  60 static void *isl_obj_bool_copy(void *v)
  61 {
  62         return v;
  63 }
  64
  65 static void isl_obj_bool_free(void *v)
  66 {
  67 }
  68
  69 static __isl_give isl_printer *isl_obj_bool_print(__isl_take isl_printer *p,
  70         void *v)
  71 {
  72         if (v == &isl_bool_true)
  73                 return isl_printer_print_str(p, "True");
  74         else if (v == &isl_bool_false)
  75                 return isl_printer_print_str(p, "False");
  76         else
  77                 return isl_printer_print_str(p, "Error");
  78 }
  79
  80 static void *isl_obj_bool_add(void *v1, void *v2)
  81 {
  82         return v1;
  83 }
  84
  85 struct isl_obj_vtable isl_obj_bool_vtable = {
  86         isl_obj_bool_copy,
  87         isl_obj_bool_add,
  88         isl_obj_bool_print,
  89         isl_obj_bool_free
  90 };
  91 #define isl_obj_bool            (&isl_obj_bool_vtable)
  92
  93 int *isl_bool_from_int(int res)
  94 {
  95         return res < 0 ? &isl_bool_error : res ? &isl_bool_true : &isl_bool_false;
  96 }
  97
  98 int *union_map_is_equal(__isl_take isl_union_map *map1,
  99         __isl_take isl_union_map *map2)
 100 {
 101         int res = isl_union_map_is_equal(map1, map2);
 102         isl_union_map_free(map1);
 103         isl_union_map_free(map2);
 104         return isl_bool_from_int(res);
 105 }
 106 int *union_set_is_equal(__isl_take isl_union_set *set1,
 107         __isl_take isl_union_set *set2)
 108 {
 109         return union_map_is_equal((isl_union_map *)set1, (isl_union_map *)set2);
 110 }
 111
 112 int *union_map_is_subset(__isl_take isl_union_map *map1,
 113         __isl_take isl_union_map *map2)
 114 {
 115         int res = isl_union_map_is_subset(map1, map2);
 116         isl_union_map_free(map1);
 117         isl_union_map_free(map2);
 118         return isl_bool_from_int(res);
 119 }
 120 int *union_set_is_subset(__isl_take isl_union_set *set1,
 121         __isl_take isl_union_set *set2)
 122 {
 123         return union_map_is_subset((isl_union_map *)set1, (isl_union_map *)set2);
 124 }
 125
 126 int *union_map_is_strict_subset(__isl_take isl_union_map *map1,
 127         __isl_take isl_union_map *map2)
 128 {
 129         int res = isl_union_map_is_strict_subset(map1, map2);
 130         isl_union_map_free(map1);
 131         isl_union_map_free(map2);
 132         return isl_bool_from_int(res);
 133 }
 134 int *union_set_is_strict_subset(__isl_take isl_union_set *set1,
 135         __isl_take isl_union_set *set2)
 136 {
 137         return union_map_is_strict_subset((isl_union_map *)set1,
 138                                           (isl_union_map *)set2);
 139 }
 140
 141 int *union_map_is_superset(__isl_take isl_union_map *map1,
 142         __isl_take isl_union_map *map2)
 143 {
 144         return union_map_is_subset(map2, map1);
 145 }
 146 int *union_set_is_superset(__isl_take isl_union_set *set1,
 147         __isl_take isl_union_set *set2)
 148 {
 149         return union_set_is_subset(set2, set1);
 150 }
 151
 152 int *union_map_is_strict_superset(__isl_take isl_union_map *map1,
 153         __isl_take isl_union_map *map2)
 154 {
 155         return union_map_is_strict_subset(map2, map1);
 156 }
 157 int *union_set_is_strict_superset(__isl_take isl_union_set *set1,
 158         __isl_take isl_union_set *set2)
 159 {
 160         return union_set_is_strict_subset(set2, set1);
 161 }
 162
 163 extern struct isl_obj_vtable isl_obj_list_vtable;
 164 #define isl_obj_list            (&isl_obj_list_vtable)
 165
 166 typedef void *(*isc_bin_op_fn)(void *lhs, void *rhs);
 167 struct isc_bin_op {
 168         enum isl_token_type     op;
 169         isl_obj_type            lhs;
 170         isl_obj_type            rhs;
 171         isl_obj_type            res;
 172         isc_bin_op_fn           fn;
 173 };
 174 struct isc_named_bin_op {
 175         char                    *name;
 176         struct isc_bin_op       op;
 177 };
 178
 179 struct iscc_at {
 180         isl_union_pw_qpolynomial *upwqp;
 181         isl_union_pw_qpolynomial *res;
 182 };
 183
 184 static int eval_at(__isl_take isl_point *pnt, void *user)
 185 {
 186         struct iscc_at *at = (struct iscc_at *) user;
 187         isl_qpolynomial *qp;
 188         isl_set *set;
 189
 190         set = isl_set_from_point(isl_point_copy(pnt));
 191         qp = isl_union_pw_qpolynomial_eval(
 192                                 isl_union_pw_qpolynomial_copy(at->upwqp), pnt);
 193
 194         at->res = isl_union_pw_qpolynomial_add(at->res,
 195                         isl_union_pw_qpolynomial_from_pw_qpolynomial(
 196                                 isl_pw_qpolynomial_alloc(set, qp)));
 197
 198         return 0;
 199 }
 200
 201 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_at(
 202         __isl_take isl_union_pw_qpolynomial *upwqp,
 203         __isl_take isl_union_set *uset)
 204 {
 205         struct iscc_at at;
 206
 207         at.upwqp = upwqp;
 208         at.res = isl_union_pw_qpolynomial_zero(isl_union_set_get_dim(uset));
 209
 210         isl_union_set_foreach_point(uset, eval_at, &at);
 211
 212         isl_union_pw_qpolynomial_free(upwqp);
 213         isl_union_set_free(uset);
 214
 215         return at.res;
 216 }
 217
 218 struct iscc_fold_at {
 219         isl_union_pw_qpolynomial_fold *upwf;
 220         isl_union_pw_qpolynomial *res;
 221 };
 222
 223 static int eval_fold_at(__isl_take isl_point *pnt, void *user)
 224 {
 225         struct iscc_fold_at *at = (struct iscc_fold_at *) user;
 226         isl_qpolynomial *qp;
 227         isl_set *set;
 228
 229         set = isl_set_from_point(isl_point_copy(pnt));
 230         qp = isl_union_pw_qpolynomial_fold_eval(
 231                             isl_union_pw_qpolynomial_fold_copy(at->upwf), pnt);
 232
 233         at->res = isl_union_pw_qpolynomial_add(at->res,
 234                         isl_union_pw_qpolynomial_from_pw_qpolynomial(
 235                                 isl_pw_qpolynomial_alloc(set, qp)));
 236
 237         return 0;
 238 }
 239
 240 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_fold_at(
 241         __isl_take isl_union_pw_qpolynomial_fold *upwf,
 242         __isl_take isl_union_set *uset)
 243 {
 244         struct iscc_fold_at at;
 245
 246         at.upwf = upwf;
 247         at.res = isl_union_pw_qpolynomial_zero(isl_union_set_get_dim(uset));
 248
 249         isl_union_set_foreach_point(uset, eval_fold_at, &at);
 250
 251         isl_union_pw_qpolynomial_fold_free(upwf);
 252         isl_union_set_free(uset);
 253
 254         return at.res;
 255 }
 256
 257 static __isl_give isl_union_pw_qpolynomial_fold *union_pw_qpolynomial_add_union_pw_qpolynomial_fold(
 258         __isl_take isl_union_pw_qpolynomial *upwqp,
 259         __isl_take isl_union_pw_qpolynomial_fold *upwf)
 260 {
 261         return isl_union_pw_qpolynomial_fold_add_union_pw_qpolynomial(upwf,
 262                                                                         upwqp);
 263 }
 264
 265 static __isl_give struct isl_list *union_map_apply_union_pw_qpolynomial_fold(
 266         __isl_take isl_union_map *umap,
 267         __isl_take isl_union_pw_qpolynomial_fold *upwf)
 268 {
 269         isl_ctx *ctx;
 270         struct isl_list *list;
 271         int tight;
 272
 273         ctx = isl_union_map_get_ctx(umap);
 274         list = isl_list_alloc(ctx, 2);
 275         if (!list)
 276                 goto error2;
 277
 278         list->obj[0].type = isl_obj_union_pw_qpolynomial_fold;
 279         list->obj[0].v = isl_union_map_apply_union_pw_qpolynomial_fold(umap,
 280                                                         upwf, &tight);
 281         list->obj[1].type = isl_obj_bool;
 282         list->obj[1].v = tight ? &isl_bool_true : &isl_bool_false;
 283         if (tight < 0 || !list->obj[0].v)
 284                 goto error;
 285
 286         return list;
 287 error2:
 288         isl_union_map_free(umap);
 289         isl_union_pw_qpolynomial_fold_free(upwf);
 290 error:
 291         isl_list_free(list);
 292         return NULL;
 293 }
 294
 295 struct isc_bin_op bin_ops[] = {
 296         { '+',  isl_obj_union_set,      isl_obj_union_set,
 297                 isl_obj_union_set,
 298                 (isc_bin_op_fn) &isl_union_set_union },
 299         { '+',  isl_obj_union_map,      isl_obj_union_map,
 300                 isl_obj_union_map,
 301                 (isc_bin_op_fn) &isl_union_map_union },
 302         { '-',  isl_obj_union_set,      isl_obj_union_set,
 303                 isl_obj_union_set,
 304                 (isc_bin_op_fn) &isl_union_set_subtract },
 305         { '-',  isl_obj_union_map,      isl_obj_union_map,
 306                 isl_obj_union_map,
 307                 (isc_bin_op_fn) &isl_union_map_subtract },
 308         { '*',  isl_obj_union_set,      isl_obj_union_set,
 309                 isl_obj_union_set,
 310                 (isc_bin_op_fn) &isl_union_set_intersect },
 311         { '*',  isl_obj_union_map,      isl_obj_union_map,
 312                 isl_obj_union_map,
 313                 (isc_bin_op_fn) &isl_union_map_intersect },
 314         { '*',  isl_obj_union_map,      isl_obj_union_set,
 315                 isl_obj_union_map,
 316                 (isc_bin_op_fn) &isl_union_map_intersect_domain },
 317         { '.',  isl_obj_union_map,      isl_obj_union_map,
 318                 isl_obj_union_map,
 319                 (isc_bin_op_fn) &isl_union_map_apply_range },
 320         { '.',  isl_obj_union_map,      isl_obj_union_pw_qpolynomial,
 321                 isl_obj_union_pw_qpolynomial,
 322                 (isc_bin_op_fn) &isl_union_map_apply_union_pw_qpolynomial },
 323         { '.',  isl_obj_union_map,      isl_obj_union_pw_qpolynomial_fold,
 324                 isl_obj_list,
 325                 (isc_bin_op_fn) &union_map_apply_union_pw_qpolynomial_fold },
 326         { ISL_TOKEN_TO, isl_obj_union_set,      isl_obj_union_set,
 327                 isl_obj_union_map,
 328                 (isc_bin_op_fn) &isl_union_map_from_domain_and_range },
 329         { '=', isl_obj_union_set,       isl_obj_union_set,      isl_obj_bool,
 330                 (isc_bin_op_fn) &union_set_is_equal },
 331         { '=', isl_obj_union_map,       isl_obj_union_map,      isl_obj_bool,
 332                 (isc_bin_op_fn) &union_map_is_equal },
 333         { ISL_TOKEN_LE, isl_obj_union_set,      isl_obj_union_set,
 334                 isl_obj_bool, (isc_bin_op_fn) &union_set_is_subset },
 335         { ISL_TOKEN_LE, isl_obj_union_map,      isl_obj_union_map,
 336                 isl_obj_bool, (isc_bin_op_fn) &union_map_is_subset },
 337         { ISL_TOKEN_LT, isl_obj_union_set,      isl_obj_union_set,
 338                 isl_obj_bool, (isc_bin_op_fn) &union_set_is_strict_subset },
 339         { ISL_TOKEN_LT, isl_obj_union_map,      isl_obj_union_map,
 340                 isl_obj_bool, (isc_bin_op_fn) &union_map_is_strict_subset },
 341         { ISL_TOKEN_GE, isl_obj_union_set,      isl_obj_union_set,
 342                 isl_obj_bool, (isc_bin_op_fn) &union_set_is_superset },
 343         { ISL_TOKEN_GE, isl_obj_union_map,      isl_obj_union_map,
 344                 isl_obj_bool, (isc_bin_op_fn) &union_map_is_superset },
 345         { ISL_TOKEN_GT, isl_obj_union_set,      isl_obj_union_set,
 346                 isl_obj_bool, (isc_bin_op_fn) &union_set_is_strict_superset },
 347         { ISL_TOKEN_GT, isl_obj_union_map,      isl_obj_union_map,
 348                 isl_obj_bool, (isc_bin_op_fn) &union_map_is_strict_superset },
 349         { ISL_TOKEN_LEX_LE,     isl_obj_union_set,      isl_obj_union_set,
 350                 isl_obj_union_map,
 351                 (isc_bin_op_fn) &isl_union_set_lex_le_union_set },
 352         { ISL_TOKEN_LEX_LT,     isl_obj_union_set,      isl_obj_union_set,
 353                 isl_obj_union_map,
 354                 (isc_bin_op_fn) &isl_union_set_lex_lt_union_set },
 355         { ISL_TOKEN_LEX_GE,     isl_obj_union_set,      isl_obj_union_set,
 356                 isl_obj_union_map,
 357                 (isc_bin_op_fn) &isl_union_set_lex_ge_union_set },
 358         { ISL_TOKEN_LEX_GT,     isl_obj_union_set,      isl_obj_union_set,
 359                 isl_obj_union_map,
 360                 (isc_bin_op_fn) &isl_union_set_lex_gt_union_set },
 361         { ISL_TOKEN_LEX_LE,     isl_obj_union_map,      isl_obj_union_map,
 362                 isl_obj_union_map,
 363                 (isc_bin_op_fn) &isl_union_map_lex_le_union_map },
 364         { ISL_TOKEN_LEX_LT,     isl_obj_union_map,      isl_obj_union_map,
 365                 isl_obj_union_map,
 366                 (isc_bin_op_fn) &isl_union_map_lex_lt_union_map },
 367         { ISL_TOKEN_LEX_GE,     isl_obj_union_map,      isl_obj_union_map,
 368                 isl_obj_union_map,
 369                 (isc_bin_op_fn) &isl_union_map_lex_ge_union_map },
 370         { ISL_TOKEN_LEX_GT,     isl_obj_union_map,      isl_obj_union_map,
 371                 isl_obj_union_map,
 372                 (isc_bin_op_fn) &isl_union_map_lex_gt_union_map },
 373         { '.',  isl_obj_union_pw_qpolynomial_fold,
 374                 isl_obj_union_pw_qpolynomial_fold,
 375                 isl_obj_union_pw_qpolynomial_fold,
 376                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_fold },
 377         { '+',  isl_obj_union_pw_qpolynomial,   isl_obj_union_pw_qpolynomial,
 378                 isl_obj_union_pw_qpolynomial,
 379                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_add },
 380         { '+',  isl_obj_union_pw_qpolynomial,
 381                 isl_obj_union_pw_qpolynomial_fold,
 382                 isl_obj_union_pw_qpolynomial_fold,
 383                 (isc_bin_op_fn) &union_pw_qpolynomial_add_union_pw_qpolynomial_fold },
 384         { '+',  isl_obj_union_pw_qpolynomial_fold,
 385                 isl_obj_union_pw_qpolynomial,
 386                 isl_obj_union_pw_qpolynomial_fold,
 387                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_add_union_pw_qpolynomial },
 388         { '-',  isl_obj_union_pw_qpolynomial,   isl_obj_union_pw_qpolynomial,
 389                 isl_obj_union_pw_qpolynomial,
 390                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_sub },
 391         { '*',  isl_obj_union_pw_qpolynomial,   isl_obj_union_pw_qpolynomial,
 392                 isl_obj_union_pw_qpolynomial,
 393                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_mul },
 394         { '*',  isl_obj_union_pw_qpolynomial,   isl_obj_union_set,
 395                 isl_obj_union_pw_qpolynomial,
 396                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_intersect_domain },
 397         { '*',  isl_obj_union_pw_qpolynomial_fold,      isl_obj_union_set,
 398                 isl_obj_union_pw_qpolynomial_fold,
 399                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_intersect_domain },
 400         { '@',  isl_obj_union_pw_qpolynomial, isl_obj_union_set,
 401                 isl_obj_union_pw_qpolynomial,
 402                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_at },
 403         { '@',  isl_obj_union_pw_qpolynomial_fold, isl_obj_union_set,
 404                 isl_obj_union_pw_qpolynomial,
 405                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_at },
 406         { '%',  isl_obj_union_set,      isl_obj_union_set,
 407                 isl_obj_union_set,
 408                 (isc_bin_op_fn) &isl_union_set_gist },
 409         { '%',  isl_obj_union_map,      isl_obj_union_map,
 410                 isl_obj_union_map,
 411                 (isc_bin_op_fn) &isl_union_map_gist },
 412         { '%',  isl_obj_union_pw_qpolynomial,   isl_obj_union_set,
 413                 isl_obj_union_pw_qpolynomial,
 414                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_gist },
 415         { '%',  isl_obj_union_pw_qpolynomial_fold,      isl_obj_union_set,
 416                 isl_obj_union_pw_qpolynomial_fold,
 417                 (isc_bin_op_fn) &isl_union_pw_qpolynomial_fold_gist },
 418         { '+',  isl_obj_str,    isl_obj_str,    isl_obj_str,
 419                 (isc_bin_op_fn) &isl_str_concat },
 420         0
 421 };
 422
 423 static __isl_give isl_union_map *map_after_map(__isl_take isl_union_map *umap1,
 424         __isl_take isl_union_map *umap2)
 425 {
 426         return isl_union_map_apply_range(umap2, umap1);
 427 }
 428
 429 static __isl_give isl_union_pw_qpolynomial *qpolynomial_after_map(
 430         __isl_take isl_union_pw_qpolynomial *upwqp,
 431         __isl_take isl_union_map *umap)
 432 {
 433         return isl_union_map_apply_union_pw_qpolynomial(umap, upwqp);
 434 }
 435
 436 static __isl_give struct isl_list *qpolynomial_fold_after_map(
 437         __isl_take isl_union_pw_qpolynomial_fold *upwf,
 438         __isl_take isl_union_map *umap)
 439 {
 440         return union_map_apply_union_pw_qpolynomial_fold(umap, upwf);
 441 }
 442
 443 struct isc_named_bin_op named_bin_ops[] = {
 444         { "after",      { -1, isl_obj_union_map,        isl_obj_union_map,
 445                 isl_obj_union_map,
 446                 (isc_bin_op_fn) &map_after_map } },
 447         { "after",      { -1, isl_obj_union_pw_qpolynomial,
 448                 isl_obj_union_map, isl_obj_union_pw_qpolynomial,
 449                 (isc_bin_op_fn) &qpolynomial_after_map } },
 450         { "after",      { -1, isl_obj_union_pw_qpolynomial_fold,
 451                 isl_obj_union_map, isl_obj_list,
 452                 (isc_bin_op_fn) &qpolynomial_fold_after_map } },
 453         { "before",     { -1, isl_obj_union_map,        isl_obj_union_map,
 454                 isl_obj_union_map,
 455                 (isc_bin_op_fn) &isl_union_map_apply_range } },
 456         { "before",     { -1, isl_obj_union_map,
 457                 isl_obj_union_pw_qpolynomial, isl_obj_union_pw_qpolynomial,
 458                 (isc_bin_op_fn) &isl_union_map_apply_union_pw_qpolynomial } },
 459         { "before",     { -1, isl_obj_union_map,
 460                 isl_obj_union_pw_qpolynomial_fold, isl_obj_list,
 461                 (isc_bin_op_fn) &union_map_apply_union_pw_qpolynomial_fold } },
 462         { "cross",      { -1,   isl_obj_union_set,      isl_obj_union_set,
 463                 isl_obj_union_set,
 464                 (isc_bin_op_fn) &isl_union_set_product } },
 465         { "cross",      { -1,   isl_obj_union_map,      isl_obj_union_map,
 466                 isl_obj_union_map,
 467                 (isc_bin_op_fn) &isl_union_map_product } },
 468         NULL
 469 };
 470
 471 __isl_give isl_set *union_set_sample(__isl_take isl_union_set *uset)
 472 {
 473         return isl_set_from_basic_set(isl_union_set_sample(uset));
 474 }
 475
 476 __isl_give isl_map *union_map_sample(__isl_take isl_union_map *umap)
 477 {
 478         return isl_map_from_basic_map(isl_union_map_sample(umap));
 479 }
 480
 481 static __isl_give struct isl_list *union_pw_qpolynomial_upper_bound(
 482         __isl_take isl_union_pw_qpolynomial *upwqp)
 483 {
 484         isl_ctx *ctx;
 485         struct isl_list *list;
 486         int tight;
 487
 488         ctx = isl_union_pw_qpolynomial_get_ctx(upwqp);
 489         list = isl_list_alloc(ctx, 2);
 490         if (!list)
 491                 goto error2;
 492
 493         list->obj[0].type = isl_obj_union_pw_qpolynomial_fold;
 494         list->obj[0].v = isl_union_pw_qpolynomial_bound(upwqp,
 495                                                         isl_fold_max, &tight);
 496         list->obj[1].type = isl_obj_bool;
 497         list->obj[1].v = tight ? &isl_bool_true : &isl_bool_false;
 498         if (tight < 0 || !list->obj[0].v)
 499                 goto error;
 500
 501         return list;
 502 error2:
 503         isl_union_pw_qpolynomial_free(upwqp);
 504 error:
 505         isl_list_free(list);
 506         return NULL;
 507 }
 508
 509 #ifdef HAVE_CLOOG
 510 void *map_codegen(void *arg)
 511 {
 512         isl_dim *dim;
 513         isl_union_map *umap = (isl_union_map *)arg;
 514         isl_ctx *ctx = isl_union_map_get_ctx(umap);
 515         CloogState *state;
 516         CloogOptions *options;
 517         CloogDomain *context;
 518         CloogUnionDomain *ud;
 519         CloogInput *input;
 520         struct clast_stmt *stmt;
 521
 522         state = cloog_isl_state_malloc(ctx);
 523         options = cloog_options_malloc(state);
 524         options->language = LANGUAGE_C;
 525         options->strides = 1;
 526
 527         ud = cloog_union_domain_from_isl_union_map(isl_union_map_copy(umap));
 528
 529         dim = isl_union_map_get_dim(umap);
 530         context = cloog_domain_from_isl_set(isl_set_universe(dim));
 531
 532         input = cloog_input_alloc(context, ud);
 533
 534         stmt = cloog_clast_create_from_input(input, options);
 535         clast_pprint(stdout, stmt, 0, options);
 536         cloog_clast_free(stmt);
 537
 538 error:
 539         cloog_options_free(options);
 540         cloog_state_free(state);
 541         isl_union_map_free(umap);
 542         return NULL;
 543 }
 544
 545 void *set_codegen(void *arg)
 546 {
 547         isl_dim *dim;
 548         isl_union_set *uset = (isl_union_set *)arg;
 549         isl_ctx *ctx = isl_union_set_get_ctx(uset);
 550         CloogState *state;
 551         CloogOptions *options;
 552         CloogDomain *context;
 553         CloogUnionDomain *ud;
 554         CloogInput *input;
 555         struct clast_stmt *stmt;
 556
 557         if (isl_union_set_n_set(uset) > 1)
 558                 isl_die(ctx, isl_error_invalid,
 559                         "code generation for more than one domain "
 560                         "requires a schedule", goto error);
 561
 562         state = cloog_isl_state_malloc(ctx);
 563         options = cloog_options_malloc(state);
 564         options->language = LANGUAGE_C;
 565         options->strides = 1;
 566
 567         ud = cloog_union_domain_from_isl_union_set(isl_union_set_copy(uset));
 568
 569         dim = isl_union_set_get_dim(uset);
 570         context = cloog_domain_from_isl_set(isl_set_universe(dim));
 571
 572         input = cloog_input_alloc(context, ud);
 573
 574         stmt = cloog_clast_create_from_input(input, options);
 575         clast_pprint(stdout, stmt, 0, options);
 576         cloog_clast_free(stmt);
 577
 578         cloog_options_free(options);
 579         cloog_state_free(state);
 580 error:
 581         isl_union_set_free(uset);
 582         return NULL;
 583 }
 584 #endif
 585
 586 static int add_point(__isl_take isl_point *pnt, void *user)
 587 {
 588         isl_union_set **scan = (isl_union_set **) user;
 589
 590         *scan = isl_union_set_add_set(*scan, isl_set_from_point(pnt));
 591
 592         return 0;
 593 }
 594
 595 static __isl_give isl_union_set *union_set_scan(__isl_take isl_union_set *uset)
 596 {
 597         isl_union_set *scan;
 598
 599         scan = isl_union_set_empty(isl_union_set_get_dim(uset));
 600
 601         if (isl_union_set_foreach_point(uset, add_point, &scan) < 0) {
 602                 isl_union_set_free(scan);
 603                 return uset;
 604         }
 605
 606         isl_union_set_free(uset);
 607         return scan;
 608 }
 609
 610 static __isl_give isl_union_map *union_map_scan(__isl_take isl_union_map *umap)
 611 {
 612         return isl_union_set_unwrap(union_set_scan(isl_union_map_wrap(umap)));
 613 }
 614
 615 static __isl_give isl_union_pw_qpolynomial *union_pw_qpolynomial_poly(
 616         __isl_take isl_union_pw_qpolynomial *upwqp)
 617 {
 618         return isl_union_pw_qpolynomial_to_polynomial(upwqp, 0);
 619 }
 620
 621 static __isl_give isl_union_pw_qpolynomial *union_pw_qpolynomial_lpoly(
 622         __isl_take isl_union_pw_qpolynomial *upwqp)
 623 {
 624         return isl_union_pw_qpolynomial_to_polynomial(upwqp, -1);
 625 }
 626
 627 static __isl_give isl_union_pw_qpolynomial *union_pw_qpolynomial_upoly(
 628         __isl_take isl_union_pw_qpolynomial *upwqp)
 629 {
 630         return isl_union_pw_qpolynomial_to_polynomial(upwqp, 1);
 631 }
 632
 633 typedef void *(*isc_un_op_fn)(void *arg);
 634 struct isc_un_op {
 635         enum isl_token_type     op;
 636         isl_obj_type            arg;
 637         isl_obj_type            res;
 638         isc_un_op_fn            fn;
 639 };
 640 struct isc_named_un_op {
 641         char                    *name;
 642         struct isc_un_op        op;
 643 };
 644 struct isc_named_un_op named_un_ops[] = {
 645         {"aff", { -1,   isl_obj_union_map,      isl_obj_union_map,
 646                 (isc_un_op_fn) &isl_union_map_affine_hull } },
 647         {"aff", { -1,   isl_obj_union_set,      isl_obj_union_set,
 648                 (isc_un_op_fn) &isl_union_set_affine_hull } },
 649         {"card",        { -1,   isl_obj_union_set,
 650                 isl_obj_union_pw_qpolynomial,
 651                 (isc_un_op_fn) &isl_union_set_card } },
 652         {"card",        { -1,   isl_obj_union_map,
 653                 isl_obj_union_pw_qpolynomial,
 654                 (isc_un_op_fn) &isl_union_map_card } },
 655         {"coalesce",    { -1,   isl_obj_union_set,      isl_obj_union_set,
 656                 (isc_un_op_fn) &isl_union_set_coalesce } },
 657         {"coalesce",    { -1,   isl_obj_union_map,      isl_obj_union_map,
 658                 (isc_un_op_fn) &isl_union_map_coalesce } },
 659         {"coalesce",    { -1,   isl_obj_union_pw_qpolynomial,
 660                 isl_obj_union_pw_qpolynomial,
 661                 (isc_un_op_fn) &isl_union_pw_qpolynomial_coalesce } },
 662         {"coalesce",    { -1,   isl_obj_union_pw_qpolynomial_fold,
 663                 isl_obj_union_pw_qpolynomial_fold,
 664                 (isc_un_op_fn) &isl_union_pw_qpolynomial_fold_coalesce } },
 665 #ifdef HAVE_CLOOG
 666         {"codegen",     { -1,   isl_obj_union_set, isl_obj_none,
 667                 &set_codegen } },
 668         {"codegen",     { -1,   isl_obj_union_map, isl_obj_none,
 669                 &map_codegen } },
 670 #endif
 671         {"deltas",      { -1,   isl_obj_union_map,      isl_obj_union_set,
 672                 (isc_un_op_fn) &isl_union_map_deltas } },
 673         {"dom", { -1,   isl_obj_union_map,      isl_obj_union_set,
 674                 (isc_un_op_fn) &isl_union_map_domain } },
 675         {"dom", { -1,   isl_obj_union_pw_qpolynomial,   isl_obj_union_set,
 676                 (isc_un_op_fn) &isl_union_pw_qpolynomial_domain } },
 677         {"dom", { -1,   isl_obj_union_pw_qpolynomial_fold,
 678                 isl_obj_union_set,
 679                 (isc_un_op_fn) &isl_union_pw_qpolynomial_fold_domain } },
 680         {"domain",      { -1,   isl_obj_union_map,      isl_obj_union_set,
 681                 (isc_un_op_fn) &isl_union_map_domain } },
 682         {"domain",      { -1,   isl_obj_union_pw_qpolynomial,
 683                 isl_obj_union_set,
 684                 (isc_un_op_fn) &isl_union_pw_qpolynomial_domain } },
 685         {"domain",      { -1,   isl_obj_union_pw_qpolynomial_fold,
 686                 isl_obj_union_set,
 687                 (isc_un_op_fn) &isl_union_pw_qpolynomial_fold_domain } },
 688         {"domain_map",  { -1,   isl_obj_union_map,      isl_obj_union_map,
 689                 (isc_un_op_fn) &isl_union_map_domain_map } },
 690         {"ran", { -1,   isl_obj_union_map,      isl_obj_union_set,
 691                 (isc_un_op_fn) &isl_union_map_range } },
 692         {"range",       { -1,   isl_obj_union_map,      isl_obj_union_set,
 693                 (isc_un_op_fn) &isl_union_map_range } },
 694         {"range_map",   { -1,   isl_obj_union_map,      isl_obj_union_map,
 695                 (isc_un_op_fn) &isl_union_map_range_map } },
 696         {"identity",    { -1,   isl_obj_union_set,      isl_obj_union_map,
 697                 (isc_un_op_fn) &isl_union_set_identity } },
 698         {"lexmin",      { -1,   isl_obj_union_map,      isl_obj_union_map,
 699                 (isc_un_op_fn) &isl_union_map_lexmin } },
 700         {"lexmax",      { -1,   isl_obj_union_map,      isl_obj_union_map,
 701                 (isc_un_op_fn) &isl_union_map_lexmax } },
 702         {"lexmin",      { -1,   isl_obj_union_set,      isl_obj_union_set,
 703                 (isc_un_op_fn) &isl_union_set_lexmin } },
 704         {"lexmax",      { -1,   isl_obj_union_set,      isl_obj_union_set,
 705                 (isc_un_op_fn) &isl_union_set_lexmax } },
 706         {"poly",        { -1,   isl_obj_union_map,      isl_obj_union_map,
 707                 (isc_un_op_fn) &isl_union_map_polyhedral_hull } },
 708         {"poly",        { -1,   isl_obj_union_set,      isl_obj_union_set,
 709                 (isc_un_op_fn) &isl_union_set_polyhedral_hull } },
 710         {"poly",        { -1,   isl_obj_union_pw_qpolynomial,
 711                 isl_obj_union_pw_qpolynomial,
 712                 (isc_un_op_fn) &union_pw_qpolynomial_poly } },
 713         {"lpoly",       { -1,   isl_obj_union_pw_qpolynomial,
 714                 isl_obj_union_pw_qpolynomial,
 715                 (isc_un_op_fn) &union_pw_qpolynomial_lpoly } },
 716         {"upoly",       { -1,   isl_obj_union_pw_qpolynomial,
 717                 isl_obj_union_pw_qpolynomial,
 718                 (isc_un_op_fn) &union_pw_qpolynomial_upoly } },
 719         {"sample",      { -1,   isl_obj_union_set,      isl_obj_set,
 720                 (isc_un_op_fn) &union_set_sample } },
 721         {"sample",      { -1,   isl_obj_union_map,      isl_obj_map,
 722                 (isc_un_op_fn) &union_map_sample } },
 723         {"scan",        { -1,   isl_obj_union_set,      isl_obj_union_set,
 724                 (isc_un_op_fn) &union_set_scan } },
 725         {"scan",        { -1,   isl_obj_union_map,      isl_obj_union_map,
 726                 (isc_un_op_fn) &union_map_scan } },
 727         {"sum",         { -1,   isl_obj_union_pw_qpolynomial,
 728                 isl_obj_union_pw_qpolynomial,
 729                 (isc_un_op_fn) &isl_union_pw_qpolynomial_sum } },
 730         {"ub",          { -1,   isl_obj_union_pw_qpolynomial, isl_obj_list,
 731                 (isc_un_op_fn) &union_pw_qpolynomial_upper_bound } },
 732         {"unwrap",      { -1,   isl_obj_union_set,      isl_obj_union_map,
 733                 (isc_un_op_fn) &isl_union_set_unwrap } },
 734         {"wrap",        { -1,   isl_obj_union_map,      isl_obj_union_set,
 735                 (isc_un_op_fn) &isl_union_map_wrap } },
 736         NULL
 737 };
 738
 739 struct isl_named_obj {
 740         char            *name;
 741         struct isl_obj  obj;
 742 };
 743
 744 static void free_obj(struct isl_obj obj)
 745 {
 746         obj.type->free(obj.v);
 747 }
 748
 749 static int same_name(const void *entry, const void *val)
 750 {
 751         const struct isl_named_obj *named = (const struct isl_named_obj *)entry;
 752
 753         return !strcmp(named->name, val);
 754 }
 755
 756 static int do_assign(struct isl_ctx *ctx, struct isl_hash_table *table,
 757         char *name, struct isl_obj obj)
 758 {
 759         struct isl_hash_table_entry *entry;
 760         uint32_t name_hash;
 761         struct isl_named_obj *named;
 762
 763         name_hash = isl_hash_string(isl_hash_init(), name);
 764         entry = isl_hash_table_find(ctx, table, name_hash, same_name, name, 1);
 765         if (!entry)
 766                 goto error;
 767         if (entry->data) {
 768                 named = entry->data;
 769                 free_obj(named->obj);
 770                 free(name);
 771         } else {
 772                 named = isl_alloc_type(ctx, struct isl_named_obj);
 773                 if (!named)
 774                         goto error;
 775                 named->name = name;
 776                 entry->data = named;
 777         }
 778         named->obj = obj;
 779
 780         return 0;
 781 error:
 782         free_obj(obj);
 783         free(name);
 784         return -1;
 785 }
 786
 787 static struct isl_obj stored_obj(struct isl_ctx *ctx,
 788         struct isl_hash_table *table, char *name)
 789 {
 790         struct isl_obj obj = { isl_obj_none, NULL };
 791         struct isl_hash_table_entry *entry;
 792         uint32_t name_hash;
 793
 794         name_hash = isl_hash_string(isl_hash_init(), name);
 795         entry = isl_hash_table_find(ctx, table, name_hash, same_name, name, 0);
 796         if (entry) {
 797                 struct isl_named_obj *named;
 798                 named = entry->data;
 799                 obj = named->obj;
 800         } else
 801                 fprintf(stderr, "unknown identifier '%s'\n", name);
 802
 803         free(name);
 804         obj.v = obj.type->copy(obj.v);
 805         return obj;
 806 }
 807
 808 static int is_subtype(struct isl_obj obj, isl_obj_type super)
 809 {
 810         if (obj.type == super)
 811                 return 1;
 812         if (obj.type == isl_obj_map && super == isl_obj_union_map)
 813                 return 1;
 814         if (obj.type == isl_obj_set && super == isl_obj_union_set)
 815                 return 1;
 816         if (obj.type == isl_obj_pw_qpolynomial &&
 817             super == isl_obj_union_pw_qpolynomial)
 818                 return 1;
 819         if (obj.type == isl_obj_pw_qpolynomial_fold &&
 820             super == isl_obj_union_pw_qpolynomial_fold)
 821                 return 1;
 822         if (obj.type == isl_obj_union_set && isl_union_set_is_empty(obj.v))
 823                 return 1;
 824         if (obj.type == isl_obj_list) {
 825                 struct isl_list *list = obj.v;
 826                 if (list->n == 2 && list->obj[1].type == isl_obj_bool)
 827                         return is_subtype(list->obj[0], super);
 828         }
 829         if (super == isl_obj_str)
 830                 return 1;
 831         return 0;
 832 }
 833
 834 static struct isl_obj obj_at(struct isl_obj obj, int i)
 835 {
 836         struct isl_list *list = obj.v;
 837
 838         obj = list->obj[i];
 839         obj.v = obj.type->copy(obj.v);
 840
 841         isl_list_free(list);
 842
 843         return obj;
 844 }
 845
 846 static struct isl_obj convert(isl_ctx *ctx, struct isl_obj obj,
 847         isl_obj_type type)
 848 {
 849         if (obj.type == type)
 850                 return obj;
 851         if (obj.type == isl_obj_map && type == isl_obj_union_map) {
 852                 obj.type = isl_obj_union_map;
 853                 obj.v = isl_union_map_from_map(obj.v);
 854                 return obj;
 855         }
 856         if (obj.type == isl_obj_set && type == isl_obj_union_set) {
 857                 obj.type = isl_obj_union_set;
 858                 obj.v = isl_union_set_from_set(obj.v);
 859                 return obj;
 860         }
 861         if (obj.type == isl_obj_pw_qpolynomial &&
 862             type == isl_obj_union_pw_qpolynomial) {
 863                 obj.type = isl_obj_union_pw_qpolynomial;
 864                 obj.v = isl_union_pw_qpolynomial_from_pw_qpolynomial(obj.v);
 865                 return obj;
 866         }
 867         if (obj.type == isl_obj_pw_qpolynomial_fold &&
 868             type == isl_obj_union_pw_qpolynomial_fold) {
 869                 obj.type = isl_obj_union_pw_qpolynomial_fold;
 870                 obj.v = isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold(obj.v);
 871                 return obj;
 872         }
 873         if (obj.type == isl_obj_union_set && isl_union_set_is_empty(obj.v)) {
 874                 if (type == isl_obj_union_map) {
 875                         obj.type = isl_obj_union_map;
 876                         return obj;
 877                 }
 878                 if (type == isl_obj_union_pw_qpolynomial) {
 879                         isl_dim *dim = isl_union_set_get_dim(obj.v);
 880                         isl_union_set_free(obj.v);
 881                         obj.v = isl_union_pw_qpolynomial_zero(dim);
 882                         obj.type = isl_obj_union_pw_qpolynomial;
 883                         return obj;
 884                 }
 885                 if (type == isl_obj_union_pw_qpolynomial_fold) {
 886                         isl_dim *dim = isl_union_set_get_dim(obj.v);
 887                         isl_union_set_free(obj.v);
 888                         obj.v = isl_union_pw_qpolynomial_fold_zero(dim,
 889                                                                 isl_fold_list);
 890                         obj.type = isl_obj_union_pw_qpolynomial_fold;
 891                         return obj;
 892                 }
 893         }
 894         if (obj.type == isl_obj_list) {
 895                 struct isl_list *list = obj.v;
 896                 if (list->n == 2 && list->obj[1].type == isl_obj_bool)
 897                         return convert(ctx, obj_at(obj, 0), type);
 898         }
 899         if (type == isl_obj_str) {
 900                 isl_str *str;
 901                 isl_printer *p;
 902                 char *s;
 903
 904                 p = isl_printer_to_str(ctx);
 905                 if (!p)
 906                         goto error;
 907                 p = obj.type->print(p, obj.v);
 908                 s = isl_printer_get_str(p);
 909                 isl_printer_free(p);
 910
 911                 str = isl_str_alloc(ctx);
 912                 if (!str) {
 913                         free(s);
 914                         goto error;
 915                 }
 916                 str->s = s;
 917                 free_obj(obj);
 918                 obj.v = str;
 919                 obj.type = isl_obj_str;
 920                 return obj;
 921
 922         }
 923 error:
 924         free_obj(obj);
 925         obj.type = isl_obj_none;
 926         obj.v = NULL;
 927         return obj;
 928 }
 929
 930 static struct isc_bin_op *read_bin_op_if_available(struct isl_stream *s,
 931         struct isl_obj lhs)
 932 {
 933         int i;
 934         struct isl_token *tok;
 935
 936         tok = isl_stream_next_token(s);
 937         if (!tok)
 938                 return NULL;
 939
 940         for (i = 0; ; ++i) {
 941                 if (!bin_ops[i].op)
 942                         break;
 943                 if (bin_ops[i].op != tok->type)
 944                         continue;
 945                 if (!is_subtype(lhs, bin_ops[i].lhs))
 946                         continue;
 947
 948                 isl_token_free(tok);
 949                 return &bin_ops[i];
 950         }
 951
 952         for (i = 0; ; ++i) {
 953                 if (!named_bin_ops[i].name)
 954                         break;
 955                 if (named_bin_ops[i].op.op != tok->type)
 956                         continue;
 957                 if (!is_subtype(lhs, named_bin_ops[i].op.lhs))
 958                         continue;
 959
 960                 isl_token_free(tok);
 961                 return &named_bin_ops[i].op;
 962         }
 963
 964         isl_stream_push_token(s, tok);
 965
 966         return NULL;
 967 }
 968
 969 static struct isc_un_op *read_prefix_un_op_if_available(struct isl_stream *s)
 970 {
 971         int i;
 972         struct isl_token *tok;
 973
 974         tok = isl_stream_next_token(s);
 975         if (!tok)
 976                 return NULL;
 977
 978         for (i = 0; ; ++i) {
 979                 if (!named_un_ops[i].name)
 980                         break;
 981                 if (named_un_ops[i].op.op != tok->type)
 982                         continue;
 983
 984                 isl_token_free(tok);
 985                 return &named_un_ops[i].op;
 986         }
 987
 988         isl_stream_push_token(s, tok);
 989
 990         return NULL;
 991 }
 992
 993 static struct isc_un_op *find_matching_un_op(struct isc_un_op *like,
 994         struct isl_obj arg)
 995 {
 996         int i;
 997
 998         for (i = 0; ; ++i) {
 999                 if (!named_un_ops[i].name)
1000                         break;
1001                 if (named_un_ops[i].op.op != like->op)
1002                         continue;
1003                 if (!is_subtype(arg, named_un_ops[i].op.arg))
1004                         continue;
1005
1006                 return &named_un_ops[i].op;
1007         }
1008
1009         return NULL;
1010 }
1011
1012 static int is_assign(struct isl_stream *s)
1013 {
1014         struct isl_token *tok;
1015         struct isl_token *tok2;
1016         int assign;
1017
1018         tok = isl_stream_next_token(s);
1019         if (!tok)
1020                 return 0;
1021         if (tok->type != ISL_TOKEN_IDENT) {
1022                 isl_stream_push_token(s, tok);
1023                 return 0;
1024         }
1025
1026         tok2 = isl_stream_next_token(s);
1027         if (!tok2) {
1028                 isl_stream_push_token(s, tok);
1029                 return 0;
1030         }
1031         assign = tok2->type == ISL_TOKEN_DEF;
1032         isl_stream_push_token(s, tok2);
1033         isl_stream_push_token(s, tok);
1034
1035         return assign;
1036 }
1037
1038 static struct isl_obj read_obj(struct isl_stream *s,
1039         struct isl_hash_table *table);
1040 static struct isl_obj read_expr(struct isl_stream *s,
1041         struct isl_hash_table *table);
1042
1043 static struct isl_obj read_un_op_expr(struct isl_stream *s,
1044         struct isl_hash_table *table, struct isc_un_op *op)
1045 {
1046         struct isl_obj obj = { isl_obj_none, NULL };
1047
1048         obj = read_obj(s, table);
1049         if (!obj.v)
1050                 goto error;
1051
1052         op = find_matching_un_op(op, obj);
1053
1054         if (!op)
1055                 isl_die(s->ctx, isl_error_invalid,
1056                         "no such unary operator defined on given operand",
1057                         goto error);
1058
1059         obj = convert(s->ctx, obj, op->arg);
1060         obj.v = op->fn(obj.v);
1061         obj.type = op->res;
1062
1063         return obj;
1064 error:
1065         free_obj(obj);
1066         obj.type = isl_obj_none;
1067         obj.v = NULL;
1068         return obj;
1069 }
1070
1071 static struct isl_obj transitive_closure(struct isl_ctx *ctx, struct isl_obj obj)
1072 {
1073         struct isl_list *list;
1074         int exact;
1075
1076         if (obj.type != isl_obj_union_map)
1077                 obj = convert(ctx, obj, isl_obj_union_map);
1078         isl_assert(ctx, obj.type == isl_obj_union_map, goto error);
1079         list = isl_list_alloc(ctx, 2);
1080         if (!list)
1081                 goto error;
1082
1083         list->obj[0].type = isl_obj_union_map;
1084         list->obj[0].v = isl_union_map_transitive_closure(obj.v, &exact);
1085         list->obj[1].type = isl_obj_bool;
1086         list->obj[1].v = exact ? &isl_bool_true : &isl_bool_false;
1087         obj.v = list;
1088         obj.type = isl_obj_list;
1089         if (exact < 0 || !list->obj[0].v)
1090                 goto error;
1091
1092         return obj;
1093 error:
1094         free_obj(obj);
1095         obj.type = isl_obj_none;
1096         obj.v = NULL;
1097         return obj;
1098 }
1099
1100 static struct isl_obj obj_at_index(struct isl_stream *s, struct isl_obj obj)
1101 {
1102         struct isl_list *list = obj.v;
1103         struct isl_token *tok;
1104         int i;
1105
1106         tok = isl_stream_next_token(s);
1107         if (!tok || tok->type != ISL_TOKEN_VALUE) {
1108                 isl_stream_error(s, tok, "expecting index");
1109                 if (tok)
1110                         isl_stream_push_token(s, tok);
1111                 goto error;
1112         }
1113         i = isl_int_get_si(tok->u.v);
1114         isl_token_free(tok);
1115         isl_assert(s->ctx, i < list->n, goto error);
1116         if (isl_stream_eat(s, ']'))
1117                 goto error;
1118
1119         return obj_at(obj, i);
1120 error:
1121         free_obj(obj);
1122         obj.type = isl_obj_none;
1123         obj.v = NULL;
1124         return obj;
1125 }
1126
1127 static struct isl_obj apply(struct isl_stream *s, __isl_take isl_union_map *umap,
1128         struct isl_hash_table *table)
1129 {
1130         struct isl_obj obj;
1131
1132         obj = read_expr(s, table);
1133         isl_assert(s->ctx, is_subtype(obj, isl_obj_union_set) ||
1134                            is_subtype(obj, isl_obj_union_map), goto error);
1135
1136         if (obj.type == isl_obj_list) {
1137                 struct isl_list *list = obj.v;
1138                 if (list->n == 2 && list->obj[1].type == isl_obj_bool)
1139                         obj = obj_at(obj, 0);
1140         }
1141         if (obj.type == isl_obj_set)
1142                 obj = convert(s->ctx, obj, isl_obj_union_set);
1143         else if (obj.type == isl_obj_map)
1144                 obj = convert(s->ctx, obj, isl_obj_union_map);
1145         if (obj.type == isl_obj_union_set) {
1146                 obj.v = isl_union_set_apply(obj.v, umap);
1147         } else
1148                 obj.v = isl_union_map_apply_range(obj.v, umap);
1149         if (!obj.v)
1150                 goto error2;
1151
1152         if (isl_stream_eat(s, ')'))
1153                 goto error2;
1154
1155         return obj;
1156 error:
1157         isl_union_map_free(umap);
1158 error2:
1159         free_obj(obj);
1160         obj.type = isl_obj_none;
1161         obj.v = NULL;
1162         return obj;
1163 }
1164
1165 static struct isl_obj apply_fun(struct isl_stream *s,
1166         struct isl_obj obj, struct isl_hash_table *table)
1167 {
1168         struct isl_obj arg;
1169
1170         arg = read_expr(s, table);
1171         isl_assert(s->ctx, is_subtype(arg, isl_obj_union_map), goto error);
1172
1173         if (arg.type == isl_obj_list) {
1174                 struct isl_list *list = arg.v;
1175                 if (list->n == 2 && list->obj[1].type == isl_obj_bool)
1176                         arg = obj_at(arg, 0);
1177         }
1178         if (arg.type == isl_obj_map)
1179                 arg = convert(s->ctx, arg, isl_obj_union_map);
1180         if (obj.type == isl_obj_union_pw_qpolynomial) {
1181                 obj.v = isl_union_map_apply_union_pw_qpolynomial(arg.v, obj.v);
1182         } else {
1183                 obj.type = isl_obj_list;
1184                 obj.v = union_map_apply_union_pw_qpolynomial_fold(arg.v, obj.v);
1185         }
1186         if (!obj.v)
1187                 goto error2;
1188
1189         if (isl_stream_eat(s, ')'))
1190                 goto error2;
1191
1192         return obj;
1193 error:
1194         free_obj(arg);
1195 error2:
1196         free_obj(obj);
1197         obj.type = isl_obj_none;
1198         obj.v = NULL;
1199         return obj;
1200 }
1201
1202 struct add_vertex_data {
1203         struct isl_list *list;
1204         int i;
1205 };
1206
1207 static int add_vertex(__isl_take isl_vertex *vertex, void *user)
1208 {
1209         struct add_vertex_data *data = (struct add_vertex_data *)user;
1210         isl_basic_set *expr;
1211
1212         expr = isl_vertex_get_expr(vertex);
1213
1214         data->list->obj[data->i].type = isl_obj_set;
1215         data->list->obj[data->i].v = isl_set_from_basic_set(expr);
1216         data->i++;
1217
1218         isl_vertex_free(vertex);
1219
1220         return 0;
1221 }
1222
1223 static int set_vertices(__isl_take isl_set *set, void *user)
1224 {
1225         isl_ctx *ctx;
1226         isl_basic_set *hull;
1227         isl_vertices *vertices = NULL;
1228         struct isl_list *list = NULL;
1229         int r;
1230         struct add_vertex_data *data = (struct add_vertex_data *)user;
1231
1232         set = isl_set_remove_divs(set);
1233         hull = isl_set_convex_hull(set);
1234         vertices = isl_basic_set_compute_vertices(hull);
1235         isl_basic_set_free(hull);
1236
1237         list = data->list;
1238
1239         ctx = isl_vertices_get_ctx(vertices);
1240         data->list = isl_list_alloc(ctx, isl_vertices_get_n_vertices(vertices));
1241         if (!data->list)
1242                 goto error;
1243
1244         data->i = 0;
1245         r = isl_vertices_foreach_vertex(vertices, &add_vertex, user);
1246
1247         data->list = isl_list_concat(list, data->list);
1248
1249         isl_vertices_free(vertices);
1250
1251         return r;
1252 error:
1253         data->list = list;
1254         isl_vertices_free(vertices);
1255         return -1;
1256 }
1257
1258 static struct isl_obj vertices(struct isl_stream *s,
1259         struct isl_hash_table *table)
1260 {
1261         isl_ctx *ctx;
1262         struct isl_obj obj;
1263         struct isl_list *list = NULL;
1264         isl_union_set *uset;
1265         struct add_vertex_data data = { NULL };
1266
1267         obj = read_expr(s, table);
1268         obj = convert(s->ctx, obj, isl_obj_union_set);
1269         isl_assert(s->ctx, obj.type == isl_obj_union_set, goto error);
1270         uset = obj.v;
1271         obj.v = NULL;
1272
1273         ctx = isl_union_set_get_ctx(uset);
1274         list = isl_list_alloc(ctx, 0);
1275         if (!list)
1276                 goto error;
1277
1278         data.list = list;
1279
1280         if (isl_union_set_foreach_set(uset, &set_vertices, &data) < 0)
1281                 goto error;
1282
1283         isl_union_set_free(uset);
1284
1285         obj.type = isl_obj_list;
1286         obj.v = data.list;
1287
1288         return obj;
1289 error:
1290         isl_union_set_free(uset);
1291         isl_list_free(data.list);
1292         free_obj(obj);
1293         obj.type = isl_obj_none;
1294         obj.v = NULL;
1295         return obj;
1296 }
1297
1298 static __isl_give isl_union_map *read_map(struct isl_stream *s,
1299         struct isl_hash_table *table)
1300 {
1301         struct isl_obj obj;
1302
1303         obj = read_obj(s, table);
1304         obj = convert(s->ctx, obj, isl_obj_union_map);
1305         isl_assert(s->ctx, obj.type == isl_obj_union_map, goto error);
1306         return obj.v;
1307 error:
1308         free_obj(obj);
1309         return NULL;
1310 }
1311
1312 static struct isl_obj last_any(struct isl_stream *s,
1313         struct isl_hash_table *table, __isl_take isl_union_map *must_source,
1314         __isl_take isl_union_map *may_source)
1315 {
1316         struct isl_obj obj = { isl_obj_none, NULL };
1317         isl_union_map *sink = NULL;
1318         isl_union_map *schedule = NULL;
1319         isl_union_map *may_dep;
1320         isl_union_map *must_dep;
1321
1322         if (isl_stream_eat(s, iscc_op[ISCC_BEFORE]))
1323                 goto error;
1324
1325         sink = read_map(s, table);
1326         if (!sink)
1327                 goto error;
1328
1329         if (isl_stream_eat(s, iscc_op[ISCC_UNDER]))
1330                 goto error;
1331
1332         schedule = read_map(s, table);
1333         if (!schedule)
1334                 goto error;
1335
1336         if (isl_union_map_compute_flow(sink, must_source, may_source,
1337                                        schedule, &must_dep, &may_dep,
1338                                        NULL, NULL) < 0)
1339                 return obj;
1340
1341         obj.type = isl_obj_union_map;
1342         obj.v = isl_union_map_union(must_dep, may_dep);
1343
1344         return obj;
1345 error:
1346         isl_union_map_free(may_source);
1347         isl_union_map_free(must_source);
1348         isl_union_map_free(sink);
1349         isl_union_map_free(schedule);
1350         free_obj(obj);
1351         obj.type = isl_obj_none;
1352         obj.v = NULL;
1353         return obj;
1354 }
1355
1356 static struct isl_obj any(struct isl_stream *s, struct isl_hash_table *table)
1357 {
1358         struct isl_obj obj = { isl_obj_none, NULL };
1359         isl_union_map *must_source = NULL;
1360         isl_union_map *may_source = NULL;
1361         isl_union_map *sink = NULL;
1362         isl_union_map *schedule = NULL;
1363         isl_union_map *may_dep;
1364
1365         may_source = read_map(s, table);
1366         if (!may_source)
1367                 goto error;
1368
1369         if (isl_stream_eat_if_available(s, iscc_op[ISCC_LAST])) {
1370                 must_source = read_map(s, table);
1371                 if (!must_source)
1372                         goto error;
1373                 return last_any(s, table, must_source, may_source);
1374         }
1375
1376         if (isl_stream_eat(s, iscc_op[ISCC_BEFORE]))
1377                 goto error;
1378
1379         sink = read_map(s, table);
1380         if (!sink)
1381                 goto error;
1382
1383         if (isl_stream_eat(s, iscc_op[ISCC_UNDER]))
1384                 goto error;
1385
1386         schedule = read_map(s, table);
1387         if (!schedule)
1388                 goto error;
1389
1390         must_source = isl_union_map_empty(isl_union_map_get_dim(sink));
1391         if (isl_union_map_compute_flow(sink, must_source, may_source,
1392                                        schedule, NULL, &may_dep,
1393                                        NULL, NULL) < 0)
1394                 return obj;
1395
1396         obj.type = isl_obj_union_map;
1397         obj.v = may_dep;
1398
1399         return obj;
1400 error:
1401         isl_union_map_free(may_source);
1402         isl_union_map_free(must_source);
1403         isl_union_map_free(sink);
1404         isl_union_map_free(schedule);
1405         free_obj(obj);
1406         obj.type = isl_obj_none;
1407         obj.v = NULL;
1408         return obj;
1409 }
1410
1411 static struct isl_obj last(struct isl_stream *s, struct isl_hash_table *table)
1412 {
1413         struct isl_obj obj = { isl_obj_none, NULL };
1414         struct isl_list *list = NULL;
1415         isl_union_map *must_source = NULL;
1416         isl_union_map *may_source = NULL;
1417         isl_union_map *sink = NULL;
1418         isl_union_map *schedule = NULL;
1419         isl_union_map *must_dep;
1420         isl_union_set *must_no_source;
1421
1422         must_source = read_map(s, table);
1423         if (!must_source)
1424                 goto error;
1425
1426         if (isl_stream_eat_if_available(s, iscc_op[ISCC_ANY])) {
1427                 may_source = read_map(s, table);
1428                 if (!may_source)
1429                         goto error;
1430                 return last_any(s, table, must_source, may_source);
1431         }
1432
1433         list = isl_list_alloc(s->ctx, 2);
1434         if (!list)
1435                 goto error;
1436
1437         if (isl_stream_eat(s, iscc_op[ISCC_BEFORE]))
1438                 goto error;
1439
1440         sink = read_map(s, table);
1441         if (!sink)
1442                 goto error;
1443
1444         if (isl_stream_eat(s, iscc_op[ISCC_UNDER]))
1445                 goto error;
1446
1447         schedule = read_map(s, table);
1448         if (!schedule)
1449                 goto error;
1450
1451         may_source = isl_union_map_empty(isl_union_map_get_dim(sink));
1452         if (isl_union_map_compute_flow(sink, must_source, may_source,
1453                                        schedule, &must_dep, NULL,
1454                                        &must_no_source, NULL) < 0)
1455                 return obj;
1456
1457         list->obj[0].type = isl_obj_union_map;
1458         list->obj[0].v = must_dep;
1459         list->obj[1].type = isl_obj_union_set;
1460         list->obj[1].v = must_no_source;
1461
1462         obj.v = list;
1463         obj.type = isl_obj_list;
1464
1465         return obj;
1466 error:
1467         isl_list_free(list);
1468         isl_union_map_free(may_source);
1469         isl_union_map_free(must_source);
1470         isl_union_map_free(sink);
1471         isl_union_map_free(schedule);
1472         free_obj(obj);
1473         obj.type = isl_obj_none;
1474         obj.v = NULL;
1475         return obj;
1476 }
1477
1478 static struct isl_obj power(struct isl_stream *s, struct isl_obj obj)
1479 {
1480         struct isl_token *tok;
1481
1482         if (isl_stream_eat_if_available(s, '+'))
1483                 return transitive_closure(s->ctx, obj);
1484
1485         tok = isl_stream_next_token(s);
1486         if (!tok || tok->type != ISL_TOKEN_VALUE || isl_int_cmp_si(tok->u.v, -1)) {
1487                 isl_stream_error(s, tok, "expecting -1");
1488                 if (tok)
1489                         isl_stream_push_token(s, tok);
1490                 goto error;
1491         }
1492         isl_token_free(tok);
1493         isl_assert(s->ctx, is_subtype(obj, isl_obj_union_map), goto error);
1494         if (obj.type != isl_obj_union_map)
1495                 obj = convert(s->ctx, obj, isl_obj_union_map);
1496
1497         obj.v = isl_union_map_reverse(obj.v);
1498         if (!obj.v)
1499                 goto error;
1500
1501         return obj;
1502 error:
1503         free_obj(obj);
1504         obj.type = isl_obj_none;
1505         obj.v = NULL;
1506         return obj;
1507 }
1508
1509 static struct isl_obj read_from_file(struct isl_stream *s)
1510 {
1511         struct isl_obj obj;
1512         struct isl_token *tok;
1513         struct isl_stream *s_file;
1514         FILE *file;
1515
1516         tok = isl_stream_next_token(s);
1517         if (!tok || tok->type != ISL_TOKEN_STRING) {
1518                 isl_stream_error(s, tok, "expecting filename");
1519                 isl_token_free(tok);
1520                 goto error;
1521         }
1522
1523         file = fopen(tok->u.s, "r");
1524         isl_token_free(tok);
1525         isl_assert(s->ctx, file, goto error);
1526
1527         s_file = isl_stream_new_file(s->ctx, file);
1528         if (!s_file) {
1529                 fclose(file);
1530                 goto error;
1531         }
1532
1533         obj = isl_stream_read_obj(s_file);
1534
1535         isl_stream_free(s_file);
1536         fclose(file);
1537
1538         return obj;
1539 error:
1540         obj.type = isl_obj_none;
1541         obj.v = NULL;
1542         return obj;
1543 }
1544
1545 static struct isl_obj read_string_if_available(struct isl_stream *s)
1546 {
1547         struct isl_token *tok;
1548         struct isl_obj obj = { isl_obj_none, NULL };
1549
1550         tok = isl_stream_next_token(s);
1551         if (!tok)
1552                 return obj;
1553         if (tok->type == ISL_TOKEN_STRING) {
1554                 isl_str *str;
1555                 str = isl_str_alloc(s->ctx);
1556                 if (!str)
1557                         goto error;
1558                 str->s = strdup(tok->u.s);
1559                 isl_token_free(tok);
1560                 obj.v = str;
1561                 obj.type = isl_obj_str;
1562         } else
1563                 isl_stream_push_token(s, tok);
1564         return obj;
1565 error:
1566         isl_token_free(tok);
1567         return obj;
1568 }
1569
1570 static struct isl_obj read_obj(struct isl_stream *s,
1571         struct isl_hash_table *table)
1572 {
1573         struct isl_obj obj = { isl_obj_none, NULL };
1574         char *name = NULL;
1575         struct isc_un_op *op = NULL;
1576
1577         obj = read_string_if_available(s);
1578         if (obj.v)
1579                 return obj;
1580         if (isl_stream_eat_if_available(s, '(')) {
1581                 obj = read_expr(s, table);
1582                 if (!obj.v || isl_stream_eat(s, ')'))
1583                         goto error;
1584         } else {
1585                 op = read_prefix_un_op_if_available(s);
1586                 if (op)
1587                         return read_un_op_expr(s, table, op);
1588
1589                 if (isl_stream_eat_if_available(s, iscc_op[ISCC_READ]))
1590                         return read_from_file(s);
1591                 if (isl_stream_eat_if_available(s, iscc_op[ISCC_VERTICES]))
1592                         return vertices(s, table);
1593                 if (isl_stream_eat_if_available(s, iscc_op[ISCC_ANY]))
1594                         return any(s, table);
1595                 if (isl_stream_eat_if_available(s, iscc_op[ISCC_LAST]))
1596                         return last(s, table);
1597
1598                 name = isl_stream_read_ident_if_available(s);
1599                 if (name)
1600                         obj = stored_obj(s->ctx, table, name);
1601                 else
1602                         obj = isl_stream_read_obj(s);
1603                 if (!obj.v)
1604                         goto error;
1605         }
1606
1607         if (isl_stream_eat_if_available(s, '^'))
1608                 obj = power(s, obj);
1609         else if (obj.type == isl_obj_list && isl_stream_eat_if_available(s, '['))
1610                 obj = obj_at_index(s, obj);
1611         else if (is_subtype(obj, isl_obj_union_map) &&
1612                  isl_stream_eat_if_available(s, '(')) {
1613                 obj = convert(s->ctx, obj, isl_obj_union_map);
1614                 obj = apply(s, obj.v, table);
1615         } else if (is_subtype(obj, isl_obj_union_pw_qpolynomial) &&
1616                    isl_stream_eat_if_available(s, '(')) {
1617                 obj = convert(s->ctx, obj, isl_obj_union_pw_qpolynomial);
1618                 obj = apply_fun(s, obj, table);
1619         } else if (is_subtype(obj, isl_obj_union_pw_qpolynomial_fold) &&
1620                    isl_stream_eat_if_available(s, '(')) {
1621                 obj = convert(s->ctx, obj, isl_obj_union_pw_qpolynomial_fold);
1622                 obj = apply_fun(s, obj, table);
1623         }
1624
1625         return obj;
1626 error:
1627         free_obj(obj);
1628         obj.type = isl_obj_none;
1629         obj.v = NULL;
1630         return obj;
1631 }
1632
1633 static struct isc_bin_op *find_matching_bin_op(struct isc_bin_op *like,
1634         struct isl_obj lhs, struct isl_obj rhs)
1635 {
1636         int i;
1637
1638         for (i = 0; ; ++i) {
1639                 if (!bin_ops[i].op)
1640                         break;
1641                 if (bin_ops[i].op != like->op)
1642                         continue;
1643                 if (!is_subtype(lhs, bin_ops[i].lhs))
1644                         continue;
1645                 if (!is_subtype(rhs, bin_ops[i].rhs))
1646                         continue;
1647
1648                 return &bin_ops[i];
1649         }
1650
1651         for (i = 0; ; ++i) {
1652                 if (!named_bin_ops[i].name)
1653                         break;
1654                 if (named_bin_ops[i].op.op != like->op)
1655                         continue;
1656                 if (!is_subtype(lhs, named_bin_ops[i].op.lhs))
1657                         continue;
1658                 if (!is_subtype(rhs, named_bin_ops[i].op.rhs))
1659                         continue;
1660
1661                 return &named_bin_ops[i].op;
1662         }
1663
1664         return NULL;
1665 }
1666
1667 static struct isl_obj read_expr(struct isl_stream *s,
1668         struct isl_hash_table *table)
1669 {
1670         struct isl_obj obj = { isl_obj_none, NULL };
1671         struct isl_obj right_obj = { isl_obj_none, NULL };
1672
1673         obj = read_obj(s, table);
1674         for (; obj.v;) {
1675                 struct isc_bin_op *op = NULL;
1676
1677                 op = read_bin_op_if_available(s, obj);
1678                 if (!op)
1679                         break;
1680
1681                 right_obj = read_obj(s, table);
1682
1683                 op = find_matching_bin_op(op, obj, right_obj);
1684
1685                 if (!op)
1686                         isl_die(s->ctx, isl_error_invalid,
1687                             "no such binary operator defined on given operands",
1688                             goto error);
1689
1690                 obj = convert(s->ctx, obj, op->lhs);
1691                 right_obj = convert(s->ctx, right_obj, op->rhs);
1692                 obj.v = op->fn(obj.v, right_obj.v);
1693                 obj.type = op->res;
1694         }
1695
1696         return obj;
1697 error:
1698         free_obj(right_obj);
1699         free_obj(obj);
1700         obj.type = isl_obj_none;
1701         obj.v = NULL;
1702         return obj;
1703 }
1704
1705 static __isl_give isl_printer *source_file(struct isl_stream *s,
1706         struct isl_hash_table *table, __isl_take isl_printer *p);
1707
1708 static __isl_give isl_printer *read_line(struct isl_stream *s,
1709         struct isl_hash_table *table, __isl_take isl_printer *p)
1710 {
1711         struct isl_obj obj = { isl_obj_none, NULL };
1712         char *lhs = NULL;
1713         int assign = 0;
1714         struct isc_bin_op *op = NULL;
1715
1716         if (!p)
1717                 return NULL;
1718         if (isl_stream_is_empty(s))
1719                 return p;
1720
1721         if (isl_stream_eat_if_available(s, iscc_op[ISCC_SOURCE]))
1722                 return source_file(s, table, p);
1723
1724         assign = is_assign(s);
1725         if (assign) {
1726                 lhs = isl_stream_read_ident_if_available(s);
1727                 if (isl_stream_eat(s, ISL_TOKEN_DEF))
1728                         goto error;
1729         }
1730
1731         obj = read_expr(s, table);
1732         if (obj.type == isl_obj_none || obj.v == NULL)
1733                 goto error;
1734         if (isl_stream_eat(s, ';'))
1735                 goto error;
1736
1737         if (assign) {
1738                 if (do_assign(s->ctx, table, lhs, obj))
1739                         return;
1740         } else {
1741                 p = obj.type->print(p, obj.v);
1742                 p = isl_printer_end_line(p);
1743                 free_obj(obj);
1744         }
1745
1746         return p;
1747 error:
1748         isl_stream_flush_tokens(s);
1749         isl_stream_skip_line(s);
1750         free(lhs);
1751         free_obj(obj);
1752         return p;
1753 }
1754
1755 int free_cb(void **entry, void *user)
1756 {
1757         struct isl_named_obj *named = *entry;
1758
1759         free_obj(named->obj);
1760         free(named->name);
1761         free(named);
1762
1763         return 0;
1764 }
1765
1766 static void register_named_ops(struct isl_stream *s)
1767 {
1768         int i;
1769
1770         for (i = 0; i < ISCC_N_OP; ++i) {
1771                 iscc_op[i] = isl_stream_register_keyword(s, op_name[i]);
1772                 assert(iscc_op[i] != ISL_TOKEN_ERROR);
1773         }
1774
1775         for (i = 0; ; ++i) {
1776                 if (!named_un_ops[i].name)
1777                         break;
1778                 named_un_ops[i].op.op = isl_stream_register_keyword(s,
1779                                                         named_un_ops[i].name);
1780                 assert(named_un_ops[i].op.op != ISL_TOKEN_ERROR);
1781         }
1782
1783         for (i = 0; ; ++i) {
1784                 if (!named_bin_ops[i].name)
1785                         break;
1786                 named_bin_ops[i].op.op = isl_stream_register_keyword(s,
1787                                                         named_bin_ops[i].name);
1788                 assert(named_bin_ops[i].op.op != ISL_TOKEN_ERROR);
1789         }
1790 }
1791
1792 static __isl_give isl_printer *source_file(struct isl_stream *s,
1793         struct isl_hash_table *table, __isl_take isl_printer *p)
1794 {
1795         struct isl_token *tok;
1796         struct isl_stream *s_file;
1797         FILE *file;
1798
1799         tok = isl_stream_next_token(s);
1800         if (!tok || tok->type != ISL_TOKEN_STRING) {
1801                 isl_stream_error(s, tok, "expecting filename");
1802                 isl_token_free(tok);
1803                 return p;
1804         }
1805
1806         file = fopen(tok->u.s, "r");
1807         isl_token_free(tok);
1808         isl_assert(s->ctx, file, return p);
1809
1810         s_file = isl_stream_new_file(s->ctx, file);
1811         if (!s_file) {
1812                 fclose(file);
1813                 return p;
1814         }
1815
1816         register_named_ops(s_file);
1817
1818         while (!s_file->eof)
1819                 p = read_line(s_file, table, p);
1820
1821         isl_stream_free(s_file);
1822         fclose(file);
1823
1824         isl_stream_eat(s, ';');
1825
1826         return p;
1827 }
1828
1829 int main(int argc, char **argv)
1830 {
1831         struct isl_ctx *ctx;
1832         struct isl_stream *s;
1833         struct isl_hash_table *table;
1834         struct iscc_options *options;
1835         isl_printer *p;
1836
1837         options = iscc_options_new_with_defaults();
1838         assert(options);
1839         argc = iscc_options_parse(options, argc, argv, ISL_ARG_ALL);
1840
1841         ctx = isl_ctx_alloc_with_options(iscc_options_arg, options);
1842         s = isl_stream_new_file(ctx, stdin);
1843         assert(s);
1844         table = isl_hash_table_alloc(ctx, 10);
1845         assert(table);
1846         p = isl_printer_to_file(ctx, stdout);
1847         p = isl_printer_set_output_format(p, options->format);
1848         assert(p);
1849
1850         register_named_ops(s);
1851
1852         while (p && !s->eof) {
1853                 p = read_line(s, table, p);
1854         }
1855
1856         isl_printer_free(p);
1857         isl_hash_table_foreach(ctx, table, free_cb, NULL);
1858         isl_hash_table_free(ctx, table);
1859         isl_stream_free(s);
1860         isl_ctx_free(ctx);
1861
1862         return 0;
1863 }