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