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_obj_list.h>
   7 #include <barvinok/barvinok.h>
   8
   9 #include "config.h"
  10 #ifdef HAVE_GINAC
  11 #include <barvinok/bernstein.h>
  12 #endif
  13
  14 static int isl_bool_false = 0;
  15 static int isl_bool_true = 1;
  16 static int isl_bool_error = -1;
  17
  18 static void *isl_obj_bool_copy(void *v)
  19 {
  20         return v;
  21 }
  22
  23 static void isl_obj_bool_free(void *v)
  24 {
  25 }
  26
  27 static __isl_give isl_printer *isl_obj_bool_print(__isl_take isl_printer *p,
  28         void *v)
  29 {
  30         if (v == &isl_bool_true)
  31                 return isl_printer_print_str(p, "True");
  32         else if (v == &isl_bool_false)
  33                 return isl_printer_print_str(p, "False");
  34         else
  35                 return isl_printer_print_str(p, "Error");
  36 }
  37
  38 static void *isl_obj_bool_add(void *v1, void *v2)
  39 {
  40         return v1;
  41 }
  42
  43 struct isl_obj_vtable isl_obj_bool_vtable = {
  44         isl_obj_bool_copy,
  45         isl_obj_bool_add,
  46         isl_obj_bool_print,
  47         isl_obj_bool_free
  48 };
  49 #define isl_obj_bool            (&isl_obj_bool_vtable)
  50
  51 int *isl_bool_from_int(int res)
  52 {
  53         return res < 0 ? &isl_bool_error : res ? &isl_bool_true : &isl_bool_false;
  54 }
  55
  56 int *map_is_equal(__isl_take isl_map *map1, __isl_take isl_map *map2)
  57 {
  58         int res = isl_map_is_equal(map1, map2);
  59         isl_map_free(map1);
  60         isl_map_free(map2);
  61         return isl_bool_from_int(res);
  62 }
  63 int *set_is_equal(__isl_take isl_set *set1, __isl_take isl_set *set2)
  64 {
  65         return map_is_equal((isl_map *)set1, (isl_map *)set2);
  66 }
  67
  68 int *map_is_subset(__isl_take isl_map *map1, __isl_take isl_map *map2)
  69 {
  70         int res = isl_map_is_subset(map1, map2);
  71         isl_map_free(map1);
  72         isl_map_free(map2);
  73         return isl_bool_from_int(res);
  74 }
  75 int *set_is_subset(__isl_take isl_set *set1, __isl_take isl_set *set2)
  76 {
  77         return map_is_subset((isl_map *)set1, (isl_map *)set2);
  78 }
  79
  80 int *map_is_strict_subset(__isl_take isl_map *map1, __isl_take isl_map *map2)
  81 {
  82         int res = isl_map_is_strict_subset(map1, map2);
  83         isl_map_free(map1);
  84         isl_map_free(map2);
  85         return isl_bool_from_int(res);
  86 }
  87 int *set_is_strict_subset(__isl_take isl_set *set1, __isl_take isl_set *set2)
  88 {
  89         return map_is_strict_subset((isl_map *)set1, (isl_map *)set2);
  90 }
  91
  92 int *map_is_superset(__isl_take isl_map *map1, __isl_take isl_map *map2)
  93 {
  94         return map_is_subset(map2, map1);
  95 }
  96 int *set_is_superset(__isl_take isl_set *set1, __isl_take isl_set *set2)
  97 {
  98         return set_is_subset(set2, set1);
  99 }
 100
 101 int *map_is_strict_superset(__isl_take isl_map *map1, __isl_take isl_map *map2)
 102 {
 103         return map_is_strict_subset(map2, map1);
 104 }
 105 int *set_is_strict_superset(__isl_take isl_set *set1, __isl_take isl_set *set2)
 106 {
 107         return set_is_strict_subset(set2, set1);
 108 }
 109
 110 extern struct isl_obj_vtable isl_obj_list_vtable;
 111 #define isl_obj_list            (&isl_obj_list_vtable)
 112
 113 typedef void *(*isc_bin_op_fn)(void *lhs, void *rhs);
 114 struct isc_bin_op {
 115         enum isl_token_type     op;
 116         isl_obj_type            lhs;
 117         isl_obj_type            rhs;
 118         isl_obj_type            res;
 119         isc_bin_op_fn           fn;
 120 };
 121
 122 struct iscc_at {
 123         isl_pw_qpolynomial *pwqp;
 124         isl_pw_qpolynomial *res;
 125 };
 126
 127 static int eval_at(__isl_take isl_point *pnt, void *user)
 128 {
 129         struct iscc_at *at = (struct iscc_at *) user;
 130         isl_qpolynomial *qp;
 131         isl_set *set;
 132
 133         set = isl_set_from_point(isl_point_copy(pnt));
 134         qp = isl_pw_qpolynomial_eval(isl_pw_qpolynomial_copy(at->pwqp), pnt);
 135
 136         at->res = isl_pw_qpolynomial_add_disjoint(at->res,
 137                         isl_pw_qpolynomial_alloc(set, qp));
 138
 139         return 0;
 140 }
 141
 142 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_at(
 143         __isl_take isl_pw_qpolynomial *pwqp, __isl_take isl_set *set)
 144 {
 145         struct iscc_at at;
 146
 147         at.pwqp = pwqp;
 148         at.res = isl_pw_qpolynomial_zero(isl_set_get_dim(set));
 149
 150         isl_set_foreach_point(set, eval_at, &at);
 151
 152         isl_pw_qpolynomial_free(pwqp);
 153         isl_set_free(set);
 154
 155         return at.res;
 156 }
 157
 158 struct iscc_fold_at {
 159         isl_pw_qpolynomial_fold *pwf;
 160         isl_pw_qpolynomial *res;
 161 };
 162
 163 static int eval_fold_at(__isl_take isl_point *pnt, void *user)
 164 {
 165         struct iscc_fold_at *at = (struct iscc_fold_at *) user;
 166         isl_qpolynomial *qp;
 167         isl_set *set;
 168
 169         set = isl_set_from_point(isl_point_copy(pnt));
 170         qp = isl_pw_qpolynomial_fold_eval(isl_pw_qpolynomial_fold_copy(at->pwf),
 171                                                 pnt);
 172
 173         at->res = isl_pw_qpolynomial_add_disjoint(at->res,
 174                         isl_pw_qpolynomial_alloc(set, qp));
 175
 176         return 0;
 177 }
 178
 179 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fold_at(
 180         __isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_set *set)
 181 {
 182         struct iscc_fold_at at;
 183
 184         at.pwf = pwf;
 185         at.res = isl_pw_qpolynomial_zero(isl_set_get_dim(set));
 186
 187         isl_set_foreach_point(set, eval_fold_at, &at);
 188
 189         isl_pw_qpolynomial_fold_free(pwf);
 190         isl_set_free(set);
 191
 192         return at.res;
 193 }
 194
 195 static __isl_give isl_set *set_gist(__isl_take isl_set *set,
 196         __isl_take isl_set *context)
 197 {
 198         return isl_set_gist(set, isl_set_convex_hull(context));
 199 }
 200
 201 static __isl_give isl_map *map_gist(__isl_take isl_map *map,
 202         __isl_take isl_map *context)
 203 {
 204         return isl_map_gist(map, isl_map_convex_hull(context));
 205 }
 206
 207 struct isc_bin_op bin_ops[] = {
 208         { '+',  isl_obj_set,    isl_obj_set,
 209                 isl_obj_set,
 210                 (isc_bin_op_fn) &isl_set_union },
 211         { '+',  isl_obj_map,    isl_obj_map,
 212                 isl_obj_map,
 213                 (isc_bin_op_fn) &isl_map_union },
 214         { '-',  isl_obj_set,    isl_obj_set,
 215                 isl_obj_set,
 216                 (isc_bin_op_fn) &isl_set_subtract },
 217         { '-',  isl_obj_map,    isl_obj_map,
 218                 isl_obj_map,
 219                 (isc_bin_op_fn) &isl_map_subtract },
 220         { '*',  isl_obj_set,    isl_obj_set,
 221                 isl_obj_set,
 222                 (isc_bin_op_fn) &isl_set_intersect },
 223         { '*',  isl_obj_map,    isl_obj_map,
 224                 isl_obj_map,
 225                 (isc_bin_op_fn) &isl_map_intersect },
 226         { '*',  isl_obj_map,    isl_obj_set,
 227                 isl_obj_map,
 228                 (isc_bin_op_fn) &isl_map_intersect_domain },
 229         { '.',  isl_obj_map,    isl_obj_map,
 230                 isl_obj_map,
 231                 (isc_bin_op_fn) &isl_map_apply_range },
 232         { ISL_TOKEN_TO, isl_obj_set,    isl_obj_set,    isl_obj_map,
 233                 (isc_bin_op_fn) &isl_map_from_domain_and_range },
 234         { '=', isl_obj_set,     isl_obj_set,    isl_obj_bool,
 235                 (isc_bin_op_fn) &set_is_equal },
 236         { '=', isl_obj_map,     isl_obj_map,    isl_obj_bool,
 237                 (isc_bin_op_fn) &map_is_equal },
 238         { ISL_TOKEN_LE, isl_obj_set,    isl_obj_set,    isl_obj_bool,
 239                 (isc_bin_op_fn) &set_is_subset },
 240         { ISL_TOKEN_LE, isl_obj_map,    isl_obj_map,    isl_obj_bool,
 241                 (isc_bin_op_fn) &map_is_subset },
 242         { ISL_TOKEN_LT, isl_obj_set,    isl_obj_set,    isl_obj_bool,
 243                 (isc_bin_op_fn) &set_is_strict_subset },
 244         { ISL_TOKEN_LT, isl_obj_map,    isl_obj_map,    isl_obj_bool,
 245                 (isc_bin_op_fn) &map_is_strict_subset },
 246         { ISL_TOKEN_GE, isl_obj_set,    isl_obj_set,    isl_obj_bool,
 247                 (isc_bin_op_fn) &set_is_superset },
 248         { ISL_TOKEN_GE, isl_obj_map,    isl_obj_map,    isl_obj_bool,
 249                 (isc_bin_op_fn) &map_is_superset },
 250         { ISL_TOKEN_GT, isl_obj_set,    isl_obj_set,    isl_obj_bool,
 251                 (isc_bin_op_fn) &set_is_strict_superset },
 252         { ISL_TOKEN_GT, isl_obj_map,    isl_obj_map,    isl_obj_bool,
 253                 (isc_bin_op_fn) &map_is_strict_superset },
 254         { '+',  isl_obj_pw_qpolynomial, isl_obj_pw_qpolynomial,
 255                 isl_obj_pw_qpolynomial,
 256                 (isc_bin_op_fn) &isl_pw_qpolynomial_add },
 257         { '-',  isl_obj_pw_qpolynomial, isl_obj_pw_qpolynomial,
 258                 isl_obj_pw_qpolynomial,
 259                 (isc_bin_op_fn) &isl_pw_qpolynomial_sub },
 260         { '*',  isl_obj_pw_qpolynomial, isl_obj_pw_qpolynomial,
 261                 isl_obj_pw_qpolynomial,
 262                 (isc_bin_op_fn) &isl_pw_qpolynomial_mul },
 263         { '*',  isl_obj_pw_qpolynomial, isl_obj_set,
 264                 isl_obj_pw_qpolynomial,
 265                 (isc_bin_op_fn) &isl_pw_qpolynomial_intersect_domain },
 266         { '*',  isl_obj_pw_qpolynomial_fold,    isl_obj_set,
 267                 isl_obj_pw_qpolynomial_fold,
 268                 (isc_bin_op_fn) &isl_pw_qpolynomial_fold_intersect_domain },
 269         { '@',  isl_obj_pw_qpolynomial, isl_obj_set,
 270                 isl_obj_pw_qpolynomial,
 271                 (isc_bin_op_fn) &isl_pw_qpolynomial_at },
 272         { '@',  isl_obj_pw_qpolynomial_fold, isl_obj_set,
 273                 isl_obj_pw_qpolynomial,
 274                 (isc_bin_op_fn) &isl_pw_qpolynomial_fold_at },
 275         { '%',  isl_obj_set,    isl_obj_set,
 276                 isl_obj_set,
 277                 (isc_bin_op_fn) &set_gist },
 278         { '%',  isl_obj_map,    isl_obj_map,
 279                 isl_obj_map,
 280                 (isc_bin_op_fn) &map_gist },
 281         { '%',  isl_obj_pw_qpolynomial, isl_obj_set,
 282                 isl_obj_pw_qpolynomial,
 283                 (isc_bin_op_fn) &isl_pw_qpolynomial_gist },
 284         { '%',  isl_obj_pw_qpolynomial_fold,    isl_obj_set,
 285                 isl_obj_pw_qpolynomial_fold,
 286                 (isc_bin_op_fn) &isl_pw_qpolynomial_fold_gist },
 287         0
 288 };
 289
 290 __isl_give isl_set *set_sample(__isl_take isl_set *set)
 291 {
 292         return isl_set_from_basic_set(isl_set_sample(set));
 293 }
 294
 295 __isl_give isl_map *map_sample(__isl_take isl_map *map)
 296 {
 297         return isl_map_from_basic_map(isl_map_sample(map));
 298 }
 299
 300 static __isl_give isl_set *set_affine_hull(__isl_take isl_set *set)
 301 {
 302         return isl_set_from_basic_set(isl_set_affine_hull(set));
 303 }
 304
 305 static __isl_give isl_map *map_affine_hull(__isl_take isl_map *map)
 306 {
 307         return isl_map_from_basic_map(isl_map_affine_hull(map));
 308 }
 309
 310 typedef void *(*isc_un_op_fn)(void *arg);
 311 struct isc_un_op {
 312         enum isl_token_type     op;
 313         isl_obj_type            arg;
 314         isl_obj_type            res;
 315         isc_un_op_fn            fn;
 316 };
 317 struct isc_named_un_op {
 318         char                    *name;
 319         struct isc_un_op        op;
 320 };
 321 struct isc_named_un_op named_un_ops[] = {
 322         {"aff", { -1,   isl_obj_map,    isl_obj_map,
 323                 (isc_un_op_fn) &map_affine_hull } },
 324         {"aff", { -1,   isl_obj_set,    isl_obj_set,
 325                 (isc_un_op_fn) &set_affine_hull } },
 326         {"card",        { -1,   isl_obj_set,    isl_obj_pw_qpolynomial,
 327                 (isc_un_op_fn) &isl_set_card } },
 328         {"card",        { -1,   isl_obj_map,    isl_obj_pw_qpolynomial,
 329                 (isc_un_op_fn) &isl_map_card } },
 330         {"dom", { -1,   isl_obj_map,    isl_obj_set,
 331                 (isc_un_op_fn) &isl_map_domain } },
 332         {"dom", { -1,   isl_obj_pw_qpolynomial, isl_obj_set,
 333                 (isc_un_op_fn) &isl_pw_qpolynomial_domain } },
 334         {"dom", { -1,   isl_obj_pw_qpolynomial_fold,    isl_obj_set,
 335                 (isc_un_op_fn) &isl_pw_qpolynomial_fold_domain } },
 336         {"ran", { -1,   isl_obj_map,    isl_obj_set,
 337                 (isc_un_op_fn) &isl_map_range } },
 338         {"lexmin",      { -1,   isl_obj_map,    isl_obj_map,
 339                 (isc_un_op_fn) &isl_map_lexmin } },
 340         {"lexmax",      { -1,   isl_obj_map,    isl_obj_map,
 341                 (isc_un_op_fn) &isl_map_lexmax } },
 342         {"lexmin",      { -1,   isl_obj_set,    isl_obj_set,
 343                 (isc_un_op_fn) &isl_set_lexmin } },
 344         {"lexmax",      { -1,   isl_obj_set,    isl_obj_set,
 345                 (isc_un_op_fn) &isl_set_lexmax } },
 346         {"sample",      { -1,   isl_obj_set,    isl_obj_set,
 347                 (isc_un_op_fn) &set_sample } },
 348         {"sample",      { -1,   isl_obj_map,    isl_obj_map,
 349                 (isc_un_op_fn) &map_sample } },
 350         {"sum",         { -1,   isl_obj_pw_qpolynomial, isl_obj_pw_qpolynomial,
 351                 (isc_un_op_fn) &isl_pw_qpolynomial_sum } },
 352 #ifdef HAVE_GINAC
 353         {"ub",          { -1,   isl_obj_pw_qpolynomial, isl_obj_pw_qpolynomial_fold,
 354                 (isc_un_op_fn) &isl_pw_qpolynomial_upper_bound } },
 355 #endif
 356         NULL
 357 };
 358
 359 struct isl_named_obj {
 360         char            *name;
 361         struct isl_obj  obj;
 362 };
 363
 364 static void free_obj(struct isl_obj obj)
 365 {
 366         obj.type->free(obj.v);
 367 }
 368
 369 static int same_name(const void *entry, const void *val)
 370 {
 371         const struct isl_named_obj *named = (const struct isl_named_obj *)entry;
 372
 373         return !strcmp(named->name, val);
 374 }
 375
 376 static int do_assign(struct isl_ctx *ctx, struct isl_hash_table *table,
 377         char *name, struct isl_obj obj)
 378 {
 379         struct isl_hash_table_entry *entry;
 380         uint32_t name_hash;
 381         struct isl_named_obj *named;
 382
 383         name_hash = isl_hash_string(isl_hash_init(), name);
 384         entry = isl_hash_table_find(ctx, table, name_hash, same_name, name, 1);
 385         if (!entry)
 386                 goto error;
 387         if (entry->data) {
 388                 named = entry->data;
 389                 free_obj(named->obj);
 390                 free(name);
 391         } else {
 392                 named = isl_alloc_type(ctx, struct isl_named_obj);
 393                 if (!named)
 394                         goto error;
 395                 named->name = name;
 396                 entry->data = named;
 397         }
 398         named->obj = obj;
 399
 400         return 0;
 401 error:
 402         free_obj(obj);
 403         free(name);
 404         return -1;
 405 }
 406
 407 static struct isl_obj stored_obj(struct isl_ctx *ctx,
 408         struct isl_hash_table *table, char *name)
 409 {
 410         struct isl_obj obj = { isl_obj_none, NULL };
 411         struct isl_hash_table_entry *entry;
 412         uint32_t name_hash;
 413
 414         name_hash = isl_hash_string(isl_hash_init(), name);
 415         entry = isl_hash_table_find(ctx, table, name_hash, same_name, name, 0);
 416         if (entry) {
 417                 struct isl_named_obj *named;
 418                 named = entry->data;
 419                 obj = named->obj;
 420         }
 421
 422         free(name);
 423         obj.v = obj.type->copy(obj.v);
 424         return obj;
 425 }
 426
 427 static struct isc_bin_op *read_bin_op_if_available(struct isl_stream *s,
 428         isl_obj_type lhs)
 429 {
 430         int i;
 431         struct isl_token *tok;
 432
 433         tok = isl_stream_next_token(s);
 434         if (!tok)
 435                 return NULL;
 436
 437         for (i = 0; ; ++i) {
 438                 if (!bin_ops[i].op)
 439                         break;
 440                 if (bin_ops[i].op != tok->type)
 441                         continue;
 442                 if (bin_ops[i].lhs != lhs)
 443                         continue;
 444
 445                 isl_token_free(tok);
 446                 return &bin_ops[i];
 447         }
 448
 449         isl_stream_push_token(s, tok);
 450
 451         return NULL;
 452 }
 453
 454 static struct isc_un_op *read_prefix_un_op_if_available(struct isl_stream *s)
 455 {
 456         int i;
 457         struct isl_token *tok;
 458
 459         tok = isl_stream_next_token(s);
 460         if (!tok)
 461                 return NULL;
 462
 463         for (i = 0; ; ++i) {
 464                 if (!named_un_ops[i].op.op)
 465                         break;
 466                 if (named_un_ops[i].op.op != tok->type)
 467                         continue;
 468
 469                 isl_token_free(tok);
 470                 return &named_un_ops[i].op;
 471         }
 472
 473         isl_stream_push_token(s, tok);
 474
 475         return NULL;
 476 }
 477
 478 static struct isc_un_op *find_matching_un_op(struct isc_un_op *like,
 479         isl_obj_type arg)
 480 {
 481         int i;
 482
 483         for (i = 0; ; ++i) {
 484                 if (!named_un_ops[i].op.op)
 485                         break;
 486                 if (named_un_ops[i].op.op != like->op)
 487                         continue;
 488                 if (named_un_ops[i].op.arg != arg)
 489                         continue;
 490
 491                 return &named_un_ops[i].op;
 492         }
 493
 494         return NULL;
 495 }
 496
 497 static int is_assign(struct isl_stream *s)
 498 {
 499         struct isl_token *tok;
 500         struct isl_token *tok2;
 501         int assign;
 502
 503         tok = isl_stream_next_token(s);
 504         if (!tok)
 505                 return 0;
 506         if (tok->type != ISL_TOKEN_IDENT) {
 507                 isl_stream_push_token(s, tok);
 508                 return 0;
 509         }
 510
 511         tok2 = isl_stream_next_token(s);
 512         if (!tok2) {
 513                 isl_stream_push_token(s, tok);
 514                 return 0;
 515         }
 516         assign = tok2->type == ISL_TOKEN_DEF;
 517         isl_stream_push_token(s, tok2);
 518         isl_stream_push_token(s, tok);
 519
 520         return assign;
 521 }
 522
 523 static struct isl_obj read_obj(struct isl_stream *s,
 524         struct isl_hash_table *table);
 525 static struct isl_obj read_expr(struct isl_stream *s,
 526         struct isl_hash_table *table);
 527
 528 static struct isl_obj read_un_op_expr(struct isl_stream *s,
 529         struct isl_hash_table *table, struct isc_un_op *op)
 530 {
 531         struct isl_obj obj = { isl_obj_none, NULL };
 532
 533         obj = read_obj(s, table);
 534
 535         op = find_matching_un_op(op, obj.type);
 536
 537         isl_assert(s->ctx, op, goto error);
 538         obj.v = op->fn(obj.v);
 539         obj.type = op->res;
 540
 541         return obj;
 542 error:
 543         free_obj(obj);
 544         obj.type = isl_obj_none;
 545         obj.v = NULL;
 546         return obj;
 547 }
 548
 549 static struct isl_obj transitive_closure(struct isl_ctx *ctx, struct isl_obj obj)
 550 {
 551         struct isl_list *list;
 552         int exact;
 553
 554         isl_assert(ctx, obj.type == isl_obj_map, goto error);
 555         list = isl_list_alloc(ctx, 2);
 556         if (!list)
 557                 goto error;
 558
 559         list->obj[0].type = isl_obj_map;
 560         list->obj[0].v = isl_map_transitive_closure(obj.v, &exact);
 561         list->obj[1].type = isl_obj_bool;
 562         list->obj[1].v = exact ? &isl_bool_true : &isl_bool_false;
 563         obj.v = list;
 564         obj.type = isl_obj_list;
 565         if (exact < 0 || !list->obj[0].v)
 566                 goto error;
 567
 568         return obj;
 569 error:
 570         free_obj(obj);
 571         obj.type = isl_obj_none;
 572         obj.v = NULL;
 573         return obj;
 574 }
 575
 576 static struct isl_obj obj_at_index(struct isl_stream *s, struct isl_obj obj)
 577 {
 578         struct isl_list *list = obj.v;
 579         struct isl_token *tok;
 580         int i;
 581
 582         tok = isl_stream_next_token(s);
 583         if (!tok || tok->type != ISL_TOKEN_VALUE) {
 584                 isl_stream_error(s, tok, "expecting index");
 585                 if (tok)
 586                         isl_stream_push_token(s, tok);
 587                 goto error;
 588         }
 589         i = isl_int_get_si(tok->u.v);
 590         isl_token_free(tok);
 591         isl_assert(s, i < list->n, goto error);
 592         if (isl_stream_eat(s, ']'))
 593                 goto error;
 594
 595         obj = list->obj[i];
 596         obj.v = obj.type->copy(obj.v);
 597
 598         isl_list_free(list);
 599
 600         return obj;
 601 error:
 602         free_obj(obj);
 603         obj.type = isl_obj_none;
 604         obj.v = NULL;
 605         return obj;
 606 }
 607
 608 static struct isl_obj power(struct isl_stream *s, struct isl_obj obj)
 609 {
 610         struct isl_token *tok;
 611
 612         if (isl_stream_eat_if_available(s, '+'))
 613                 return transitive_closure(s->ctx, obj);
 614
 615         tok = isl_stream_next_token(s);
 616         if (!tok || tok->type != ISL_TOKEN_VALUE || isl_int_cmp_si(tok->u.v, -1)) {
 617                 isl_stream_error(s, tok, "expecting -1");
 618                 if (tok)
 619                         isl_stream_push_token(s, tok);
 620                 goto error;
 621         }
 622         isl_token_free(tok);
 623         isl_assert(s->ctx, obj.type == isl_obj_map, goto error);
 624
 625         obj.v = isl_map_reverse(obj.v);
 626         if (!obj.v)
 627                 goto error;
 628
 629         return obj;
 630 error:
 631         free_obj(obj);
 632         obj.type = isl_obj_none;
 633         obj.v = NULL;
 634         return obj;
 635 }
 636
 637 static struct isl_obj read_obj(struct isl_stream *s,
 638         struct isl_hash_table *table)
 639 {
 640         struct isl_obj obj = { isl_obj_none, NULL };
 641         char *name = NULL;
 642         struct isc_un_op *op = NULL;
 643
 644         if (isl_stream_eat_if_available(s, '(')) {
 645                 obj = read_expr(s, table);
 646                 if (isl_stream_eat(s, ')'))
 647                         goto error;
 648         } else {
 649                 op = read_prefix_un_op_if_available(s);
 650                 if (op)
 651                         return read_un_op_expr(s, table, op);
 652
 653                 name = isl_stream_read_ident_if_available(s);
 654                 if (name) {
 655                         obj = stored_obj(s->ctx, table, name);
 656                 } else {
 657                         obj = isl_stream_read_obj(s);
 658                         assert(obj.v);
 659                 }
 660         }
 661
 662         if (isl_stream_eat_if_available(s, '^'))
 663                 obj = power(s, obj);
 664         else if (obj.type == isl_obj_list && isl_stream_eat_if_available(s, '['))
 665                 obj = obj_at_index(s, obj);
 666
 667         return obj;
 668 error:
 669         free_obj(obj);
 670         obj.type = isl_obj_none;
 671         obj.v = NULL;
 672         return obj;
 673 }
 674
 675 static struct isc_bin_op *find_matching_bin_op(struct isc_bin_op *like,
 676         isl_obj_type lhs, isl_obj_type rhs)
 677 {
 678         int i;
 679
 680         for (i = 0; ; ++i) {
 681                 if (!bin_ops[i].op)
 682                         break;
 683                 if (bin_ops[i].op != like->op)
 684                         continue;
 685                 if (bin_ops[i].lhs != lhs)
 686                         continue;
 687                 if (bin_ops[i].rhs != rhs)
 688                         continue;
 689
 690                 return &bin_ops[i];
 691         }
 692
 693         return NULL;
 694 }
 695
 696 static struct isl_obj read_expr(struct isl_stream *s,
 697         struct isl_hash_table *table)
 698 {
 699         struct isl_obj obj = { isl_obj_none, NULL };
 700         struct isl_obj right_obj = { isl_obj_none, NULL };
 701
 702         obj = read_obj(s, table);
 703         for (;;) {
 704                 struct isc_bin_op *op = NULL;
 705
 706                 op = read_bin_op_if_available(s, obj.type);
 707                 if (!op)
 708                         break;
 709
 710                 right_obj = read_obj(s, table);
 711
 712                 op = find_matching_bin_op(op, obj.type, right_obj.type);
 713
 714                 isl_assert(s->ctx, op, goto error);
 715                 obj.v = op->fn(obj.v, right_obj.v);
 716                 obj.type = op->res;
 717         }
 718
 719         return obj;
 720 error:
 721         free_obj(right_obj);
 722         free_obj(obj);
 723         obj.type = isl_obj_none;
 724         obj.v = NULL;
 725         return obj;
 726 }
 727
 728 static __isl_give isl_printer *read_line(struct isl_stream *s,
 729         struct isl_hash_table *table, __isl_take isl_printer *p)
 730 {
 731         struct isl_obj obj = { isl_obj_none, NULL };
 732         char *lhs = NULL;
 733         int assign = 0;
 734         struct isc_bin_op *op = NULL;
 735
 736         if (!p)
 737                 return NULL;
 738         if (isl_stream_is_empty(s))
 739                 return p;
 740
 741         assign = is_assign(s);
 742         if (assign) {
 743                 lhs = isl_stream_read_ident_if_available(s);
 744                 if (isl_stream_eat(s, ISL_TOKEN_DEF))
 745                         goto error;
 746         }
 747
 748         obj = read_expr(s, table);
 749         if (obj.type == isl_obj_none || obj.v == NULL)
 750                 goto error;
 751         if (isl_stream_eat(s, ';'))
 752                 goto error;
 753
 754         if (assign) {
 755                 if (do_assign(s->ctx, table, lhs, obj))
 756                         return;
 757         } else {
 758                 p = obj.type->print(p, obj.v);
 759                 p = isl_printer_end_line(p);
 760                 free_obj(obj);
 761         }
 762
 763         return p;
 764 error:
 765         free(lhs);
 766         free_obj(obj);
 767         return p;
 768 }
 769
 770 int free_cb(void *entry)
 771 {
 772         struct isl_named_obj *named = entry;
 773
 774         free_obj(named->obj);
 775         free(named->name);
 776         free(named);
 777
 778         return 0;
 779 }
 780
 781 static void register_named_ops(struct isl_stream *s)
 782 {
 783         int i;
 784
 785         for (i = 0; ; ++i) {
 786                 if (!named_un_ops[i].name)
 787                         break;
 788                 named_un_ops[i].op.op = isl_stream_register_keyword(s,
 789                                                         named_un_ops[i].name);
 790                 assert(named_un_ops[i].op.op != ISL_TOKEN_ERROR);
 791         }
 792 }
 793
 794 int main(int argc, char **argv)
 795 {
 796         struct isl_ctx *ctx;
 797         struct isl_stream *s;
 798         struct isl_hash_table *table;
 799         isl_printer *p;
 800
 801         ctx = isl_ctx_alloc();
 802         s = isl_stream_new_file(ctx, stdin);
 803         assert(s);
 804         table = isl_hash_table_alloc(ctx, 10);
 805         assert(table);
 806         p = isl_printer_to_file(ctx, stdout);
 807         assert(p);
 808
 809         register_named_ops(s);
 810
 811         while (!feof(stdin)) {
 812                 p = read_line(s, table, p);
 813         }
 814
 815         isl_printer_free(p);
 816         isl_hash_table_foreach(ctx, table, free_cb);
 817         isl_hash_table_free(ctx, table);
 818         isl_stream_free(s);
 819         isl_ctx_free(ctx);
 820
 821         return 0;
 822 }