parse.c

   1 /*
   2  * Copyright 2011 Leiden University. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  *    1. Redistributions of source code must retain the above copyright
   9  *       notice, this list of conditions and the following disclaimer.
  10  *
  11  *    2. Redistributions in binary form must reproduce the above
  12  *       copyright notice, this list of conditions and the following
  13  *       disclaimer in the documentation and/or other materials provided
  14  *       with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY LEIDEN UNIVERSITY ''AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LEIDEN UNIVERSITY OR
  20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  23  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * The views and conclusions contained in the software and documentation
  29  * are those of the authors and should not be interpreted as
  30  * representing official policies, either expressed or implied, of
  31  * Leiden University.
  32  */
  33
  34 #include <stdlib.h>
  35 #include <yaml.h>
  36
  37 #include "scop.h"
  38 #include "scop_yaml.h"
  39
  40 static char *extract_string(isl_ctx *ctx, yaml_document_t *document,
  41         yaml_node_t *node)
  42 {
  43         if (node->type != YAML_SCALAR_NODE)
  44                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  45                         return NULL);
  46
  47         return strdup((char *) node->data.scalar.value);
  48 }
  49
  50 static int extract_int(isl_ctx *ctx, yaml_document_t *document,
  51         yaml_node_t *node)
  52 {
  53         if (node->type != YAML_SCALAR_NODE)
  54                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  55                         return -1);
  56
  57         return atoi((char *) node->data.scalar.value);
  58 }
  59
  60 static double extract_double(isl_ctx *ctx, yaml_document_t *document,
  61         yaml_node_t *node)
  62 {
  63         if (node->type != YAML_SCALAR_NODE)
  64                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  65                         return -1);
  66
  67         return strtod((char *) node->data.scalar.value, NULL);
  68 }
  69
  70 static enum pet_expr_type extract_type(isl_ctx *ctx, yaml_document_t *document,
  71         yaml_node_t *node)
  72 {
  73         if (node->type != YAML_SCALAR_NODE)
  74                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  75                         return -1);
  76
  77         return pet_str_type((char *) node->data.scalar.value);
  78 }
  79
  80 static enum pet_op_type extract_op(isl_ctx *ctx, yaml_document_t *document,
  81         yaml_node_t *node)
  82 {
  83         if (node->type != YAML_SCALAR_NODE)
  84                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  85                         return -1);
  86
  87         return pet_str_op((char *) node->data.scalar.value);
  88 }
  89
  90 static __isl_give isl_set *extract_set(isl_ctx *ctx, yaml_document_t *document,
  91         yaml_node_t *node)
  92 {
  93         if (node->type != YAML_SCALAR_NODE)
  94                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
  95                         return NULL);
  96
  97         return isl_set_read_from_str(ctx, (char *) node->data.scalar.value);
  98 }
  99
 100 static __isl_give isl_id *extract_id(isl_ctx *ctx, yaml_document_t *document,
 101         yaml_node_t *node)
 102 {
 103         if (node->type != YAML_SCALAR_NODE)
 104                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 105                         return NULL);
 106
 107         return isl_id_alloc(ctx, (char *) node->data.scalar.value, NULL);
 108 }
 109
 110 static __isl_give isl_map *extract_map(isl_ctx *ctx, yaml_document_t *document,
 111         yaml_node_t *node)
 112 {
 113         if (node->type != YAML_SCALAR_NODE)
 114                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 115                         return NULL);
 116
 117         return isl_map_read_from_str(ctx, (char *) node->data.scalar.value);
 118 }
 119
 120 /* Extract an isl_multi_pw_aff from "node".
 121  */
 122 static __isl_give isl_multi_pw_aff *extract_multi_pw_aff(isl_ctx *ctx,
 123         yaml_document_t *document, yaml_node_t *node)
 124 {
 125         if (node->type != YAML_SCALAR_NODE)
 126                 isl_die(ctx, isl_error_invalid, "expecting scalar node",
 127                         return NULL);
 128
 129         return isl_multi_pw_aff_read_from_str(ctx,
 130                                             (char *) node->data.scalar.value);
 131 }
 132
 133 static struct pet_array *extract_array(isl_ctx *ctx, yaml_document_t *document,
 134         yaml_node_t *node)
 135 {
 136         struct pet_array *array;
 137         yaml_node_pair_t * pair;
 138
 139         if (node->type != YAML_MAPPING_NODE)
 140                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 141                         return NULL);
 142
 143         array = isl_calloc_type(ctx, struct pet_array);
 144         if (!array)
 145                 return NULL;
 146
 147         for (pair = node->data.mapping.pairs.start;
 148              pair < node->data.mapping.pairs.top; ++pair) {
 149                 yaml_node_t *key, *value;
 150
 151                 key = yaml_document_get_node(document, pair->key);
 152                 value = yaml_document_get_node(document, pair->value);
 153
 154                 if (key->type != YAML_SCALAR_NODE)
 155                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 156                                 return pet_array_free(array));
 157
 158                 if (!strcmp((char *) key->data.scalar.value, "context"))
 159                         array->context = extract_set(ctx, document, value);
 160                 if (!strcmp((char *) key->data.scalar.value, "extent"))
 161                         array->extent = extract_set(ctx, document, value);
 162                 if (!strcmp((char *) key->data.scalar.value, "value_bounds"))
 163                         array->value_bounds = extract_set(ctx, document, value);
 164                 if (!strcmp((char *) key->data.scalar.value, "element_type"))
 165                         array->element_type =
 166                                         extract_string(ctx, document, value);
 167                 if (!strcmp((char *) key->data.scalar.value, "element_size"))
 168                         array->element_size = extract_int(ctx, document, value);
 169                 if (!strcmp((char *) key->data.scalar.value, "live_out"))
 170                         array->live_out = extract_int(ctx, document, value);
 171                 if (!strcmp((char *) key->data.scalar.value,
 172                                 "uniquely_defined"))
 173                         array->uniquely_defined =
 174                                         extract_int(ctx, document, value);
 175                 if (!strcmp((char *) key->data.scalar.value, "declared"))
 176                         array->declared = extract_int(ctx, document, value);
 177                 if (!strcmp((char *) key->data.scalar.value, "exposed"))
 178                         array->exposed = extract_int(ctx, document, value);
 179         }
 180
 181         return array;
 182 }
 183
 184 static struct pet_scop *extract_arrays(isl_ctx *ctx, yaml_document_t *document,
 185         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_array = node->data.sequence.items.top
 195                                 - node->data.sequence.items.start;
 196         scop->arrays = isl_calloc_array(ctx, struct pet_array *, scop->n_array);
 197         if (!scop->arrays)
 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->arrays[i] = extract_array(ctx, document, n);
 206                 if (!scop->arrays[i])
 207                         return pet_scop_free(scop);
 208         }
 209
 210         return scop;
 211 }
 212
 213 static struct pet_expr *extract_expr(isl_ctx *ctx, yaml_document_t *document,
 214         yaml_node_t *node);
 215
 216 static struct pet_expr *extract_arguments(isl_ctx *ctx,
 217         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 218 {
 219         int i;
 220         yaml_node_item_t *item;
 221
 222         if (node->type != YAML_SEQUENCE_NODE)
 223                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 224                         return pet_expr_free(expr));
 225
 226         expr->n_arg = node->data.sequence.items.top
 227                                 - node->data.sequence.items.start;
 228         expr->args = isl_calloc_array(ctx, struct pet_expr *, expr->n_arg);
 229         if (!expr->args)
 230                 return pet_expr_free(expr);
 231
 232         for (item = node->data.sequence.items.start, i = 0;
 233              item < node->data.sequence.items.top; ++item, ++i) {
 234                 yaml_node_t *n;
 235
 236                 n = yaml_document_get_node(document, *item);
 237                 expr->args[i] = extract_expr(ctx, document, n);
 238                 if (!expr->args[i])
 239                         return pet_expr_free(expr);
 240         }
 241
 242         return expr;
 243 }
 244
 245 /* Extract pet_expr_double specific fields from "node" and
 246  * update "expr" accordingly.
 247  */
 248 static struct pet_expr *extract_expr_double(isl_ctx *ctx,
 249         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 250 {
 251         yaml_node_pair_t *pair;
 252
 253         for (pair = node->data.mapping.pairs.start;
 254              pair < node->data.mapping.pairs.top; ++pair) {
 255                 yaml_node_t *key, *value;
 256
 257                 key = yaml_document_get_node(document, pair->key);
 258                 value = yaml_document_get_node(document, pair->value);
 259
 260                 if (key->type != YAML_SCALAR_NODE)
 261                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 262                                 return pet_expr_free(expr));
 263
 264                 if (!strcmp((char *) key->data.scalar.value, "value"))
 265                         expr->d.val = extract_double(ctx, document, value);
 266                 if (!strcmp((char *) key->data.scalar.value, "string"))
 267                         expr->d.s = extract_string(ctx, document, value);
 268         }
 269
 270         return expr;
 271 }
 272
 273 /* Extract pet_expr_access specific fields from "node" and
 274  * update "expr" accordingly.
 275  */
 276 static struct pet_expr *extract_expr_access(isl_ctx *ctx,
 277         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 278 {
 279         yaml_node_pair_t *pair;
 280
 281         for (pair = node->data.mapping.pairs.start;
 282              pair < node->data.mapping.pairs.top; ++pair) {
 283                 yaml_node_t *key, *value;
 284
 285                 key = yaml_document_get_node(document, pair->key);
 286                 value = yaml_document_get_node(document, pair->value);
 287
 288                 if (key->type != YAML_SCALAR_NODE)
 289                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 290                                 return pet_expr_free(expr));
 291
 292                 if (!strcmp((char *) key->data.scalar.value, "relation"))
 293                         expr->acc.access = extract_map(ctx, document, value);
 294                 if (!strcmp((char *) key->data.scalar.value, "index"))
 295                         expr->acc.index = extract_multi_pw_aff(ctx, document,
 296                                                                 value);
 297                 if (!strcmp((char *) key->data.scalar.value, "reference"))
 298                         expr->acc.ref_id = extract_id(ctx, document, value);
 299                 if (!strcmp((char *) key->data.scalar.value, "read"))
 300                         expr->acc.read = extract_int(ctx, document, value);
 301                 if (!strcmp((char *) key->data.scalar.value, "write"))
 302                         expr->acc.write = extract_int(ctx, document, value);
 303         }
 304
 305         return expr;
 306 }
 307
 308 /* Extract operation expression specific fields from "node" and
 309  * update "expr" accordingly.
 310  */
 311 static struct pet_expr *extract_expr_op(isl_ctx *ctx,
 312         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 313 {
 314         yaml_node_pair_t *pair;
 315
 316         for (pair = node->data.mapping.pairs.start;
 317              pair < node->data.mapping.pairs.top; ++pair) {
 318                 yaml_node_t *key, *value;
 319
 320                 key = yaml_document_get_node(document, pair->key);
 321                 value = yaml_document_get_node(document, pair->value);
 322
 323                 if (key->type != YAML_SCALAR_NODE)
 324                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 325                                 return pet_expr_free(expr));
 326
 327                 if (!strcmp((char *) key->data.scalar.value, "operation"))
 328                         expr->op = extract_op(ctx, document, value);
 329         }
 330
 331         return expr;
 332 }
 333
 334 /* Extract pet_expr_call specific fields from "node" and
 335  * update "expr" accordingly.
 336  */
 337 static struct pet_expr *extract_expr_call(isl_ctx *ctx,
 338         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 339 {
 340         yaml_node_pair_t *pair;
 341
 342         for (pair = node->data.mapping.pairs.start;
 343              pair < node->data.mapping.pairs.top; ++pair) {
 344                 yaml_node_t *key, *value;
 345
 346                 key = yaml_document_get_node(document, pair->key);
 347                 value = yaml_document_get_node(document, pair->value);
 348
 349                 if (key->type != YAML_SCALAR_NODE)
 350                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 351                                 return pet_expr_free(expr));
 352
 353                 if (!strcmp((char *) key->data.scalar.value, "name"))
 354                         expr->name = extract_string(ctx, document, value);
 355         }
 356
 357         return expr;
 358 }
 359
 360 /* Extract pet_expr_cast specific fields from "node" and
 361  * update "expr" accordingly.
 362  */
 363 static struct pet_expr *extract_expr_cast(isl_ctx *ctx,
 364         yaml_document_t *document, yaml_node_t *node, struct pet_expr *expr)
 365 {
 366         yaml_node_pair_t *pair;
 367
 368         for (pair = node->data.mapping.pairs.start;
 369              pair < node->data.mapping.pairs.top; ++pair) {
 370                 yaml_node_t *key, *value;
 371
 372                 key = yaml_document_get_node(document, pair->key);
 373                 value = yaml_document_get_node(document, pair->value);
 374
 375                 if (key->type != YAML_SCALAR_NODE)
 376                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 377                                 return pet_expr_free(expr));
 378
 379                 if (!strcmp((char *) key->data.scalar.value, "type_name"))
 380                         expr->type_name = extract_string(ctx, document, value);
 381         }
 382
 383         return expr;
 384 }
 385
 386 /* Extract a pet_expr from "node".
 387  *
 388  * We first extract the type and arguments of the expression and
 389  * then extract additional fields depending on the type.
 390  */
 391 static struct pet_expr *extract_expr(isl_ctx *ctx, yaml_document_t *document,
 392         yaml_node_t *node)
 393 {
 394         struct pet_expr *expr;
 395         yaml_node_pair_t *pair;
 396
 397         if (node->type != YAML_MAPPING_NODE)
 398                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 399                         return NULL);
 400
 401         expr = isl_calloc_type(ctx, struct pet_expr);
 402         if (!expr)
 403                 return NULL;
 404
 405         for (pair = node->data.mapping.pairs.start;
 406              pair < node->data.mapping.pairs.top; ++pair) {
 407                 yaml_node_t *key, *value;
 408
 409                 key = yaml_document_get_node(document, pair->key);
 410                 value = yaml_document_get_node(document, pair->value);
 411
 412                 if (key->type != YAML_SCALAR_NODE)
 413                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 414                                 return pet_expr_free(expr));
 415
 416                 if (!strcmp((char *) key->data.scalar.value, "type"))
 417                         expr->type = extract_type(ctx, document, value);
 418
 419                 if (!strcmp((char *) key->data.scalar.value, "arguments"))
 420                         expr = extract_arguments(ctx, document, value, expr);
 421                 if (!expr)
 422                         return NULL;
 423         }
 424
 425         switch (expr->type) {
 426         case pet_expr_access:
 427                 expr = extract_expr_access(ctx, document, node, expr);
 428                 break;
 429         case pet_expr_double:
 430                 expr = extract_expr_double(ctx, document, node, expr);
 431                 break;
 432         case pet_expr_call:
 433                 expr = extract_expr_call(ctx, document, node, expr);
 434                 break;
 435         case pet_expr_cast:
 436                 expr = extract_expr_cast(ctx, document, node, expr);
 437                 break;
 438         case pet_expr_unary:
 439         case pet_expr_binary:
 440         case pet_expr_ternary:
 441                 expr = extract_expr_op(ctx, document, node, expr);
 442                 break;
 443         }
 444
 445         return expr;
 446 }
 447
 448 static struct pet_stmt *extract_stmt_arguments(isl_ctx *ctx,
 449         yaml_document_t *document, yaml_node_t *node, struct pet_stmt *stmt)
 450 {
 451         int i;
 452         yaml_node_item_t *item;
 453
 454         if (node->type != YAML_SEQUENCE_NODE)
 455                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 456                         return pet_stmt_free(stmt));
 457
 458         stmt->n_arg = node->data.sequence.items.top
 459                                 - node->data.sequence.items.start;
 460         stmt->args = isl_calloc_array(ctx, struct pet_expr *, stmt->n_arg);
 461         if (!stmt->args)
 462                 return pet_stmt_free(stmt);
 463
 464         for (item = node->data.sequence.items.start, i = 0;
 465              item < node->data.sequence.items.top; ++item, ++i) {
 466                 yaml_node_t *n;
 467
 468                 n = yaml_document_get_node(document, *item);
 469                 stmt->args[i] = extract_expr(ctx, document, n);
 470                 if (!stmt->args[i])
 471                         return pet_stmt_free(stmt);
 472         }
 473
 474         return stmt;
 475 }
 476
 477 static struct pet_stmt *extract_stmt(isl_ctx *ctx, yaml_document_t *document,
 478         yaml_node_t *node)
 479 {
 480         struct pet_stmt *stmt;
 481         yaml_node_pair_t * pair;
 482
 483         if (node->type != YAML_MAPPING_NODE)
 484                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 485                         return NULL);
 486
 487         stmt = isl_calloc_type(ctx, struct pet_stmt);
 488         if (!stmt)
 489                 return NULL;
 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_stmt_free(stmt));
 501
 502                 if (!strcmp((char *) key->data.scalar.value, "line"))
 503                         stmt->line = extract_int(ctx, document, value);
 504                 if (!strcmp((char *) key->data.scalar.value, "domain"))
 505                         stmt->domain = extract_set(ctx, document, value);
 506                 if (!strcmp((char *) key->data.scalar.value, "schedule"))
 507                         stmt->schedule = extract_map(ctx, document, value);
 508                 if (!strcmp((char *) key->data.scalar.value, "body"))
 509                         stmt->body = extract_expr(ctx, document, value);
 510
 511                 if (!strcmp((char *) key->data.scalar.value, "arguments"))
 512                         stmt = extract_stmt_arguments(ctx, document,
 513                                                         value, stmt);
 514                 if (!stmt)
 515                         return NULL;
 516         }
 517
 518         return stmt;
 519 }
 520
 521 static struct pet_scop *extract_statements(isl_ctx *ctx,
 522         yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
 523 {
 524         int i;
 525         yaml_node_item_t *item;
 526
 527         if (node->type != YAML_SEQUENCE_NODE)
 528                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 529                         return NULL);
 530
 531         scop->n_stmt = node->data.sequence.items.top
 532                                 - node->data.sequence.items.start;
 533         scop->stmts = isl_calloc_array(ctx, struct pet_stmt *, scop->n_stmt);
 534         if (!scop->stmts)
 535                 return pet_scop_free(scop);
 536
 537         for (item = node->data.sequence.items.start, i = 0;
 538              item < node->data.sequence.items.top; ++item, ++i) {
 539                 yaml_node_t *n;
 540
 541                 n = yaml_document_get_node(document, *item);
 542                 scop->stmts[i] = extract_stmt(ctx, document, n);
 543                 if (!scop->stmts[i])
 544                         return pet_scop_free(scop);
 545         }
 546
 547         return scop;
 548 }
 549
 550 /* Extract a pet_implication from "node".
 551  */
 552 static struct pet_implication *extract_implication(isl_ctx *ctx,
 553         yaml_document_t *document, yaml_node_t *node)
 554 {
 555         struct pet_implication *implication;
 556         yaml_node_pair_t * pair;
 557
 558         if (node->type != YAML_MAPPING_NODE)
 559                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 560                         return NULL);
 561
 562         implication = isl_calloc_type(ctx, struct pet_implication);
 563         if (!implication)
 564                 return NULL;
 565
 566         for (pair = node->data.mapping.pairs.start;
 567              pair < node->data.mapping.pairs.top; ++pair) {
 568                 yaml_node_t *key, *value;
 569
 570                 key = yaml_document_get_node(document, pair->key);
 571                 value = yaml_document_get_node(document, pair->value);
 572
 573                 if (key->type != YAML_SCALAR_NODE)
 574                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 575                                 return pet_implication_free(implication));
 576
 577                 if (!strcmp((char *) key->data.scalar.value, "satisfied"))
 578                         implication->satisfied =
 579                                             extract_int(ctx, document, value);
 580                 if (!strcmp((char *) key->data.scalar.value, "extension"))
 581                         implication->extension =
 582                                             extract_map(ctx, document, value);
 583         }
 584
 585         return implication;
 586 }
 587
 588 /* Extract a sequence of implications from "node" and
 589  * store them in scop->implications.
 590  */
 591 static struct pet_scop *extract_implications(isl_ctx *ctx,
 592         yaml_document_t *document, yaml_node_t *node, struct pet_scop *scop)
 593 {
 594         int i;
 595         yaml_node_item_t *item;
 596
 597         if (node->type != YAML_SEQUENCE_NODE)
 598                 isl_die(ctx, isl_error_invalid, "expecting sequence",
 599                         return NULL);
 600
 601         scop->n_implication = node->data.sequence.items.top
 602                                 - node->data.sequence.items.start;
 603         scop->implications = isl_calloc_array(ctx, struct pet_implication *,
 604                                                 scop->n_implication);
 605         if (!scop->implications)
 606                 return pet_scop_free(scop);
 607
 608         for (item = node->data.sequence.items.start, i = 0;
 609              item < node->data.sequence.items.top; ++item, ++i) {
 610                 yaml_node_t *n;
 611
 612                 n = yaml_document_get_node(document, *item);
 613                 scop->implications[i] = extract_implication(ctx, document, n);
 614                 if (!scop->implications[i])
 615                         return pet_scop_free(scop);
 616         }
 617
 618         return scop;
 619 }
 620
 621 static struct pet_scop *extract_scop(isl_ctx *ctx, yaml_document_t *document,
 622         yaml_node_t *node)
 623 {
 624         struct pet_scop *scop;
 625         yaml_node_pair_t * pair;
 626
 627         if (!node)
 628                 return NULL;
 629
 630         if (node->type != YAML_MAPPING_NODE)
 631                 isl_die(ctx, isl_error_invalid, "expecting mapping",
 632                         return NULL);
 633
 634         scop = pet_scop_alloc(ctx);
 635         if (!scop)
 636                 return NULL;
 637
 638         for (pair = node->data.mapping.pairs.start;
 639              pair < node->data.mapping.pairs.top; ++pair) {
 640                 yaml_node_t *key, *value;
 641
 642                 key = yaml_document_get_node(document, pair->key);
 643                 value = yaml_document_get_node(document, pair->value);
 644
 645                 if (key->type != YAML_SCALAR_NODE)
 646                         isl_die(ctx, isl_error_invalid, "expecting scalar key",
 647                                 return pet_scop_free(scop));
 648                 if (!strcmp((char *) key->data.scalar.value, "context"))
 649                         scop->context = extract_set(ctx, document, value);
 650                 if (!strcmp((char *) key->data.scalar.value, "context_value"))
 651                         scop->context_value = extract_set(ctx, document, value);
 652                 if (!strcmp((char *) key->data.scalar.value, "arrays"))
 653                         scop = extract_arrays(ctx, document, value, scop);
 654                 if (!strcmp((char *) key->data.scalar.value, "statements"))
 655                         scop = extract_statements(ctx, document, value, scop);
 656                 if (!strcmp((char *) key->data.scalar.value, "implications"))
 657                         scop = extract_implications(ctx, document, value, scop);
 658                 if (!scop)
 659                         return NULL;
 660         }
 661
 662         if (!scop->context_value) {
 663                 isl_space *space = isl_space_params_alloc(ctx, 0);
 664                 scop->context_value = isl_set_universe(space);
 665                 if (!scop->context_value)
 666                         return pet_scop_free(scop);
 667         }
 668
 669         return scop;
 670 }
 671
 672 /* Extract a pet_scop from the YAML description in "in".
 673  */
 674 struct pet_scop *pet_scop_parse(isl_ctx *ctx, FILE *in)
 675 {
 676         struct pet_scop *scop = NULL;
 677         yaml_parser_t parser;
 678         yaml_node_t *root;
 679         yaml_document_t document = { 0 };
 680
 681         yaml_parser_initialize(&parser);
 682
 683         yaml_parser_set_input_file(&parser, in);
 684
 685         if (!yaml_parser_load(&parser, &document))
 686                 goto error;
 687
 688         root = yaml_document_get_root_node(&document);
 689
 690         scop = extract_scop(ctx, &document, root);
 691
 692         yaml_document_delete(&document);
 693
 694         yaml_parser_delete(&parser);
 695
 696         return scop;
 697 error:
 698         yaml_parser_delete(&parser);
 699         pet_scop_free(scop);
 700         return NULL;
 701 }