parse.c

   1 /*
   2  * Copyright 2011      Leiden University. All rights reserved.
   3  * Copyright 2013-2014 Ecole Normale Superieure. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  *    1. Redistributions of source code must retain the above copyright
  10  *       notice, this list of conditions and the following disclaimer.
  11  *
  12  *    2. Redistributions in binary form must reproduce the above
  13  *       copyright notice, this list of conditions and the following
  14  *       disclaimer in the documentation and/or other materials provided
  15  *       with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY LEIDEN UNIVERSITY ''AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LEIDEN UNIVERSITY OR
  21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  24  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * The views and conclusions contained in the software and documentation
  30  * are those of the authors and should not be interpreted as
  31  * representing official policies, either expressed or implied, of
  32  * Leiden University.
  33  */
  34
  35 #include <stdlib.h>
  36 #include <yaml.h>
  37
  38 #include <isl/union_set.h>
  39
  40 #include "expr.h"
  41 #include "loc.h"
  42 #include "scop.h"
  43 #include "scop_yaml.h"
  44 #include "tree.h"
  45
  46 static char *extract_string(isl_ctx *ctx, yaml_document_t *document,
  47         yaml_node_t *node)
  48 {
  49         if (node->type != YAML_SCALAR_NODE)
  50                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  51                         return NULL);
  52
  53         return strdup((char *) node->data.scalar.value);
  54 }
  55
  56 static int extract_int(isl_ctx *ctx, yaml_document_t *document,
  57         yaml_node_t *node)
  58 {
  59         if (node->type != YAML_SCALAR_NODE)
  60                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  61                         return -1);
  62
  63         return atoi((char *) node->data.scalar.value);
  64 }
  65
  66 static double extract_double(isl_ctx *ctx, yaml_document_t *document,
  67         yaml_node_t *node)
  68 {
  69         if (node->type != YAML_SCALAR_NODE)
  70                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  71                         return -1);
  72
  73         return strtod((char *) node->data.scalar.value, NULL);
  74 }
  75
  76 static enum pet_expr_type extract_expr_type(isl_ctx *ctx,
  77         yaml_document_t *document, yaml_node_t *node)
  78 {
  79         if (node->type != YAML_SCALAR_NODE)
  80                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  81                         return -1);
  82
  83         return pet_str_type((char *) node->data.scalar.value);
  84 }
  85
  86 static enum pet_op_type extract_op(isl_ctx *ctx, yaml_document_t *document,
  87         yaml_node_t *node)
  88 {
  89         if (node->type != YAML_SCALAR_NODE)
  90                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  91                         return -1);
  92
  93         return pet_str_op((char *) node->data.scalar.value);
  94 }
  95
  96 static __isl_give isl_set *extract_set(isl_ctx *ctx, yaml_document_t *document,
  97         yaml_node_t *node)
  98 {
  99         if (node->type != YAML_SCALAR_NODE)
 100                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 101                         return NULL);
 102
 103         return isl_set_read_from_str(ctx, (char *) node->data.scalar.value);
 104 }
 105
 106 static __isl_give isl_id *extract_id(isl_ctx *ctx, yaml_document_t *document,
 107         yaml_node_t *node)
 108 {
 109         if (node->type != YAML_SCALAR_NODE)
 110                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 111                         return NULL);
 112
 113         return isl_id_alloc(ctx, (char *) node->data.scalar.value, NULL);
 114 }
 115
 116 static __isl_give isl_map *extract_map(isl_ctx *ctx, yaml_document_t *document,
 117         yaml_node_t *node)
 118 {
 119         if (node->type != YAML_SCALAR_NODE)
 120                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 121                         return NULL);
 122
 123         return isl_map_read_from_str(ctx, (char *) node->data.scalar.value);
 124 }
 125
 126 /* Extract an isl_union_set from "node".
 127  */
 128 static __isl_give isl_union_set *extract_union_set(isl_ctx *ctx,
 129         yaml_document_t *document, yaml_node_t *node)
 130 {
 131         if (node->type != YAML_SCALAR_NODE)
 132                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 133                         return NULL);
 134
 135         return isl_union_set_read_from_str(ctx,
 136                                             (char *) node->data.scalar.value);
 137 }
 138
 139 /* Extract an isl_union_map from "node".
 140  */
 141 static __isl_give isl_union_map *extract_union_map(isl_ctx *ctx,
 142         yaml_document_t *document, yaml_node_t *node)
 143 {
 144         if (node->type != YAML_SCALAR_NODE)
 145                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 146                         return NULL);
 147
 148         return isl_union_map_read_from_str(ctx,
 149                                             (char *) node->data.scalar.value);
 150 }
 151
 152 /* Extract an isl_val from "node".
 153  */
 154 static __isl_give isl_val *extract_val(isl_ctx *ctx, yaml_document_t *document,
 155         yaml_node_t *node)
 156 {
 157         if (node->type != YAML_SCALAR_NODE)
 158                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 159                         return NULL);
 160
 161         return isl_val_read_from_str(ctx, (char *) node->data.scalar.value);
 162 }
 163
 164 /* Extract an isl_multi_pw_aff from "node".
 165  */
 166 static __isl_give isl_multi_pw_aff *extract_multi_pw_aff(isl_ctx *ctx,
 167         yaml_document_t *document, yaml_node_t *node)
 168 {
 169         if (node->type != YAML_SCALAR_NODE)
 170                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 171                         return NULL);
 172
 173         return isl_multi_pw_aff_read_from_str(ctx,
 174                                             (char *) node->data.scalar.value);
 175 }
 176
 177 /* Extract an isl_schedule from "node".
 178  */
 179 static __isl_give isl_schedule *extract_schedule(isl_ctx *ctx,
 180         yaml_document_t *document, yaml_node_t *node)
 181 {
 182         if (node->type != YAML_SCALAR_NODE)
 183                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 184                         return NULL);
 185
 186         return isl_schedule_read_from_str(ctx,
 187                                             (char *) node->data.scalar.value);
 188 }
 189
 190 /* Extract a pet_type from "node".
 191  */
 192 static struct pet_type *extract_type(isl_ctx *ctx,
 193         yaml_document_t *document, yaml_node_t *node)
 194 {
 195         struct pet_type *type;
 196         yaml_node_pair_t * pair;
 197
 198         if (node->type != YAML_MAPPING_NODE)
 199                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 200                         return NULL);
 201
 202         type = isl_calloc_type(ctx, struct pet_type);
 203         if (!type)
 204                 return NULL;
 205
 206         for (pair = node->data.mapping.pairs.start;
 207              pair < node->data.mapping.pairs.top; ++pair) {
 208                 yaml_node_t *key, *value;
 209
 210                 key = yaml_document_get_node(document, pair->key);
 211                 value = yaml_document_get_node(document, pair->value);
 212
 213                 if (key->type != YAML_SCALAR_NODE)
 214                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 215                                 return pet_type_free(type));
 216
 217                 if (!strcmp((char *) key->data.scalar.value, "name"))
 218                         type->name = extract_string(ctx, document, value);
 219                 if (!strcmp((char *) key->data.scalar.value, "definition"))
 220                         type->definition = extract_string(ctx, document, value);
 221         }
 222
 223         return type;
 224 }
 225
 226 /* Extract a sequence of types from "node" and store them in scop->types.
 227  */
 228 static struct pet_scop *extract_types(isl_ctx *ctx,
 229         yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
 230 {
 231         int i;
 232         yaml_node_item_t *item;
 233
 234         if (node->type != YAML_SEQUENCE_NODE)
 235                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 236                         return NULL);
 237
 238         scop->n_type = node->data.sequence.items.top
 239                                 - node->data.sequence.items.start;
 240         scop->types = isl_calloc_array(ctx, struct pet_type *, scop->n_type);
 241         if (!scop->types)
 242                 return pet_scop_free(scop);
 243
 244         for (item = node->data.sequence.items.start, i = 0;
 245              item < node->data.sequence.items.top; ++item, ++i) {
 246                 yaml_node_t *n;
 247
 248                 n = yaml_document_get_node(document, *item);
 249                 scop->types[i] = extract_type(ctx, document, n);
 250                 if (!scop->types[i])
 251                         return pet_scop_free(scop);
 252         }
 253
 254         return scop;
 255 }
 256
 257 static struct pet_array *extract_array(isl_ctx *ctx, yaml_document_t *document,
 258         yaml_node_t *node)
 259 {
 260         struct pet_array *array;
 261         yaml_node_pair_t * pair;
 262
 263         if (node->type != YAML_MAPPING_NODE)
 264                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 265                         return NULL);
 266
 267         array = isl_calloc_type(ctx, struct pet_array);
 268         if (!array)
 269                 return NULL;
 270
 271         for (pair = node->data.mapping.pairs.start;
 272              pair < node->data.mapping.pairs.top; ++pair) {
 273                 yaml_node_t *key, *value;
 274
 275                 key = yaml_document_get_node(document, pair->key);
 276                 value = yaml_document_get_node(document, pair->value);
 277
 278                 if (key->type != YAML_SCALAR_NODE)
 279                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 280                                 return pet_array_free(array));
 281
 282                 if (!strcmp((char *) key->data.scalar.value, "context"))
 283                         array->context = extract_set(ctx, document, value);
 284                 if (!strcmp((char *) key->data.scalar.value, "extent"))
 285                         array->extent = extract_set(ctx, document, value);
 286                 if (!strcmp((char *) key->data.scalar.value, "value_bounds"))
 287                         array->value_bounds = extract_set(ctx, document, value);
 288                 if (!strcmp((char *) key->data.scalar.value, "element_type"))
 289                         array->element_type =
 290                                         extract_string(ctx, document, value);
 291                 if (!strcmp((char *) key->data.scalar.value, "element_size"))
 292                         array->element_size = extract_int(ctx, document, value);
 293                 if (!strcmp((char *) key->data.scalar.value,
 294                                 "element_is_record"))
 295                         array->element_is_record =
 296                                         extract_int(ctx, document, value);
 297                 if (!strcmp((char *) key->data.scalar.value, "live_out"))
 298                         array->live_out = extract_int(ctx, document, value);
 299                 if (!strcmp((char *) key->data.scalar.value,
 300                                 "uniquely_defined"))
 301                         array->uniquely_defined =
 302                                         extract_int(ctx, document, value);
 303                 if (!strcmp((char *) key->data.scalar.value, "declared"))
 304                         array->declared = extract_int(ctx, document, value);
 305                 if (!strcmp((char *) key->data.scalar.value, "exposed"))
 306                         array->exposed = extract_int(ctx, document, value);
 307         }
 308
 309         return array;
 310 }
 311
 312 static struct pet_scop *extract_arrays(isl_ctx *ctx, yaml_document_t *document,
 313         yaml_node_t *node, struct pet_scop *scop)
 314 {
 315         int i;
 316         yaml_node_item_t *item;
 317
 318         if (node->type != YAML_SEQUENCE_NODE)
 319                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 320                         return NULL);
 321
 322         scop->n_array = node->data.sequence.items.top
 323                                 - node->data.sequence.items.start;
 324         scop->arrays = isl_calloc_array(ctx, struct pet_array *, scop->n_array);
 325         if (!scop->arrays)
 326                 return pet_scop_free(scop);
 327
 328         for (item = node->data.sequence.items.start, i = 0;
 329              item < node->data.sequence.items.top; ++item, ++i) {
 330                 yaml_node_t *n;
 331
 332                 n = yaml_document_get_node(document, *item);
 333                 scop->arrays[i] = extract_array(ctx, document, n);
 334                 if (!scop->arrays[i])
 335                         return pet_scop_free(scop);
 336         }
 337
 338         return scop;
 339 }
 340
 341 static __isl_give pet_expr *extract_expr(isl_ctx *ctx,
 342         yaml_document_t *document, yaml_node_t *node);
 343
 344 static __isl_give pet_expr *extract_arguments(isl_ctx *ctx,
 345         yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
 346 {
 347         int i, n;
 348         yaml_node_item_t *item;
 349
 350         if (node->type != YAML_SEQUENCE_NODE)
 351                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 352                         return pet_expr_free(expr));
 353
 354         n = node->data.sequence.items.top - node->data.sequence.items.start;
 355         expr = pet_expr_set_n_arg(expr, n);
 356
 357         for (item = node->data.sequence.items.start, i = 0;
 358              item < node->data.sequence.items.top; ++item, ++i) {
 359                 yaml_node_t *n;
 360                 pet_expr *arg;
 361
 362                 n = yaml_document_get_node(document, *item);
 363                 arg = extract_expr(ctx, document, n);
 364                 expr = pet_expr_set_arg(expr, i, arg);
 365         }
 366
 367         return expr;
 368 }
 369
 370 /* Extract pet_expr_double specific fields from "node" and
 371  * update "expr" accordingly.
 372  */
 373 static __isl_give pet_expr *extract_expr_double(isl_ctx *ctx,
 374         yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
 375 {
 376         yaml_node_pair_t *pair;
 377         double d = 0;
 378         char *s = NULL;
 379
 380         for (pair = node->data.mapping.pairs.start;
 381              pair < node->data.mapping.pairs.top; ++pair) {
 382                 yaml_node_t *key, *value;
 383
 384                 key = yaml_document_get_node(document, pair->key);
 385                 value = yaml_document_get_node(document, pair->value);
 386
 387                 if (key->type != YAML_SCALAR_NODE)
 388                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 389                                 return pet_expr_free(expr));
 390
 391                 if (!strcmp((char *) key->data.scalar.value, "value"))
 392                         d = extract_double(ctx, document, value);
 393                 if (!strcmp((char *) key->data.scalar.value, "string"))
 394                         s = extract_string(ctx, document, value);
 395         }
 396
 397         expr = pet_expr_double_set(expr, d, s);
 398         free(s);
 399
 400         return expr;
 401 }
 402
 403 /* Extract pet_expr_access specific fields from "node" and
 404  * update "expr" accordingly.
 405  *
 406  * The depth of the access is initialized by pet_expr_access_set_index.
 407  * Any explicitly specified depth therefore needs to be set after
 408  * setting the index expression.  Similiarly, the access relations (if any)
 409  * need to be set after setting the depth.
 410  */
 411 static __isl_give pet_expr *extract_expr_access(isl_ctx *ctx,
 412         yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
 413 {
 414         yaml_node_pair_t *pair;
 415         int depth = -1;
 416         isl_multi_pw_aff *index = NULL;
 417
 418         for (pair = node->data.mapping.pairs.start;
 419              pair < node->data.mapping.pairs.top; ++pair) {
 420                 yaml_node_t *key, *value;
 421
 422                 key = yaml_document_get_node(document, pair->key);
 423                 value = yaml_document_get_node(document, pair->value);
 424
 425                 if (key->type != YAML_SCALAR_NODE)
 426                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 427                                 return pet_expr_free(expr));
 428
 429                 if (!strcmp((char *) key->data.scalar.value, "index"))
 430                         index = extract_multi_pw_aff(ctx, document, value);
 431                 if (!strcmp((char *) key->data.scalar.value, "depth"))
 432                         depth = extract_int(ctx, document, value);
 433         }
 434
 435         expr = pet_expr_access_set_index(expr, index);
 436         if (depth >= 0)
 437                 expr = pet_expr_access_set_depth(expr, depth);
 438
 439         for (pair = node->data.mapping.pairs.start;
 440              pair < node->data.mapping.pairs.top; ++pair) {
 441                 yaml_node_t *key, *value;
 442
 443                 key = yaml_document_get_node(document, pair->key);
 444                 value = yaml_document_get_node(document, pair->value);
 445
 446                 if (key->type != YAML_SCALAR_NODE)
 447                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 448                                 return pet_expr_free(expr));
 449
 450                 if (!strcmp((char *) key->data.scalar.value, "may_read"))
 451                         expr = pet_expr_access_set_access(expr,
 452                                     pet_expr_access_may_read,
 453                                     extract_union_map(ctx, document, value));
 454                 if (!strcmp((char *) key->data.scalar.value, "may_write"))
 455                         expr = pet_expr_access_set_access(expr,
 456                                     pet_expr_access_may_write,
 457                                     extract_union_map(ctx, document, value));
 458                 if (!strcmp((char *) key->data.scalar.value, "must_write"))
 459                         expr = pet_expr_access_set_access(expr,
 460                                     pet_expr_access_must_write,
 461                                     extract_union_map(ctx, document, value));
 462                 if (!strcmp((char *) key->data.scalar.value, "killed"))
 463                         expr = pet_expr_access_set_access(expr,
 464                                     pet_expr_access_killed,
 465                                     extract_union_map(ctx, document, value));
 466                 if (!strcmp((char *) key->data.scalar.value, "reference"))
 467                         expr = pet_expr_access_set_ref_id(expr,
 468                                     extract_id(ctx, document, value));
 469                 if (!strcmp((char *) key->data.scalar.value, "read"))
 470                         expr = pet_expr_access_set_read(expr,
 471                                     extract_int(ctx, document, value));
 472                 if (!strcmp((char *) key->data.scalar.value, "write"))
 473                         expr = pet_expr_access_set_write(expr,
 474                                     extract_int(ctx, document, value));
 475                 if (!strcmp((char *) key->data.scalar.value, "kill"))
 476                         expr = pet_expr_access_set_kill(expr,
 477                                     extract_int(ctx, document, value));
 478         }
 479
 480         return expr;
 481 }
 482
 483 /* Extract operation expression specific fields from "node" and
 484  * update "expr" accordingly.
 485  */
 486 static __isl_give pet_expr *extract_expr_op(isl_ctx *ctx,
 487         yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
 488 {
 489         yaml_node_pair_t *pair;
 490
 491         for (pair = node->data.mapping.pairs.start;
 492              pair < node->data.mapping.pairs.top; ++pair) {
 493                 yaml_node_t *key, *value;
 494
 495                 key = yaml_document_get_node(document, pair->key);
 496                 value = yaml_document_get_node(document, pair->value);
 497
 498                 if (key->type != YAML_SCALAR_NODE)
 499                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 500                                 return pet_expr_free(expr));
 501
 502                 if (!strcmp((char *) key->data.scalar.value, "operation"))
 503                         expr = pet_expr_op_set_type(expr,
 504                                             extract_op(ctx, document, value));
 505         }
 506
 507         return expr;
 508 }
 509
 510 /* Extract pet_expr_call specific fields from "node" and
 511  * update "expr" accordingly.
 512  */
 513 static __isl_give pet_expr *extract_expr_call(isl_ctx *ctx,
 514         yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
 515 {
 516         yaml_node_pair_t *pair;
 517
 518         for (pair = node->data.mapping.pairs.start;
 519              pair < node->data.mapping.pairs.top; ++pair) {
 520                 yaml_node_t *key, *value;
 521
 522                 key = yaml_document_get_node(document, pair->key);
 523                 value = yaml_document_get_node(document, pair->value);
 524
 525                 if (key->type != YAML_SCALAR_NODE)
 526                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 527                                 return pet_expr_free(expr));
 528
 529                 if (!strcmp((char *) key->data.scalar.value, "name"))
 530                         expr = pet_expr_call_set_name(expr,
 531                                         extract_string(ctx, document, value));
 532         }
 533
 534         return expr;
 535 }
 536
 537 /* Extract pet_expr_cast specific fields from "node" and
 538  * update "expr" accordingly.
 539  */
 540 static __isl_give pet_expr *extract_expr_cast(isl_ctx *ctx,
 541         yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
 542 {
 543         yaml_node_pair_t *pair;
 544
 545         for (pair = node->data.mapping.pairs.start;
 546              pair < node->data.mapping.pairs.top; ++pair) {
 547                 yaml_node_t *key, *value;
 548
 549                 key = yaml_document_get_node(document, pair->key);
 550                 value = yaml_document_get_node(document, pair->value);
 551
 552                 if (key->type != YAML_SCALAR_NODE)
 553                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 554                                 return pet_expr_free(expr));
 555
 556                 if (!strcmp((char *) key->data.scalar.value, "type_name"))
 557                         expr = pet_expr_cast_set_type_name(expr,
 558                                         extract_string(ctx, document, value));
 559         }
 560
 561         return expr;
 562 }
 563
 564 /* Extract pet_expr_int specific fields from "node" and
 565  * update "expr" accordingly.
 566  */
 567 static __isl_give pet_expr *extract_expr_int(isl_ctx *ctx,
 568         yaml_document_t *document, yaml_node_t *node, __isl_take pet_expr *expr)
 569 {
 570         yaml_node_pair_t * pair;
 571
 572         for (pair = node->data.mapping.pairs.start;
 573              pair < node->data.mapping.pairs.top; ++pair) {
 574                 yaml_node_t *key, *value;
 575
 576                 key = yaml_document_get_node(document, pair->key);
 577                 value = yaml_document_get_node(document, pair->value);
 578
 579                 if (key->type != YAML_SCALAR_NODE)
 580                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 581                                 return pet_expr_free(expr));
 582
 583                 if (!strcmp((char *) key->data.scalar.value, "value"))
 584                         expr = pet_expr_int_set_val(expr,
 585                                             extract_val(ctx, document, value));
 586         }
 587
 588         return expr;
 589 }
 590
 591 /* Extract a pet_expr from "node".
 592  *
 593  * We first extract the type and arguments of the expression and
 594  * then extract additional fields depending on the type.
 595  */
 596 static __isl_give pet_expr *extract_expr(isl_ctx *ctx,
 597         yaml_document_t *document, yaml_node_t *node)
 598 {
 599         enum pet_expr_type type = pet_expr_error;
 600         pet_expr *expr;
 601         yaml_node_pair_t *pair;
 602
 603         if (node->type != YAML_MAPPING_NODE)
 604                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 605                         return NULL);
 606
 607         for (pair = node->data.mapping.pairs.start;
 608              pair < node->data.mapping.pairs.top; ++pair) {
 609                 yaml_node_t *key, *value;
 610
 611                 key = yaml_document_get_node(document, pair->key);
 612                 value = yaml_document_get_node(document, pair->value);
 613
 614                 if (key->type != YAML_SCALAR_NODE)
 615                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 616                                 return pet_expr_free(expr));
 617
 618                 if (!strcmp((char *) key->data.scalar.value, "type"))
 619                         type = extract_expr_type(ctx, document, value);
 620         }
 621
 622         if (type == pet_expr_error)
 623                 isl_die(ctx, isl_error_invalid, "cannot determine type",
 624                         return NULL);
 625
 626         expr = pet_expr_alloc(ctx, type);
 627         if (!expr)
 628                 return NULL;
 629
 630         for (pair = node->data.mapping.pairs.start;
 631              pair < node->data.mapping.pairs.top; ++pair) {
 632                 yaml_node_t *key, *value;
 633
 634                 key = yaml_document_get_node(document, pair->key);
 635                 value = yaml_document_get_node(document, pair->value);
 636
 637                 if (!strcmp((char *) key->data.scalar.value, "arguments"))
 638                         expr = extract_arguments(ctx, document, value, expr);
 639                 if (!expr)
 640                         return NULL;
 641         }
 642
 643         switch (type) {
 644         case pet_expr_error:
 645                 isl_die(ctx, isl_error_internal, "unreachable code",
 646                         return NULL);
 647         case pet_expr_access:
 648                 expr = extract_expr_access(ctx, document, node, expr);
 649                 break;
 650         case pet_expr_double:
 651                 expr = extract_expr_double(ctx, document, node, expr);
 652                 break;
 653         case pet_expr_call:
 654                 expr = extract_expr_call(ctx, document, node, expr);
 655                 break;
 656         case pet_expr_cast:
 657                 expr = extract_expr_cast(ctx, document, node, expr);
 658                 break;
 659         case pet_expr_int:
 660                 expr = extract_expr_int(ctx, document, node, expr);
 661                 break;
 662         case pet_expr_op:
 663                 expr = extract_expr_op(ctx, document, node, expr);
 664                 break;
 665         }
 666
 667         return expr;
 668 }
 669
 670 /* Extract a pet_tree_type from "node".
 671  */
 672 static enum pet_tree_type extract_tree_type(isl_ctx *ctx,
 673         yaml_document_t *document, yaml_node_t *node)
 674 {
 675         if (node->type != YAML_SCALAR_NODE)
 676                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 677                         return -1);
 678
 679         return pet_tree_str_type((char *) node->data.scalar.value);
 680 }
 681
 682 static __isl_give pet_tree *extract_tree(isl_ctx *ctx,
 683         yaml_document_t *document, yaml_node_t *node);
 684
 685 /* Extract a pet_tree of type pet_tree_block from "node".
 686  */
 687 static __isl_give pet_tree *extract_tree_block(isl_ctx *ctx,
 688         yaml_document_t *document, yaml_node_t *node)
 689 {
 690         int block = 0;
 691         int i, n;
 692         yaml_node_pair_t *pair;
 693         yaml_node_item_t *item;
 694         yaml_node_t *children = NULL;
 695         pet_tree *tree;
 696
 697         for (pair = node->data.mapping.pairs.start;
 698              pair < node->data.mapping.pairs.top; ++pair) {
 699                 yaml_node_t *key, *value;
 700
 701                 key = yaml_document_get_node(document, pair->key);
 702                 value = yaml_document_get_node(document, pair->value);
 703
 704                 if (key->type != YAML_SCALAR_NODE)
 705                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 706                                 return NULL);
 707
 708                 if (!strcmp((char *) key->data.scalar.value, "block"))
 709                         block = extract_int(ctx, document, value);
 710                 if (!strcmp((char *) key->data.scalar.value, "children"))
 711                         children = value;
 712         }
 713
 714         if (!children)
 715                 n = 0;
 716         else
 717                 n = children->data.sequence.items.top -
 718                                             children->data.sequence.items.start;
 719
 720         tree = pet_tree_new_block(ctx, block, n);
 721         if (!children)
 722                 return tree;
 723
 724         for (item = children->data.sequence.items.start, i = 0;
 725              item < children->data.sequence.items.top; ++item, ++i) {
 726                 yaml_node_t *n;
 727                 pet_tree *child;
 728
 729                 n = yaml_document_get_node(document, *item);
 730                 child = extract_tree(ctx, document, n);
 731                 tree = pet_tree_block_add_child(tree, child);
 732         }
 733
 734         return tree;
 735 }
 736
 737 /* Extract a pet_tree of type pet_tree_decl from "node".
 738  */
 739 static __isl_give pet_tree *extract_tree_decl(isl_ctx *ctx,
 740         yaml_document_t *document, yaml_node_t *node)
 741 {
 742         yaml_node_pair_t *pair;
 743         pet_expr *var = NULL;
 744
 745         for (pair = node->data.mapping.pairs.start;
 746              pair < node->data.mapping.pairs.top; ++pair) {
 747                 yaml_node_t *key, *value;
 748
 749                 key = yaml_document_get_node(document, pair->key);
 750                 value = yaml_document_get_node(document, pair->value);
 751
 752                 if (key->type != YAML_SCALAR_NODE)
 753                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 754                                 return NULL);
 755
 756                 if (!strcmp((char *) key->data.scalar.value, "variable")) {
 757                         var = extract_expr(ctx, document, value);
 758                         if (!var)
 759                                 return NULL;
 760                 }
 761         }
 762
 763         if (!var)
 764                 isl_die(ctx, isl_error_invalid,
 765                         "no variable field", return NULL);
 766
 767         return pet_tree_new_decl(var);
 768 }
 769
 770 /* Extract a pet_tree of type pet_tree_decl_init from "node".
 771  */
 772 static __isl_give pet_tree *extract_tree_decl_init(isl_ctx *ctx,
 773         yaml_document_t *document, yaml_node_t *node)
 774 {
 775         yaml_node_pair_t *pair;
 776         pet_expr *var = NULL;
 777         pet_expr *init = NULL;
 778
 779         for (pair = node->data.mapping.pairs.start;
 780              pair < node->data.mapping.pairs.top; ++pair) {
 781                 yaml_node_t *key, *value;
 782
 783                 key = yaml_document_get_node(document, pair->key);
 784                 value = yaml_document_get_node(document, pair->value);
 785
 786                 if (key->type != YAML_SCALAR_NODE)
 787                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 788                                 return NULL);
 789
 790                 if (!strcmp((char *) key->data.scalar.value, "variable")) {
 791                         var = extract_expr(ctx, document, value);
 792                         if (!var)
 793                                 goto error;
 794                 }
 795                 if (!strcmp((char *) key->data.scalar.value,
 796                                                         "initialization")) {
 797                         init = extract_expr(ctx, document, value);
 798                         if (!init)
 799                                 goto error;
 800                 }
 801         }
 802
 803         if (!var)
 804                 isl_die(ctx, isl_error_invalid,
 805                         "no variable field", goto error);
 806         if (!init)
 807                 isl_die(ctx, isl_error_invalid,
 808                         "no initialization field", goto error);
 809
 810         return pet_tree_new_decl_init(var, init);
 811 error:
 812         pet_expr_free(var);
 813         pet_expr_free(init);
 814         return NULL;
 815 }
 816
 817 /* Extract a pet_tree of type pet_tree_expr from "node".
 818  */
 819 static __isl_give pet_tree *extract_tree_expr(isl_ctx *ctx,
 820         yaml_document_t *document, yaml_node_t *node)
 821 {
 822         yaml_node_pair_t *pair;
 823         pet_expr *expr = NULL;
 824
 825         for (pair = node->data.mapping.pairs.start;
 826              pair < node->data.mapping.pairs.top; ++pair) {
 827                 yaml_node_t *key, *value;
 828
 829                 key = yaml_document_get_node(document, pair->key);
 830                 value = yaml_document_get_node(document, pair->value);
 831
 832                 if (key->type != YAML_SCALAR_NODE)
 833                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 834                                 return NULL);
 835
 836                 if (!strcmp((char *) key->data.scalar.value, "expr")) {
 837                         expr = extract_expr(ctx, document, value);
 838                         if (!expr)
 839                                 return NULL;
 840                 }
 841         }
 842
 843         if (!expr)
 844                 isl_die(ctx, isl_error_invalid,
 845                         "no expr field", return NULL);
 846
 847         return pet_tree_new_expr(expr);
 848 }
 849
 850 /* Extract a pet_tree of type pet_tree_while from "node".
 851  */
 852 static __isl_give pet_tree *extract_tree_while(isl_ctx *ctx,
 853         yaml_document_t *document, yaml_node_t *node)
 854 {
 855         yaml_node_pair_t *pair;
 856         pet_expr *cond = NULL;
 857         pet_tree *body = NULL;
 858
 859         for (pair = node->data.mapping.pairs.start;
 860              pair < node->data.mapping.pairs.top; ++pair) {
 861                 yaml_node_t *key, *value;
 862
 863                 key = yaml_document_get_node(document, pair->key);
 864                 value = yaml_document_get_node(document, pair->value);
 865
 866                 if (key->type != YAML_SCALAR_NODE)
 867                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 868                                 return NULL);
 869
 870                 if (!strcmp((char *) key->data.scalar.value, "condition")) {
 871                         cond = extract_expr(ctx, document, value);
 872                         if (!cond)
 873                                 goto error;
 874                 }
 875                 if (!strcmp((char *) key->data.scalar.value, "body")) {
 876                         body = extract_tree(ctx, document, value);
 877                         if (!body)
 878                                 goto error;
 879                 }
 880         }
 881
 882         if (!cond)
 883                 isl_die(ctx, isl_error_invalid,
 884                         "no condition field", goto error);
 885         if (!body)
 886                 isl_die(ctx, isl_error_invalid,
 887                         "no body field", goto error);
 888
 889         return pet_tree_new_while(cond, body);
 890 error:
 891         pet_expr_free(cond);
 892         pet_tree_free(body);
 893         return NULL;
 894 }
 895
 896 /* Extract a pet_tree of type pet_tree_infinite_loop from "node".
 897  */
 898 static __isl_give pet_tree *extract_tree_infinite_loop(isl_ctx *ctx,
 899         yaml_document_t *document, yaml_node_t *node)
 900 {
 901         yaml_node_pair_t *pair;
 902         pet_tree *body;
 903
 904         for (pair = node->data.mapping.pairs.start;
 905              pair < node->data.mapping.pairs.top; ++pair) {
 906                 yaml_node_t *key, *value;
 907
 908                 key = yaml_document_get_node(document, pair->key);
 909                 value = yaml_document_get_node(document, pair->value);
 910
 911                 if (key->type != YAML_SCALAR_NODE)
 912                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 913                                 return NULL);
 914
 915                 if (!strcmp((char *) key->data.scalar.value, "body")) {
 916                         body = extract_tree(ctx, document, value);
 917                         if (!body)
 918                                 return NULL;
 919                 }
 920         }
 921
 922         if (!body)
 923                 isl_die(ctx, isl_error_invalid,
 924                         "no body field", return NULL);
 925
 926         return pet_tree_new_infinite_loop(body);
 927 }
 928
 929 /* Extract a pet_tree of type pet_tree_if from "node".
 930  */
 931 static __isl_give pet_tree *extract_tree_if(isl_ctx *ctx,
 932         yaml_document_t *document, yaml_node_t *node)
 933 {
 934         yaml_node_pair_t *pair;
 935         pet_expr *cond = NULL;
 936         pet_tree *then_body = NULL;
 937
 938         for (pair = node->data.mapping.pairs.start;
 939              pair < node->data.mapping.pairs.top; ++pair) {
 940                 yaml_node_t *key, *value;
 941
 942                 key = yaml_document_get_node(document, pair->key);
 943                 value = yaml_document_get_node(document, pair->value);
 944
 945                 if (key->type != YAML_SCALAR_NODE)
 946                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 947                                 return NULL);
 948
 949                 if (!strcmp((char *) key->data.scalar.value, "condition")) {
 950                         cond = extract_expr(ctx, document, value);
 951                         if (!cond)
 952                                 goto error;
 953                 }
 954                 if (!strcmp((char *) key->data.scalar.value, "then")) {
 955                         then_body = extract_tree(ctx, document, value);
 956                         if (!then_body)
 957                                 goto error;
 958                 }
 959         }
 960
 961         if (!cond)
 962                 isl_die(ctx, isl_error_invalid,
 963                         "no condition field", goto error);
 964         if (!then_body)
 965                 isl_die(ctx, isl_error_invalid,
 966                         "no then body", goto error);
 967
 968         return pet_tree_new_if(cond, then_body);
 969 error:
 970         pet_expr_free(cond);
 971         pet_tree_free(then_body);
 972         return NULL;
 973 }
 974
 975 /* Extract a pet_tree of type pet_tree_if_else from "node".
 976  */
 977 static __isl_give pet_tree *extract_tree_if_else(isl_ctx *ctx,
 978         yaml_document_t *document, yaml_node_t *node)
 979 {
 980         yaml_node_pair_t *pair;
 981         pet_expr *cond = NULL;
 982         pet_tree *then_body = NULL;
 983         pet_tree *else_body = NULL;
 984
 985         for (pair = node->data.mapping.pairs.start;
 986              pair < node->data.mapping.pairs.top; ++pair) {
 987                 yaml_node_t *key, *value;
 988
 989                 key = yaml_document_get_node(document, pair->key);
 990                 value = yaml_document_get_node(document, pair->value);
 991
 992                 if (key->type != YAML_SCALAR_NODE)
 993                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 994                                 return NULL);
 995
 996                 if (!strcmp((char *) key->data.scalar.value, "condition")) {
 997                         cond = extract_expr(ctx, document, value);
 998                         if (!cond)
 999                                 goto error;
1000                 }
1001                 if (!strcmp((char *) key->data.scalar.value, "then")) {
1002                         then_body = extract_tree(ctx, document, value);
1003                         if (!then_body)
1004                                 goto error;
1005                 }
1006                 if (!strcmp((char *) key->data.scalar.value, "else")) {
1007                         else_body = extract_tree(ctx, document, value);
1008                         if (!else_body)
1009                                 goto error;
1010                 }
1011         }
1012
1013         if (!cond)
1014                 isl_die(ctx, isl_error_invalid,
1015                         "no condition field", goto error);
1016         if (!then_body)
1017                 isl_die(ctx, isl_error_invalid,
1018                         "no then body", goto error);
1019         if (!else_body)
1020                 isl_die(ctx, isl_error_invalid,
1021                         "no else body", goto error);
1022
1023         return pet_tree_new_if_else(cond, then_body, else_body);
1024 error:
1025         pet_expr_free(cond);
1026         pet_tree_free(then_body);
1027         pet_tree_free(else_body);
1028         return NULL;
1029 }
1030
1031 /* Extract a pet_tree of type pet_tree_for from "node".
1032  */
1033 static __isl_give pet_tree *extract_tree_for(isl_ctx *ctx,
1034         yaml_document_t *document, yaml_node_t *node)
1035 {
1036         yaml_node_pair_t *pair;
1037         int declared = 0;
1038         int independent = 0;
1039         pet_expr *iv = NULL;
1040         pet_expr *init = NULL;
1041         pet_expr *cond = NULL;
1042         pet_expr *inc = NULL;
1043         pet_tree *body = NULL;
1044
1045         for (pair = node->data.mapping.pairs.start;
1046              pair < node->data.mapping.pairs.top; ++pair) {
1047                 yaml_node_t *key, *value;
1048
1049                 key = yaml_document_get_node(document, pair->key);
1050                 value = yaml_document_get_node(document, pair->value);
1051
1052                 if (key->type != YAML_SCALAR_NODE)
1053                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
1054                                 return NULL);
1055
1056                 if (!strcmp((char *) key->data.scalar.value, "declared"))
1057                         declared = extract_int(ctx, document, value);
1058                 if (!strcmp((char *) key->data.scalar.value, "independent"))
1059                         independent = extract_int(ctx, document, value);
1060                 if (!strcmp((char *) key->data.scalar.value, "variable")) {
1061                         iv = extract_expr(ctx, document, value);
1062                         if (!iv)
1063                                 goto error;
1064                 }
1065                 if (!strcmp((char *) key->data.scalar.value,
1066                                                         "initialization")) {
1067                         init = extract_expr(ctx, document, value);
1068                         if (!init)
1069                                 goto error;
1070                 }
1071                 if (!strcmp((char *) key->data.scalar.value, "condition")) {
1072                         cond = extract_expr(ctx, document, value);
1073                         if (!cond)
1074                                 goto error;
1075                 }
1076                 if (!strcmp((char *) key->data.scalar.value, "increment")) {
1077                         inc = extract_expr(ctx, document, value);
1078                         if (!inc)
1079                                 goto error;
1080                 }
1081                 if (!strcmp((char *) key->data.scalar.value, "body")) {
1082                         body = extract_tree(ctx, document, value);
1083                         if (!body)
1084                                 goto error;
1085                 }
1086         }
1087
1088         if (!iv)
1089                 isl_die(ctx, isl_error_invalid,
1090                         "no variable field", goto error);
1091         if (!init)
1092                 isl_die(ctx, isl_error_invalid,
1093                         "no initialization field", goto error);
1094         if (!cond)
1095                 isl_die(ctx, isl_error_invalid,
1096                         "no condition field", goto error);
1097         if (!inc)
1098                 isl_die(ctx, isl_error_invalid,
1099                         "no increment field", goto error);
1100         if (!body)
1101                 isl_die(ctx, isl_error_invalid,
1102                         "no body field", goto error);
1103
1104         return pet_tree_new_for(independent, declared, iv, init, cond, inc,
1105                                 body);
1106 error:
1107         pet_expr_free(iv);
1108         pet_expr_free(init);
1109         pet_expr_free(cond);
1110         pet_expr_free(inc);
1111         pet_tree_free(body);
1112         return NULL;
1113 }
1114
1115 /* Extract a pet_tree from "node".
1116  *
1117  * We first extract the type of the pet_tree and then call
1118  * the appropriate function to extract and construct a pet_tree
1119  * of that type.
1120  */
1121 static __isl_give pet_tree *extract_tree(isl_ctx *ctx,
1122         yaml_document_t *document, yaml_node_t *node)
1123 {
1124         enum pet_tree_type type = pet_tree_error;
1125         pet_tree *tree;
1126         yaml_node_pair_t *pair;
1127
1128         if (node->type != YAML_MAPPING_NODE)
1129                 isl_die(ctx, isl_error_invalid, "expecting mapping",
1130                         return NULL);
1131
1132         for (pair = node->data.mapping.pairs.start;
1133              pair < node->data.mapping.pairs.top; ++pair) {
1134                 yaml_node_t *key, *value;
1135
1136                 key = yaml_document_get_node(document, pair->key);
1137                 value = yaml_document_get_node(document, pair->value);
1138
1139                 if (key->type != YAML_SCALAR_NODE)
1140                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
1141                                 return pet_tree_free(tree));
1142
1143                 if (!strcmp((char *) key->data.scalar.value, "type"))
1144                         type = extract_tree_type(ctx, document, value);
1145         }
1146
1147         if (type == pet_tree_error)
1148                 isl_die(ctx, isl_error_invalid, "cannot determine type",
1149                         return NULL);
1150
1151         switch (type) {
1152         case pet_tree_error:
1153                 return NULL;
1154         case pet_tree_block:
1155                 tree = extract_tree_block(ctx, document, node);
1156                 break;
1157         case pet_tree_break:
1158                 tree = pet_tree_new_break(ctx);
1159                 break;
1160         case pet_tree_continue:
1161                 tree = pet_tree_new_continue(ctx);
1162                 break;
1163         case pet_tree_decl:
1164                 tree = extract_tree_decl(ctx, document, node);
1165                 break;
1166         case pet_tree_decl_init:
1167                 tree = extract_tree_decl_init(ctx, document, node);
1168                 break;
1169         case pet_tree_expr:
1170                 tree = extract_tree_expr(ctx, document, node);
1171                 break;
1172         case pet_tree_for:
1173                 tree = extract_tree_for(ctx, document, node);
1174                 break;
1175         case pet_tree_while:
1176                 tree = extract_tree_while(ctx, document, node);
1177                 break;
1178         case pet_tree_infinite_loop:
1179                 tree = extract_tree_infinite_loop(ctx, document, node);
1180                 break;
1181         case pet_tree_if:
1182                 tree = extract_tree_if(ctx, document, node);
1183                 break;
1184         case pet_tree_if_else:
1185                 tree = extract_tree_if_else(ctx, document, node);
1186                 break;
1187         }
1188
1189         return tree;
1190 }
1191
1192 static struct pet_stmt *extract_stmt_arguments(isl_ctx *ctx,
1193         yaml_document_t *document, yaml_node_t *node, struct pet_stmt *stmt)
1194 {
1195         int i;
1196         yaml_node_item_t *item;
1197
1198         if (node->type != YAML_SEQUENCE_NODE)
1199                 isl_die(ctx, isl_error_invalid, "expecting sequence",
1200                         return pet_stmt_free(stmt));
1201
1202         stmt->n_arg = node->data.sequence.items.top
1203                                 - node->data.sequence.items.start;
1204         stmt->args = isl_calloc_array(ctx, pet_expr *, stmt->n_arg);
1205         if (!stmt->args)
1206                 return pet_stmt_free(stmt);
1207
1208         for (item = node->data.sequence.items.start, i = 0;
1209              item < node->data.sequence.items.top; ++item, ++i) {
1210                 yaml_node_t *n;
1211
1212                 n = yaml_document_get_node(document, *item);
1213                 stmt->args[i] = extract_expr(ctx, document, n);
1214                 if (!stmt->args[i])
1215                         return pet_stmt_free(stmt);
1216         }
1217
1218         return stmt;
1219 }
1220
1221 static struct pet_stmt *extract_stmt(isl_ctx *ctx, yaml_document_t *document,
1222         yaml_node_t *node)
1223 {
1224         struct pet_stmt *stmt;
1225         yaml_node_pair_t * pair;
1226         int line = -1;
1227         unsigned start = 0, end = 0;
1228         char *indent = NULL;
1229
1230         if (node->type != YAML_MAPPING_NODE)
1231                 isl_die(ctx, isl_error_invalid, "expecting mapping",
1232                         return NULL);
1233
1234         stmt = isl_calloc_type(ctx, struct pet_stmt);
1235         if (!stmt)
1236                 return NULL;
1237
1238         stmt->loc = &pet_loc_dummy;
1239
1240         for (pair = node->data.mapping.pairs.start;
1241              pair < node->data.mapping.pairs.top; ++pair) {
1242                 yaml_node_t *key, *value;
1243
1244                 key = yaml_document_get_node(document, pair->key);
1245                 value = yaml_document_get_node(document, pair->value);
1246
1247                 if (key->type != YAML_SCALAR_NODE)
1248                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
1249                                 return pet_stmt_free(stmt));
1250
1251                 if (!strcmp((char *) key->data.scalar.value, "indent"))
1252                         indent = extract_string(ctx, document, value);
1253                 if (!strcmp((char *) key->data.scalar.value, "line"))
1254                         line = extract_int(ctx, document, value);
1255                 if (!strcmp((char *) key->data.scalar.value, "start"))
1256                         start = extract_int(ctx, document, value);
1257                 if (!strcmp((char *) key->data.scalar.value, "end"))
1258                         end = extract_int(ctx, document, value);
1259                 if (!strcmp((char *) key->data.scalar.value, "domain"))
1260                         stmt->domain = extract_set(ctx, document, value);
1261                 if (!strcmp((char *) key->data.scalar.value, "body"))
1262                         stmt->body = extract_tree(ctx, document, value);
1263
1264                 if (!strcmp((char *) key->data.scalar.value, "arguments"))
1265                         stmt = extract_stmt_arguments(ctx, document,
1266                                                         value, stmt);
1267                 if (!stmt)
1268                         return NULL;
1269         }
1270
1271         if (!indent)
1272                 indent = strdup("");
1273         stmt->loc = pet_loc_alloc(ctx, start, end, line, indent);
1274         if (!stmt->loc)
1275                 return pet_stmt_free(stmt);
1276
1277         return stmt;
1278 }
1279
1280 static struct pet_scop *extract_statements(isl_ctx *ctx,
1281         yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
1282 {
1283         int i;
1284         yaml_node_item_t *item;
1285
1286         if (node->type != YAML_SEQUENCE_NODE)
1287                 isl_die(ctx, isl_error_invalid, "expecting sequence",
1288                         return NULL);
1289
1290         scop->n_stmt = node->data.sequence.items.top
1291                                 - node->data.sequence.items.start;
1292         scop->stmts = isl_calloc_array(ctx, struct pet_stmt *, scop->n_stmt);
1293         if (!scop->stmts)
1294                 return pet_scop_free(scop);
1295
1296         for (item = node->data.sequence.items.start, i = 0;
1297              item < node->data.sequence.items.top; ++item, ++i) {
1298                 yaml_node_t *n;
1299
1300                 n = yaml_document_get_node(document, *item);
1301                 scop->stmts[i] = extract_stmt(ctx, document, n);
1302                 if (!scop->stmts[i])
1303                         return pet_scop_free(scop);
1304         }
1305
1306         return scop;
1307 }
1308
1309 /* Extract a pet_implication from "node".
1310  */
1311 static struct pet_implication *extract_implication(isl_ctx *ctx,
1312         yaml_document_t *document, yaml_node_t *node)
1313 {
1314         struct pet_implication *implication;
1315         yaml_node_pair_t * pair;
1316
1317         if (node->type != YAML_MAPPING_NODE)
1318                 isl_die(ctx, isl_error_invalid, "expecting mapping",
1319                         return NULL);
1320
1321         implication = isl_calloc_type(ctx, struct pet_implication);
1322         if (!implication)
1323                 return NULL;
1324
1325         for (pair = node->data.mapping.pairs.start;
1326              pair < node->data.mapping.pairs.top; ++pair) {
1327                 yaml_node_t *key, *value;
1328
1329                 key = yaml_document_get_node(document, pair->key);
1330                 value = yaml_document_get_node(document, pair->value);
1331
1332                 if (key->type != YAML_SCALAR_NODE)
1333                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
1334                                 return pet_implication_free(implication));
1335
1336                 if (!strcmp((char *) key->data.scalar.value, "satisfied"))
1337                         implication->satisfied =
1338                                             extract_int(ctx, document, value);
1339                 if (!strcmp((char *) key->data.scalar.value, "extension"))
1340                         implication->extension =
1341                                             extract_map(ctx, document, value);
1342         }
1343
1344         return implication;
1345 }
1346
1347 /* Extract a sequence of implications from "node" and
1348  * store them in scop->implications.
1349  */
1350 static struct pet_scop *extract_implications(isl_ctx *ctx,
1351         yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
1352 {
1353         int i;
1354         yaml_node_item_t *item;
1355
1356         if (node->type != YAML_SEQUENCE_NODE)
1357                 isl_die(ctx, isl_error_invalid, "expecting sequence",
1358                         return NULL);
1359
1360         scop->n_implication = node->data.sequence.items.top
1361                                 - node->data.sequence.items.start;
1362         scop->implications = isl_calloc_array(ctx, struct pet_implication *,
1363                                                 scop->n_implication);
1364         if (!scop->implications)
1365                 return pet_scop_free(scop);
1366
1367         for (item = node->data.sequence.items.start, i = 0;
1368              item < node->data.sequence.items.top; ++item, ++i) {
1369                 yaml_node_t *n;
1370
1371                 n = yaml_document_get_node(document, *item);
1372                 scop->implications[i] = extract_implication(ctx, document, n);
1373                 if (!scop->implications[i])
1374                         return pet_scop_free(scop);
1375         }
1376
1377         return scop;
1378 }
1379
1380 /* Extract a pet_independence from "node".
1381  */
1382 static struct pet_independence *extract_independence(isl_ctx *ctx,
1383         yaml_document_t *document, yaml_node_t *node)
1384 {
1385         struct pet_independence *independence;
1386         yaml_node_pair_t * pair;
1387
1388         if (node->type != YAML_MAPPING_NODE)
1389                 isl_die(ctx, isl_error_invalid, "expecting mapping",
1390                         return NULL);
1391
1392         independence = isl_calloc_type(ctx, struct pet_independence);
1393         if (!independence)
1394                 return NULL;
1395
1396         for (pair = node->data.mapping.pairs.start;
1397              pair < node->data.mapping.pairs.top; ++pair) {
1398                 yaml_node_t *key, *value;
1399
1400                 key = yaml_document_get_node(document, pair->key);
1401                 value = yaml_document_get_node(document, pair->value);
1402
1403                 if (key->type != YAML_SCALAR_NODE)
1404                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
1405                                 return pet_independence_free(independence));
1406
1407                 if (!strcmp((char *) key->data.scalar.value, "filter"))
1408                         independence->filter =
1409                                         extract_union_map(ctx, document, value);
1410                 if (!strcmp((char *) key->data.scalar.value, "local"))
1411                         independence->local =
1412                                         extract_union_set(ctx, document, value);
1413         }
1414
1415         if (!independence->filter)
1416                 isl_die(ctx, isl_error_invalid, "no filter field",
1417                         return pet_independence_free(independence));
1418         if (!independence->local)
1419                 isl_die(ctx, isl_error_invalid, "no local field",
1420                         return pet_independence_free(independence));
1421
1422         return independence;
1423 }
1424
1425 /* Extract a sequence of independences from "node" and
1426  * store them in scop->independences.
1427  */
1428 static struct pet_scop *extract_independences(isl_ctx *ctx,
1429         yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
1430 {
1431         int i;
1432         yaml_node_item_t *item;
1433
1434         if (node->type != YAML_SEQUENCE_NODE)
1435                 isl_die(ctx, isl_error_invalid, "expecting sequence",
1436                         return NULL);
1437
1438         scop->n_independence = node->data.sequence.items.top
1439                                 - node->data.sequence.items.start;
1440         scop->independences = isl_calloc_array(ctx, struct pet_independence *,
1441                                                 scop->n_independence);
1442         if (!scop->independences)
1443                 return pet_scop_free(scop);
1444
1445         for (item = node->data.sequence.items.start, i = 0;
1446              item < node->data.sequence.items.top; ++item, ++i) {
1447                 yaml_node_t *n;
1448
1449                 n = yaml_document_get_node(document, *item);
1450                 scop->independences[i] = extract_independence(ctx, document, n);
1451                 if (!scop->independences[i])
1452                         return pet_scop_free(scop);
1453         }
1454
1455         return scop;
1456 }
1457
1458 static struct pet_scop *extract_scop(isl_ctx *ctx, yaml_document_t *document,
1459         yaml_node_t *node)
1460 {
1461         struct pet_scop *scop;
1462         yaml_node_pair_t * pair;
1463
1464         if (!node)
1465                 return NULL;
1466
1467         if (node->type != YAML_MAPPING_NODE)
1468                 isl_die(ctx, isl_error_invalid, "expecting mapping",
1469                         return NULL);
1470
1471         scop = pet_scop_alloc(ctx);
1472         if (!scop)
1473                 return NULL;
1474
1475         for (pair = node->data.mapping.pairs.start;
1476              pair < node->data.mapping.pairs.top; ++pair) {
1477                 yaml_node_t *key, *value;
1478
1479                 key = yaml_document_get_node(document, pair->key);
1480                 value = yaml_document_get_node(document, pair->value);
1481
1482                 if (key->type != YAML_SCALAR_NODE)
1483                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
1484                                 return pet_scop_free(scop));
1485                 if (!strcmp((char *) key->data.scalar.value, "context"))
1486                         scop->context = extract_set(ctx, document, value);
1487                 if (!strcmp((char *) key->data.scalar.value, "context_value"))
1488                         scop->context_value = extract_set(ctx, document, value);
1489                 if (!strcmp((char *) key->data.scalar.value, "schedule"))
1490                         scop->schedule = extract_schedule(ctx, document, value);
1491                 if (!strcmp((char *) key->data.scalar.value, "types"))
1492                         scop = extract_types(ctx, document, value, scop);
1493                 if (!strcmp((char *) key->data.scalar.value, "arrays"))
1494                         scop = extract_arrays(ctx, document, value, scop);
1495                 if (!strcmp((char *) key->data.scalar.value, "statements"))
1496                         scop = extract_statements(ctx, document, value, scop);
1497                 if (!strcmp((char *) key->data.scalar.value, "implications"))
1498                         scop = extract_implications(ctx, document, value, scop);
1499                 if (!strcmp((char *) key->data.scalar.value, "independences"))
1500                         scop = extract_independences(ctx,
1501                                                         document, value, scop);
1502                 if (!scop)
1503                         return NULL;
1504         }
1505
1506         if (!scop->context_value) {
1507                 isl_space *space = isl_space_params_alloc(ctx, 0);
1508                 scop->context_value = isl_set_universe(space);
1509                 if (!scop->context_value)
1510                         return pet_scop_free(scop);
1511         }
1512
1513         return scop;
1514 }
1515
1516 /* Extract a pet_scop from the YAML description in "in".
1517  */
1518 struct pet_scop *pet_scop_parse(isl_ctx *ctx, FILE *in)
1519 {
1520         struct pet_scop *scop = NULL;
1521         yaml_parser_t parser;
1522         yaml_node_t *root;
1523         yaml_document_t document = { 0 };
1524
1525         yaml_parser_initialize(&parser);
1526
1527         yaml_parser_set_input_file(&parser, in);
1528
1529         if (!yaml_parser_load(&parser, &document))
1530                 goto error;
1531
1532         root = yaml_document_get_root_node(&document);
1533
1534         scop = extract_scop(ctx, &document, root);
1535
1536         yaml_document_delete(&document);
1537
1538         yaml_parser_delete(&parser);
1539
1540         return scop;
1541 error:
1542         yaml_parser_delete(&parser);
1543         pet_scop_free(scop);
1544         return NULL;
1545 }