parse.c

   1 /*
   2  * Copyright 2011 Leiden University. All rights reserved.
   3  * Copyright 2013 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 "scop.h"
  39 #include "scop_yaml.h"
  40
  41 static char *extract_string(isl_ctx *ctx, yaml_document_t *document,
  42         yaml_node_t *node)
  43 {
  44         if (node->type != YAML_SCALAR_NODE)
  45                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  46                         return NULL);
  47
  48         return strdup((char *) node->data.scalar.value);
  49 }
  50
  51 static int extract_int(isl_ctx *ctx, yaml_document_t *document,
  52         yaml_node_t *node)
  53 {
  54         if (node->type != YAML_SCALAR_NODE)
  55                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  56                         return -1);
  57
  58         return atoi((char *) node->data.scalar.value);
  59 }
  60
  61 static double extract_double(isl_ctx *ctx, yaml_document_t *document,
  62         yaml_node_t *node)
  63 {
  64         if (node->type != YAML_SCALAR_NODE)
  65                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  66                         return -1);
  67
  68         return strtod((char *) node->data.scalar.value, NULL);
  69 }
  70
  71 static enum pet_expr_type extract_expr_type(isl_ctx *ctx,
  72         yaml_document_t *document, yaml_node_t *node)
  73 {
  74         if (node->type != YAML_SCALAR_NODE)
  75                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  76                         return -1);
  77
  78         return pet_str_type((char *) node->data.scalar.value);
  79 }
  80
  81 static enum pet_op_type extract_op(isl_ctx *ctx, yaml_document_t *document,
  82         yaml_node_t *node)
  83 {
  84         if (node->type != YAML_SCALAR_NODE)
  85                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  86                         return -1);
  87
  88         return pet_str_op((char *) node->data.scalar.value);
  89 }
  90
  91 static __isl_give isl_set *extract_set(isl_ctx *ctx, yaml_document_t *document,
  92         yaml_node_t *node)
  93 {
  94         if (node->type != YAML_SCALAR_NODE)
  95                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  96                         return NULL);
  97
  98         return isl_set_read_from_str(ctx, (char *) node->data.scalar.value);
  99 }
 100
 101 static __isl_give isl_id *extract_id(isl_ctx *ctx, yaml_document_t *document,
 102         yaml_node_t *node)
 103 {
 104         if (node->type != YAML_SCALAR_NODE)
 105                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 106                         return NULL);
 107
 108         return isl_id_alloc(ctx, (char *) node->data.scalar.value, NULL);
 109 }
 110
 111 static __isl_give isl_map *extract_map(isl_ctx *ctx, yaml_document_t *document,
 112         yaml_node_t *node)
 113 {
 114         if (node->type != YAML_SCALAR_NODE)
 115                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 116                         return NULL);
 117
 118         return isl_map_read_from_str(ctx, (char *) node->data.scalar.value);
 119 }
 120
 121 /* Extract an isl_val from "node".
 122  */
 123 static __isl_give isl_val *extract_val(isl_ctx *ctx, yaml_document_t *document,
 124         yaml_node_t *node)
 125 {
 126         if (node->type != YAML_SCALAR_NODE)
 127                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 128                         return NULL);
 129
 130         return isl_val_read_from_str(ctx, (char *) node->data.scalar.value);
 131 }
 132
 133 /* Extract an isl_multi_pw_aff from "node".
 134  */
 135 static __isl_give isl_multi_pw_aff *extract_multi_pw_aff(isl_ctx *ctx,
 136         yaml_document_t *document, yaml_node_t *node)
 137 {
 138         if (node->type != YAML_SCALAR_NODE)
 139                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 140                         return NULL);
 141
 142         return isl_multi_pw_aff_read_from_str(ctx,
 143                                             (char *) node->data.scalar.value);
 144 }
 145
 146 /* Extract a pet_type from "node".
 147  */
 148 static struct pet_type *extract_type(isl_ctx *ctx,
 149         yaml_document_t *document, yaml_node_t *node)
 150 {
 151         struct pet_type *type;
 152         yaml_node_pair_t * pair;
 153
 154         if (node->type != YAML_MAPPING_NODE)
 155                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 156                         return NULL);
 157
 158         type = isl_calloc_type(ctx, struct pet_type);
 159         if (!type)
 160                 return NULL;
 161
 162         for (pair = node->data.mapping.pairs.start;
 163              pair < node->data.mapping.pairs.top; ++pair) {
 164                 yaml_node_t *key, *value;
 165
 166                 key = yaml_document_get_node(document, pair->key);
 167                 value = yaml_document_get_node(document, pair->value);
 168
 169                 if (key->type != YAML_SCALAR_NODE)
 170                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 171                                 return pet_type_free(type));
 172
 173                 if (!strcmp((char *) key->data.scalar.value, "name"))
 174                         type->name = extract_string(ctx, document, value);
 175                 if (!strcmp((char *) key->data.scalar.value, "definition"))
 176                         type->definition = extract_string(ctx, document, value);
 177         }
 178
 179         return type;
 180 }
 181
 182 /* Extract a sequence of types from "node" and store them in scop->types.
 183  */
 184 static struct pet_scop *extract_types(isl_ctx *ctx,
 185         yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
 186 {
 187         int i;
 188         yaml_node_item_t *item;
 189
 190         if (node->type != YAML_SEQUENCE_NODE)
 191                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 192                         return NULL);
 193
 194         scop->n_type = node->data.sequence.items.top
 195                                 - node->data.sequence.items.start;
 196         scop->types = isl_calloc_array(ctx, struct pet_type *, scop->n_type);
 197         if (!scop->types)
 198                 return pet_scop_free(scop);
 199
 200         for (item = node->data.sequence.items.start, i = 0;
 201              item < node->data.sequence.items.top; ++item, ++i) {
 202                 yaml_node_t *n;
 203
 204                 n = yaml_document_get_node(document, *item);
 205                 scop->types[i] = extract_type(ctx, document, n);
 206                 if (!scop->types[i])
 207                         return pet_scop_free(scop);
 208         }
 209
 210         return scop;
 211 }
 212
 213 static struct pet_array *extract_array(isl_ctx *ctx, yaml_document_t *document,
 214         yaml_node_t *node)
 215 {
 216         struct pet_array *array;
 217         yaml_node_pair_t * pair;
 218
 219         if (node->type != YAML_MAPPING_NODE)
 220                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 221                         return NULL);
 222
 223         array = isl_calloc_type(ctx, struct pet_array);
 224         if (!array)
 225                 return NULL;
 226
 227         for (pair = node->data.mapping.pairs.start;
 228              pair < node->data.mapping.pairs.top; ++pair) {
 229                 yaml_node_t *key, *value;
 230
 231                 key = yaml_document_get_node(document, pair->key);
 232                 value = yaml_document_get_node(document, pair->value);
 233
 234                 if (key->type != YAML_SCALAR_NODE)
 235                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 236                                 return pet_array_free(array));
 237
 238                 if (!strcmp((char *) key->data.scalar.value, "context"))
 239                         array->context = extract_set(ctx, document, value);
 240                 if (!strcmp((char *) key->data.scalar.value, "extent"))
 241                         array->extent = extract_set(ctx, document, value);
 242                 if (!strcmp((char *) key->data.scalar.value, "value_bounds"))
 243                         array->value_bounds = extract_set(ctx, document, value);
 244                 if (!strcmp((char *) key->data.scalar.value, "element_type"))
 245                         array->element_type =
 246                                         extract_string(ctx, document, value);
 247                 if (!strcmp((char *) key->data.scalar.value, "element_size"))
 248                         array->element_size = extract_int(ctx, document, value);
 249                 if (!strcmp((char *) key->data.scalar.value,
 250                                 "element_is_record"))
 251                         array->element_is_record =
 252                                         extract_int(ctx, document, value);
 253                 if (!strcmp((char *) key->data.scalar.value, "live_out"))
 254                         array->live_out = extract_int(ctx, document, value);
 255                 if (!strcmp((char *) key->data.scalar.value,
 256                                 "uniquely_defined"))
 257                         array->uniquely_defined =
 258                                         extract_int(ctx, document, value);
 259                 if (!strcmp((char *) key->data.scalar.value, "declared"))
 260                         array->declared = extract_int(ctx, document, value);
 261                 if (!strcmp((char *) key->data.scalar.value, "exposed"))
 262                         array->exposed = extract_int(ctx, document, value);
 263         }
 264
 265         return array;
 266 }
 267
 268 static struct pet_scop *extract_arrays(isl_ctx *ctx, yaml_document_t *document,
 269         yaml_node_t *node, struct pet_scop *scop)
 270 {
 271         int i;
 272         yaml_node_item_t *item;
 273
 274         if (node->type != YAML_SEQUENCE_NODE)
 275                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 276                         return NULL);
 277
 278         scop->n_array = node->data.sequence.items.top
 279                                 - node->data.sequence.items.start;
 280         scop->arrays = isl_calloc_array(ctx, struct pet_array *, scop->n_array);
 281         if (!scop->arrays)
 282                 return pet_scop_free(scop);
 283
 284         for (item = node->data.sequence.items.start, i = 0;
 285              item < node->data.sequence.items.top; ++item, ++i) {
 286                 yaml_node_t *n;
 287
 288                 n = yaml_document_get_node(document, *item);
 289                 scop->arrays[i] = extract_array(ctx, document, n);
 290                 if (!scop->arrays[i])
 291                         return pet_scop_free(scop);
 292         }
 293
 294         return scop;
 295 }
 296
 297 static struct pet_expr *extract_expr(isl_ctx *ctx, yaml_document_t *document,
 298         yaml_node_t *node);
 299
 300 static struct pet_expr *extract_arguments(isl_ctx *ctx,
 301         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 302 {
 303         int i;
 304         yaml_node_item_t *item;
 305
 306         if (node->type != YAML_SEQUENCE_NODE)
 307                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 308                         return pet_expr_free(expr));
 309
 310         expr->n_arg = node->data.sequence.items.top
 311                                 - node->data.sequence.items.start;
 312         expr->args = isl_calloc_array(ctx, struct pet_expr *, expr->n_arg);
 313         if (!expr->args)
 314                 return pet_expr_free(expr);
 315
 316         for (item = node->data.sequence.items.start, i = 0;
 317              item < node->data.sequence.items.top; ++item, ++i) {
 318                 yaml_node_t *n;
 319
 320                 n = yaml_document_get_node(document, *item);
 321                 expr->args[i] = extract_expr(ctx, document, n);
 322                 if (!expr->args[i])
 323                         return pet_expr_free(expr);
 324         }
 325
 326         return expr;
 327 }
 328
 329 /* Extract pet_expr_double specific fields from "node" and
 330  * update "expr" accordingly.
 331  */
 332 static struct pet_expr *extract_expr_double(isl_ctx *ctx,
 333         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 334 {
 335         yaml_node_pair_t *pair;
 336
 337         for (pair = node->data.mapping.pairs.start;
 338              pair < node->data.mapping.pairs.top; ++pair) {
 339                 yaml_node_t *key, *value;
 340
 341                 key = yaml_document_get_node(document, pair->key);
 342                 value = yaml_document_get_node(document, pair->value);
 343
 344                 if (key->type != YAML_SCALAR_NODE)
 345                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 346                                 return pet_expr_free(expr));
 347
 348                 if (!strcmp((char *) key->data.scalar.value, "value"))
 349                         expr->d.val = extract_double(ctx, document, value);
 350                 if (!strcmp((char *) key->data.scalar.value, "string"))
 351                         expr->d.s = extract_string(ctx, document, value);
 352         }
 353
 354         return expr;
 355 }
 356
 357 /* Extract pet_expr_access specific fields from "node" and
 358  * update "expr" accordingly.
 359  */
 360 static struct pet_expr *extract_expr_access(isl_ctx *ctx,
 361         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 362 {
 363         yaml_node_pair_t *pair;
 364
 365         for (pair = node->data.mapping.pairs.start;
 366              pair < node->data.mapping.pairs.top; ++pair) {
 367                 yaml_node_t *key, *value;
 368
 369                 key = yaml_document_get_node(document, pair->key);
 370                 value = yaml_document_get_node(document, pair->value);
 371
 372                 if (key->type != YAML_SCALAR_NODE)
 373                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 374                                 return pet_expr_free(expr));
 375
 376                 if (!strcmp((char *) key->data.scalar.value, "relation"))
 377                         expr->acc.access = extract_map(ctx, document, value);
 378                 if (!strcmp((char *) key->data.scalar.value, "index"))
 379                         expr->acc.index = extract_multi_pw_aff(ctx, document,
 380                                                                 value);
 381                 if (!strcmp((char *) key->data.scalar.value, "reference"))
 382                         expr->acc.ref_id = extract_id(ctx, document, value);
 383                 if (!strcmp((char *) key->data.scalar.value, "read"))
 384                         expr->acc.read = extract_int(ctx, document, value);
 385                 if (!strcmp((char *) key->data.scalar.value, "write"))
 386                         expr->acc.write = extract_int(ctx, document, value);
 387         }
 388
 389         return expr;
 390 }
 391
 392 /* Extract operation expression specific fields from "node" and
 393  * update "expr" accordingly.
 394  */
 395 static struct pet_expr *extract_expr_op(isl_ctx *ctx,
 396         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 397 {
 398         yaml_node_pair_t *pair;
 399
 400         for (pair = node->data.mapping.pairs.start;
 401              pair < node->data.mapping.pairs.top; ++pair) {
 402                 yaml_node_t *key, *value;
 403
 404                 key = yaml_document_get_node(document, pair->key);
 405                 value = yaml_document_get_node(document, pair->value);
 406
 407                 if (key->type != YAML_SCALAR_NODE)
 408                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 409                                 return pet_expr_free(expr));
 410
 411                 if (!strcmp((char *) key->data.scalar.value, "operation"))
 412                         expr->op = extract_op(ctx, document, value);
 413         }
 414
 415         return expr;
 416 }
 417
 418 /* Extract pet_expr_call specific fields from "node" and
 419  * update "expr" accordingly.
 420  */
 421 static struct pet_expr *extract_expr_call(isl_ctx *ctx,
 422         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 423 {
 424         yaml_node_pair_t *pair;
 425
 426         for (pair = node->data.mapping.pairs.start;
 427              pair < node->data.mapping.pairs.top; ++pair) {
 428                 yaml_node_t *key, *value;
 429
 430                 key = yaml_document_get_node(document, pair->key);
 431                 value = yaml_document_get_node(document, pair->value);
 432
 433                 if (key->type != YAML_SCALAR_NODE)
 434                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 435                                 return pet_expr_free(expr));
 436
 437                 if (!strcmp((char *) key->data.scalar.value, "name"))
 438                         expr->name = extract_string(ctx, document, value);
 439         }
 440
 441         return expr;
 442 }
 443
 444 /* Extract pet_expr_cast specific fields from "node" and
 445  * update "expr" accordingly.
 446  */
 447 static struct pet_expr *extract_expr_cast(isl_ctx *ctx,
 448         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 449 {
 450         yaml_node_pair_t *pair;
 451
 452         for (pair = node->data.mapping.pairs.start;
 453              pair < node->data.mapping.pairs.top; ++pair) {
 454                 yaml_node_t *key, *value;
 455
 456                 key = yaml_document_get_node(document, pair->key);
 457                 value = yaml_document_get_node(document, pair->value);
 458
 459                 if (key->type != YAML_SCALAR_NODE)
 460                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 461                                 return pet_expr_free(expr));
 462
 463                 if (!strcmp((char *) key->data.scalar.value, "type_name"))
 464                         expr->type_name = extract_string(ctx, document, value);
 465         }
 466
 467         return expr;
 468 }
 469
 470 /* Extract pet_expr_int specific fields from "node" and
 471  * update "expr" accordingly.
 472  */
 473 static struct pet_expr *extract_expr_int(isl_ctx *ctx,
 474         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 475 {
 476         yaml_node_pair_t * pair;
 477
 478         for (pair = node->data.mapping.pairs.start;
 479              pair < node->data.mapping.pairs.top; ++pair) {
 480                 yaml_node_t *key, *value;
 481
 482                 key = yaml_document_get_node(document, pair->key);
 483                 value = yaml_document_get_node(document, pair->value);
 484
 485                 if (key->type != YAML_SCALAR_NODE)
 486                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 487                                 return pet_expr_free(expr));
 488
 489                 if (!strcmp((char *) key->data.scalar.value, "value"))
 490                         expr->i = extract_val(ctx, document, value);
 491         }
 492
 493         return expr;
 494 }
 495
 496 /* Extract a pet_expr from "node".
 497  *
 498  * We first extract the type and arguments of the expression and
 499  * then extract additional fields depending on the type.
 500  */
 501 static struct pet_expr *extract_expr(isl_ctx *ctx, yaml_document_t *document,
 502         yaml_node_t *node)
 503 {
 504         struct pet_expr *expr;
 505         yaml_node_pair_t *pair;
 506
 507         if (node->type != YAML_MAPPING_NODE)
 508                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 509                         return NULL);
 510
 511         expr = isl_calloc_type(ctx, struct pet_expr);
 512         if (!expr)
 513                 return NULL;
 514
 515         for (pair = node->data.mapping.pairs.start;
 516              pair < node->data.mapping.pairs.top; ++pair) {
 517                 yaml_node_t *key, *value;
 518
 519                 key = yaml_document_get_node(document, pair->key);
 520                 value = yaml_document_get_node(document, pair->value);
 521
 522                 if (key->type != YAML_SCALAR_NODE)
 523                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 524                                 return pet_expr_free(expr));
 525
 526                 if (!strcmp((char *) key->data.scalar.value, "type"))
 527                         expr->type = extract_expr_type(ctx, document, value);
 528
 529                 if (!strcmp((char *) key->data.scalar.value, "arguments"))
 530                         expr = extract_arguments(ctx, document, value, expr);
 531                 if (!expr)
 532                         return NULL;
 533         }
 534
 535         switch (expr->type) {
 536         case pet_expr_access:
 537                 expr = extract_expr_access(ctx, document, node, expr);
 538                 break;
 539         case pet_expr_double:
 540                 expr = extract_expr_double(ctx, document, node, expr);
 541                 break;
 542         case pet_expr_call:
 543                 expr = extract_expr_call(ctx, document, node, expr);
 544                 break;
 545         case pet_expr_cast:
 546                 expr = extract_expr_cast(ctx, document, node, expr);
 547                 break;
 548         case pet_expr_int:
 549                 expr = extract_expr_int(ctx, document, node, expr);
 550                 break;
 551         case pet_expr_op:
 552                 expr = extract_expr_op(ctx, document, node, expr);
 553                 break;
 554         }
 555
 556         return expr;
 557 }
 558
 559 static struct pet_stmt *extract_stmt_arguments(isl_ctx *ctx,
 560         yaml_document_t *document, yaml_node_t *node, struct pet_stmt *stmt)
 561 {
 562         int i;
 563         yaml_node_item_t *item;
 564
 565         if (node->type != YAML_SEQUENCE_NODE)
 566                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 567                         return pet_stmt_free(stmt));
 568
 569         stmt->n_arg = node->data.sequence.items.top
 570                                 - node->data.sequence.items.start;
 571         stmt->args = isl_calloc_array(ctx, struct pet_expr *, stmt->n_arg);
 572         if (!stmt->args)
 573                 return pet_stmt_free(stmt);
 574
 575         for (item = node->data.sequence.items.start, i = 0;
 576              item < node->data.sequence.items.top; ++item, ++i) {
 577                 yaml_node_t *n;
 578
 579                 n = yaml_document_get_node(document, *item);
 580                 stmt->args[i] = extract_expr(ctx, document, n);
 581                 if (!stmt->args[i])
 582                         return pet_stmt_free(stmt);
 583         }
 584
 585         return stmt;
 586 }
 587
 588 static struct pet_stmt *extract_stmt(isl_ctx *ctx, yaml_document_t *document,
 589         yaml_node_t *node)
 590 {
 591         struct pet_stmt *stmt;
 592         yaml_node_pair_t * pair;
 593
 594         if (node->type != YAML_MAPPING_NODE)
 595                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 596                         return NULL);
 597
 598         stmt = isl_calloc_type(ctx, struct pet_stmt);
 599         if (!stmt)
 600                 return NULL;
 601
 602         for (pair = node->data.mapping.pairs.start;
 603              pair < node->data.mapping.pairs.top; ++pair) {
 604                 yaml_node_t *key, *value;
 605
 606                 key = yaml_document_get_node(document, pair->key);
 607                 value = yaml_document_get_node(document, pair->value);
 608
 609                 if (key->type != YAML_SCALAR_NODE)
 610                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 611                                 return pet_stmt_free(stmt));
 612
 613                 if (!strcmp((char *) key->data.scalar.value, "line"))
 614                         stmt->line = extract_int(ctx, document, value);
 615                 if (!strcmp((char *) key->data.scalar.value, "domain"))
 616                         stmt->domain = extract_set(ctx, document, value);
 617                 if (!strcmp((char *) key->data.scalar.value, "schedule"))
 618                         stmt->schedule = extract_map(ctx, document, value);
 619                 if (!strcmp((char *) key->data.scalar.value, "body"))
 620                         stmt->body = extract_expr(ctx, document, value);
 621
 622                 if (!strcmp((char *) key->data.scalar.value, "arguments"))
 623                         stmt = extract_stmt_arguments(ctx, document,
 624                                                         value, stmt);
 625                 if (!stmt)
 626                         return NULL;
 627         }
 628
 629         return stmt;
 630 }
 631
 632 static struct pet_scop *extract_statements(isl_ctx *ctx,
 633         yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
 634 {
 635         int i;
 636         yaml_node_item_t *item;
 637
 638         if (node->type != YAML_SEQUENCE_NODE)
 639                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 640                         return NULL);
 641
 642         scop->n_stmt = node->data.sequence.items.top
 643                                 - node->data.sequence.items.start;
 644         scop->stmts = isl_calloc_array(ctx, struct pet_stmt *, scop->n_stmt);
 645         if (!scop->stmts)
 646                 return pet_scop_free(scop);
 647
 648         for (item = node->data.sequence.items.start, i = 0;
 649              item < node->data.sequence.items.top; ++item, ++i) {
 650                 yaml_node_t *n;
 651
 652                 n = yaml_document_get_node(document, *item);
 653                 scop->stmts[i] = extract_stmt(ctx, document, n);
 654                 if (!scop->stmts[i])
 655                         return pet_scop_free(scop);
 656         }
 657
 658         return scop;
 659 }
 660
 661 /* Extract a pet_implication from "node".
 662  */
 663 static struct pet_implication *extract_implication(isl_ctx *ctx,
 664         yaml_document_t *document, yaml_node_t *node)
 665 {
 666         struct pet_implication *implication;
 667         yaml_node_pair_t * pair;
 668
 669         if (node->type != YAML_MAPPING_NODE)
 670                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 671                         return NULL);
 672
 673         implication = isl_calloc_type(ctx, struct pet_implication);
 674         if (!implication)
 675                 return NULL;
 676
 677         for (pair = node->data.mapping.pairs.start;
 678              pair < node->data.mapping.pairs.top; ++pair) {
 679                 yaml_node_t *key, *value;
 680
 681                 key = yaml_document_get_node(document, pair->key);
 682                 value = yaml_document_get_node(document, pair->value);
 683
 684                 if (key->type != YAML_SCALAR_NODE)
 685                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 686                                 return pet_implication_free(implication));
 687
 688                 if (!strcmp((char *) key->data.scalar.value, "satisfied"))
 689                         implication->satisfied =
 690                                             extract_int(ctx, document, value);
 691                 if (!strcmp((char *) key->data.scalar.value, "extension"))
 692                         implication->extension =
 693                                             extract_map(ctx, document, value);
 694         }
 695
 696         return implication;
 697 }
 698
 699 /* Extract a sequence of implications from "node" and
 700  * store them in scop->implications.
 701  */
 702 static struct pet_scop *extract_implications(isl_ctx *ctx,
 703         yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
 704 {
 705         int i;
 706         yaml_node_item_t *item;
 707
 708         if (node->type != YAML_SEQUENCE_NODE)
 709                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 710                         return NULL);
 711
 712         scop->n_implication = node->data.sequence.items.top
 713                                 - node->data.sequence.items.start;
 714         scop->implications = isl_calloc_array(ctx, struct pet_implication *,
 715                                                 scop->n_implication);
 716         if (!scop->implications)
 717                 return pet_scop_free(scop);
 718
 719         for (item = node->data.sequence.items.start, i = 0;
 720              item < node->data.sequence.items.top; ++item, ++i) {
 721                 yaml_node_t *n;
 722
 723                 n = yaml_document_get_node(document, *item);
 724                 scop->implications[i] = extract_implication(ctx, document, n);
 725                 if (!scop->implications[i])
 726                         return pet_scop_free(scop);
 727         }
 728
 729         return scop;
 730 }
 731
 732 static struct pet_scop *extract_scop(isl_ctx *ctx, yaml_document_t *document,
 733         yaml_node_t *node)
 734 {
 735         struct pet_scop *scop;
 736         yaml_node_pair_t * pair;
 737
 738         if (!node)
 739                 return NULL;
 740
 741         if (node->type != YAML_MAPPING_NODE)
 742                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 743                         return NULL);
 744
 745         scop = pet_scop_alloc(ctx);
 746         if (!scop)
 747                 return NULL;
 748
 749         for (pair = node->data.mapping.pairs.start;
 750              pair < node->data.mapping.pairs.top; ++pair) {
 751                 yaml_node_t *key, *value;
 752
 753                 key = yaml_document_get_node(document, pair->key);
 754                 value = yaml_document_get_node(document, pair->value);
 755
 756                 if (key->type != YAML_SCALAR_NODE)
 757                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 758                                 return pet_scop_free(scop));
 759                 if (!strcmp((char *) key->data.scalar.value, "context"))
 760                         scop->context = extract_set(ctx, document, value);
 761                 if (!strcmp((char *) key->data.scalar.value, "context_value"))
 762                         scop->context_value = extract_set(ctx, document, value);
 763                 if (!strcmp((char *) key->data.scalar.value, "types"))
 764                         scop = extract_types(ctx, document, value, scop);
 765                 if (!strcmp((char *) key->data.scalar.value, "arrays"))
 766                         scop = extract_arrays(ctx, document, value, scop);
 767                 if (!strcmp((char *) key->data.scalar.value, "statements"))
 768                         scop = extract_statements(ctx, document, value, scop);
 769                 if (!strcmp((char *) key->data.scalar.value, "implications"))
 770                         scop = extract_implications(ctx, document, value, scop);
 771                 if (!scop)
 772                         return NULL;
 773         }
 774
 775         if (!scop->context_value) {
 776                 isl_space *space = isl_space_params_alloc(ctx, 0);
 777                 scop->context_value = isl_set_universe(space);
 778                 if (!scop->context_value)
 779                         return pet_scop_free(scop);
 780         }
 781
 782         return scop;
 783 }
 784
 785 /* Extract a pet_scop from the YAML description in "in".
 786  */
 787 struct pet_scop *pet_scop_parse(isl_ctx *ctx, FILE *in)
 788 {
 789         struct pet_scop *scop = NULL;
 790         yaml_parser_t parser;
 791         yaml_node_t *root;
 792         yaml_document_t document = { 0 };
 793
 794         yaml_parser_initialize(&parser);
 795
 796         yaml_parser_set_input_file(&parser, in);
 797
 798         if (!yaml_parser_load(&parser, &document))
 799                 goto error;
 800
 801         root = yaml_document_get_root_node(&document);
 802
 803         scop = extract_scop(ctx, &document, root);
 804
 805         yaml_document_delete(&document);
 806
 807         yaml_parser_delete(&parser);
 808
 809         return scop;
 810 error:
 811         yaml_parser_delete(&parser);
 812         pet_scop_free(scop);
 813         return NULL;
 814 }