emit.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 <yaml.h>
  36
  37 #include "expr.h"
  38 #include "loc.h"
  39 #include "scop.h"
  40 #include "scop_yaml.h"
  41 #include "tree.h"
  42
  43 static int emit_string(yaml_emitter_t *emitter, const char *str)
  44 {
  45         yaml_event_t event;
  46
  47         if (!yaml_scalar_event_initialize(&event, NULL, NULL,
  48                                     (yaml_char_t *) str, strlen(str),
  49                                     1, 1, YAML_PLAIN_SCALAR_STYLE))
  50                 return -1;
  51         if (!yaml_emitter_emit(emitter, &event))
  52                 return -1;
  53
  54         return 0;
  55 }
  56
  57 /* Print the string "name" and the string "str" to "emitter".
  58  */
  59 static int emit_named_string(yaml_emitter_t *emitter, const char *name,
  60         const char *str)
  61 {
  62         if (emit_string(emitter, name) < 0)
  63                 return -1;
  64         if (emit_string(emitter, str) < 0)
  65                 return -1;
  66         return 0;
  67 }
  68
  69 /* Print the isl_id "id" to "emitter".
  70  */
  71 static int emit_id(yaml_emitter_t *emitter, __isl_keep isl_id *id)
  72 {
  73         return emit_string(emitter, isl_id_get_name(id));
  74 }
  75
  76 /* Print the string "name" and the isl_id "id" to "emitter".
  77  */
  78 static int emit_named_id(yaml_emitter_t *emitter, const char *name,
  79         __isl_keep isl_id *id)
  80 {
  81         if (emit_string(emitter, name) < 0)
  82                 return -1;
  83         if (emit_id(emitter, id) < 0)
  84                 return -1;
  85         return 0;
  86 }
  87
  88 static int emit_int(yaml_emitter_t *emitter, int i)
  89 {
  90         char buffer[40];
  91
  92         snprintf(buffer, sizeof(buffer), "%d", i);
  93         return emit_string(emitter, buffer);
  94 }
  95
  96 static int emit_named_int(yaml_emitter_t *emitter, const char *name, int i)
  97 {
  98         if (emit_string(emitter, name) < 0)
  99                 return -1;
 100         if (emit_int(emitter, i) < 0)
 101                 return -1;
 102         return 0;
 103 }
 104
 105 /* Print the unsigned integer "u" to "emitter".
 106  */
 107 static int emit_unsigned(yaml_emitter_t *emitter, unsigned u)
 108 {
 109         char buffer[40];
 110
 111         snprintf(buffer, sizeof(buffer), "%u", u);
 112         return emit_string(emitter, buffer);
 113 }
 114
 115 /* Print the string "name" and the unsigned integer "u" to "emitter".
 116  */
 117 static int emit_named_unsigned(yaml_emitter_t *emitter, const char *name,
 118         unsigned u)
 119 {
 120         if (emit_string(emitter, name) < 0)
 121                 return -1;
 122         if (emit_int(emitter, u) < 0)
 123                 return -1;
 124         return 0;
 125 }
 126
 127 static int emit_double(yaml_emitter_t *emitter, double d)
 128 {
 129         char buffer[40];
 130
 131         snprintf(buffer, sizeof(buffer), "%g", d);
 132         return emit_string(emitter, buffer);
 133 }
 134
 135 static int emit_map(yaml_emitter_t *emitter, __isl_keep isl_map *map)
 136 {
 137         isl_ctx *ctx = isl_map_get_ctx(map);
 138         isl_printer *p;
 139         char *str;
 140         int r;
 141
 142         p = isl_printer_to_str(ctx);
 143         p = isl_printer_print_map(p, map);
 144         str = isl_printer_get_str(p);
 145         isl_printer_free(p);
 146         r = emit_string(emitter, str);
 147         free(str);
 148         return r;
 149 }
 150
 151 /* Print the isl_val "val" to "emitter".
 152  */
 153 static int emit_val(yaml_emitter_t *emitter, __isl_keep isl_val *val)
 154 {
 155         isl_ctx *ctx = isl_val_get_ctx(val);
 156         isl_printer *p;
 157         char *str;
 158         int r;
 159
 160         p = isl_printer_to_str(ctx);
 161         p = isl_printer_print_val(p, val);
 162         str = isl_printer_get_str(p);
 163         isl_printer_free(p);
 164         r = emit_string(emitter, str);
 165         free(str);
 166         return r;
 167 }
 168
 169 /* Print the string "name" and the isl_val "val" to "emitter".
 170  */
 171 static int emit_named_val(yaml_emitter_t *emitter, const char *name,
 172         __isl_keep isl_val *val)
 173 {
 174         if (emit_string(emitter, name) < 0)
 175                 return -1;
 176         if (emit_val(emitter, val) < 0)
 177                 return -1;
 178         return 0;
 179 }
 180
 181 static int emit_set(yaml_emitter_t *emitter, __isl_keep isl_set *set)
 182 {
 183         isl_ctx *ctx = isl_set_get_ctx(set);
 184         isl_printer *p;
 185         char *str;
 186         int r;
 187
 188         p = isl_printer_to_str(ctx);
 189         p = isl_printer_print_set(p, set);
 190         str = isl_printer_get_str(p);
 191         isl_printer_free(p);
 192         r = emit_string(emitter, str);
 193         free(str);
 194         return r;
 195 }
 196
 197 static int emit_named_set(yaml_emitter_t *emitter, const char *name,
 198         __isl_keep isl_set *set)
 199 {
 200         if (emit_string(emitter, name) < 0)
 201                 return -1;
 202         if (emit_set(emitter, set) < 0)
 203                 return -1;
 204         return 0;
 205 }
 206
 207 /* Print the string "name" and the map "map" to "emitter".
 208  */
 209 static int emit_named_map(yaml_emitter_t *emitter, const char *name,
 210         __isl_keep isl_map *map)
 211 {
 212         if (emit_string(emitter, name) < 0)
 213                 return -1;
 214         if (emit_map(emitter, map) < 0)
 215                 return -1;
 216         return 0;
 217 }
 218
 219 /* Print the union set "uset" to "emitter".
 220  */
 221 static int emit_union_set(yaml_emitter_t *emitter,
 222         __isl_keep isl_union_set *uset)
 223 {
 224         isl_ctx *ctx = isl_union_set_get_ctx(uset);
 225         isl_printer *p;
 226         char *str;
 227         int r;
 228
 229         p = isl_printer_to_str(ctx);
 230         p = isl_printer_print_union_set(p, uset);
 231         str = isl_printer_get_str(p);
 232         isl_printer_free(p);
 233         r = emit_string(emitter, str);
 234         free(str);
 235         return r;
 236 }
 237
 238 /* Print the union map "umap" to "emitter".
 239  */
 240 static int emit_union_map(yaml_emitter_t *emitter,
 241         __isl_keep isl_union_map *umap)
 242 {
 243         isl_ctx *ctx = isl_union_map_get_ctx(umap);
 244         isl_printer *p;
 245         char *str;
 246         int r;
 247
 248         p = isl_printer_to_str(ctx);
 249         p = isl_printer_print_union_map(p, umap);
 250         str = isl_printer_get_str(p);
 251         isl_printer_free(p);
 252         r = emit_string(emitter, str);
 253         free(str);
 254         return r;
 255 }
 256
 257 /* Print the string "name" and the union set "uset" to "emitter".
 258  */
 259 static int emit_named_union_set(yaml_emitter_t *emitter, const char *name,
 260         __isl_keep isl_union_set *uset)
 261 {
 262         if (emit_string(emitter, name) < 0)
 263                 return -1;
 264         if (emit_union_set(emitter, uset) < 0)
 265                 return -1;
 266         return 0;
 267 }
 268
 269 /* Print the string "name" and the union map "umap" to "emitter".
 270  */
 271 static int emit_named_union_map(yaml_emitter_t *emitter, const char *name,
 272         __isl_keep isl_union_map *umap)
 273 {
 274         if (emit_string(emitter, name) < 0)
 275                 return -1;
 276         if (emit_union_map(emitter, umap) < 0)
 277                 return -1;
 278         return 0;
 279 }
 280
 281 /* Print the isl_multi_pw_aff "mpa" to "emitter".
 282  */
 283 static int emit_multi_pw_aff(yaml_emitter_t *emitter,
 284         __isl_keep isl_multi_pw_aff *mpa)
 285 {
 286         isl_ctx *ctx = isl_multi_pw_aff_get_ctx(mpa);
 287         isl_printer *p;
 288         char *str;
 289         int r;
 290
 291         p = isl_printer_to_str(ctx);
 292         p = isl_printer_print_multi_pw_aff(p, mpa);
 293         str = isl_printer_get_str(p);
 294         isl_printer_free(p);
 295         r = emit_string(emitter, str);
 296         free(str);
 297         return r;
 298 }
 299
 300 /* Print the string "name" and the isl_multi_pw_aff "mpa" to "emitter".
 301  */
 302 static int emit_named_multi_pw_aff(yaml_emitter_t *emitter, const char *name,
 303         __isl_keep isl_multi_pw_aff *mpa)
 304 {
 305         if (emit_string(emitter, name) < 0)
 306                 return -1;
 307         if (emit_multi_pw_aff(emitter, mpa) < 0)
 308                 return -1;
 309         return 0;
 310 }
 311
 312 /* Print "type" to "emitter".
 313  */
 314 static int emit_type(yaml_emitter_t *emitter, struct pet_type *type)
 315 {
 316         yaml_event_t event;
 317
 318         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 319                                                 YAML_BLOCK_MAPPING_STYLE))
 320                 return -1;
 321         if (!yaml_emitter_emit(emitter, &event))
 322                 return -1;
 323
 324         if (emit_string(emitter, "name") < 0)
 325                 return -1;
 326         if (emit_string(emitter, type->name) < 0)
 327                 return -1;
 328
 329         if (emit_string(emitter, "definition") < 0)
 330                 return -1;
 331         if (emit_string(emitter, type->definition) < 0)
 332                 return -1;
 333
 334         if (!yaml_mapping_end_event_initialize(&event))
 335                 return -1;
 336         if (!yaml_emitter_emit(emitter, &event))
 337                 return -1;
 338
 339         return 0;
 340 }
 341
 342 /* Print the list of "n_type" "types", if any, to "emitter".
 343  */
 344 static int emit_types(yaml_emitter_t *emitter, int n_type,
 345         struct pet_type **types)
 346 {
 347         int i;
 348         yaml_event_t event;
 349
 350         if (n_type == 0)
 351                 return 0;
 352
 353         if (emit_string(emitter, "types") < 0)
 354                 return -1;
 355         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 356                                                 YAML_BLOCK_SEQUENCE_STYLE))
 357                 return -1;
 358         if (!yaml_emitter_emit(emitter, &event))
 359                 return -1;
 360
 361         for (i = 0; i < n_type; ++i)
 362                 if (emit_type(emitter, types[i]) < 0)
 363                         return -1;
 364
 365         if (!yaml_sequence_end_event_initialize(&event))
 366                 return -1;
 367         if (!yaml_emitter_emit(emitter, &event))
 368                 return -1;
 369
 370         return 0;
 371 }
 372
 373 static int emit_array(yaml_emitter_t *emitter, struct pet_array *array)
 374 {
 375         yaml_event_t event;
 376
 377         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 378                                                 YAML_BLOCK_MAPPING_STYLE))
 379                 return -1;
 380         if (!yaml_emitter_emit(emitter, &event))
 381                 return -1;
 382
 383         if (emit_string(emitter, "context") < 0)
 384                 return -1;
 385         if (emit_set(emitter, array->context) < 0)
 386                 return -1;
 387
 388         if (emit_string(emitter, "extent") < 0)
 389                 return -1;
 390         if (emit_set(emitter, array->extent) < 0)
 391                 return -1;
 392
 393         if (array->value_bounds) {
 394                 if (emit_string(emitter, "value_bounds") < 0)
 395                         return -1;
 396                 if (emit_set(emitter, array->value_bounds) < 0)
 397                         return -1;
 398         }
 399
 400         if (emit_string(emitter, "element_type") < 0)
 401                 return -1;
 402         if (emit_string(emitter, array->element_type) < 0)
 403                 return -1;
 404         if (emit_named_int(emitter, "element_size", array->element_size) < 0)
 405                 return -1;
 406
 407         if (array->element_is_record)
 408                 if (emit_named_int(emitter, "element_is_record",
 409                                         array->element_is_record) < 0)
 410                         return -1;
 411
 412         if (array->live_out) {
 413                 if (emit_string(emitter, "live_out") < 0)
 414                         return -1;
 415                 if (emit_string(emitter, "1") < 0)
 416                         return -1;
 417         }
 418
 419         if (array->uniquely_defined) {
 420                 if (emit_string(emitter, "uniquely_defined") < 0)
 421                         return -1;
 422                 if (emit_string(emitter, "1") < 0)
 423                         return -1;
 424         }
 425
 426         if (array->declared && emit_named_int(emitter, "declared", 1) < 0)
 427                 return -1;
 428         if (array->exposed && emit_named_int(emitter, "exposed", 1) < 0)
 429                 return -1;
 430
 431         if (!yaml_mapping_end_event_initialize(&event))
 432                 return -1;
 433         if (!yaml_emitter_emit(emitter, &event))
 434                 return -1;
 435
 436         return 0;
 437 }
 438
 439 static int emit_arrays(yaml_emitter_t *emitter, int n_array,
 440         struct pet_array **arrays)
 441 {
 442         int i;
 443         yaml_event_t event;
 444
 445         if (emit_string(emitter, "arrays") < 0)
 446                 return -1;
 447         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 448                                                 YAML_BLOCK_SEQUENCE_STYLE))
 449                 return -1;
 450         if (!yaml_emitter_emit(emitter, &event))
 451                 return -1;
 452
 453         for (i = 0; i < n_array; ++i)
 454                 if (emit_array(emitter, arrays[i]) < 0)
 455                         return -1;
 456
 457         if (!yaml_sequence_end_event_initialize(&event))
 458                 return -1;
 459         if (!yaml_emitter_emit(emitter, &event))
 460                 return -1;
 461
 462         return 0;
 463 }
 464
 465 static int emit_expr_type(yaml_emitter_t *emitter, enum pet_expr_type type)
 466 {
 467         if (emit_string(emitter, pet_type_str(type)) < 0)
 468                 return -1;
 469         return 0;
 470 }
 471
 472 /* Print the fields of the access expression "expr" to "emitter".
 473  *
 474  * Only print the access relations that are present and relevant
 475  * for the type of access.
 476  *
 477  * If the depth of the access is equal to the depth that can be derived from
 478  * the index expression, then there is no need to print it.
 479  */
 480 static int emit_access_expr(yaml_emitter_t *emitter, __isl_keep pet_expr *expr)
 481 {
 482         int depth;
 483
 484         if (expr->acc.kill && expr->acc.access[pet_expr_access_fake_killed] &&
 485             emit_named_union_map(emitter, "killed",
 486                     expr->acc.access[pet_expr_access_fake_killed]) < 0)
 487                 return -1;
 488         if (expr->acc.read && expr->acc.access[pet_expr_access_may_read] &&
 489             emit_named_union_map(emitter, "may_read",
 490                     expr->acc.access[pet_expr_access_may_read]) < 0)
 491                 return -1;
 492         if (expr->acc.write && expr->acc.access[pet_expr_access_may_write] &&
 493             emit_named_union_map(emitter, "may_write",
 494                     expr->acc.access[pet_expr_access_may_write]) < 0)
 495                 return -1;
 496         if (expr->acc.write && expr->acc.access[pet_expr_access_must_write] &&
 497             emit_named_union_map(emitter, "must_write",
 498                     expr->acc.access[pet_expr_access_must_write]) < 0)
 499                 return -1;
 500         if (emit_named_multi_pw_aff(emitter, "index", expr->acc.index) < 0)
 501                 return -1;
 502         depth = isl_multi_pw_aff_dim(expr->acc.index, isl_dim_out);
 503         if (expr->acc.depth != depth &&
 504             emit_named_int(emitter, "depth", expr->acc.depth) < 0)
 505                 return -1;
 506         if (expr->acc.ref_id &&
 507             emit_named_id(emitter, "reference", expr->acc.ref_id) < 0)
 508                 return -1;
 509         if (expr->acc.kill) {
 510                 if (emit_named_unsigned(emitter, "kill", 1) < 0)
 511                         return -1;
 512         } else {
 513                 if (emit_string(emitter, "read") < 0)
 514                         return -1;
 515                 if (emit_int(emitter, expr->acc.read) < 0)
 516                         return -1;
 517                 if (emit_string(emitter, "write") < 0)
 518                         return -1;
 519                 if (emit_int(emitter, expr->acc.write) < 0)
 520                         return -1;
 521         }
 522
 523         return 0;
 524 }
 525
 526 static int emit_expr(yaml_emitter_t *emitter, __isl_keep pet_expr *expr)
 527 {
 528         yaml_event_t event;
 529
 530         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 531                                                 YAML_BLOCK_MAPPING_STYLE))
 532                 return -1;
 533         if (!yaml_emitter_emit(emitter, &event))
 534                 return -1;
 535
 536         if (emit_string(emitter, "type") < 0)
 537                 return -1;
 538         if (emit_expr_type(emitter, expr->type) < 0)
 539                 return -1;
 540
 541         switch (expr->type) {
 542         case pet_expr_error:
 543                 return -1;
 544         case pet_expr_int:
 545                 if (emit_named_val(emitter, "value", expr->i) < 0)
 546                         return -1;
 547                 break;
 548         case pet_expr_double:
 549                 if (emit_string(emitter, "value") < 0)
 550                         return -1;
 551                 if (emit_double(emitter, expr->d.val) < 0)
 552                         return -1;
 553                 if (emit_string(emitter, "string") < 0)
 554                         return -1;
 555                 if (emit_string(emitter, expr->d.s) < 0)
 556                         return -1;
 557                 break;
 558         case pet_expr_access:
 559                 if (emit_access_expr(emitter, expr) < 0)
 560                         return -1;
 561                 break;
 562         case pet_expr_op:
 563                 if (emit_string(emitter, "operation") < 0)
 564                         return -1;
 565                 if (emit_string(emitter, pet_op_str(expr->op)) < 0)
 566                         return -1;
 567                 break;
 568         case pet_expr_call:
 569                 if (emit_string(emitter, "name") < 0)
 570                         return -1;
 571                 if (emit_string(emitter, expr->name) < 0)
 572                         return -1;
 573                 break;
 574         case pet_expr_cast:
 575                 if (emit_string(emitter, "type_name") < 0)
 576                         return -1;
 577                 if (emit_string(emitter, expr->type_name) < 0)
 578                         return -1;
 579                 break;
 580         }
 581
 582         if (expr->n_arg > 0) {
 583                 int i;
 584
 585                 if (emit_string(emitter, "arguments") < 0)
 586                         return -1;
 587                 if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 588                                                     YAML_BLOCK_SEQUENCE_STYLE))
 589                         return -1;
 590                 if (!yaml_emitter_emit(emitter, &event))
 591                         return -1;
 592
 593                 for (i = 0; i < expr->n_arg; ++i)
 594                         if (emit_expr(emitter, expr->args[i]) < 0)
 595                                 return -1;
 596
 597                 if (!yaml_sequence_end_event_initialize(&event))
 598                         return -1;
 599                 if (!yaml_emitter_emit(emitter, &event))
 600                         return -1;
 601         }
 602
 603         if (!yaml_mapping_end_event_initialize(&event))
 604                 return -1;
 605         if (!yaml_emitter_emit(emitter, &event))
 606                 return -1;
 607
 608         return 0;
 609 }
 610
 611 /* Print the string "name" and the expression "expr" to "emitter".
 612  */
 613 static int emit_named_expr(yaml_emitter_t *emitter, const char *name,
 614          __isl_keep pet_expr *expr)
 615 {
 616         if (emit_string(emitter, name) < 0)
 617                 return -1;
 618         if (emit_expr(emitter, expr) < 0)
 619                 return -1;
 620         return 0;
 621 }
 622
 623 /* Print "type" to "emitter".
 624  */
 625 static int emit_tree_type(yaml_emitter_t *emitter, enum pet_tree_type type)
 626 {
 627         if (emit_string(emitter, pet_tree_type_str(type)) < 0)
 628                 return -1;
 629         return 0;
 630 }
 631
 632 /* Recursively print "tree" to "emitter".
 633  */
 634 static int emit_tree(yaml_emitter_t *emitter, __isl_keep pet_tree *tree)
 635 {
 636         yaml_event_t event;
 637         int i;
 638
 639         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 640                                                 YAML_BLOCK_MAPPING_STYLE))
 641                 return -1;
 642         if (!yaml_emitter_emit(emitter, &event))
 643                 return -1;
 644
 645         if (emit_string(emitter, "type") < 0)
 646                 return -1;
 647         if (emit_tree_type(emitter, tree->type) < 0)
 648                 return -1;
 649
 650         switch (tree->type) {
 651         case pet_tree_error:
 652                 return -1;
 653         case pet_tree_block:
 654                 if (emit_named_int(emitter, "block", tree->u.b.block) < 0)
 655                         return -1;
 656                 if (tree->u.b.n == 0)
 657                         break;
 658
 659                 if (emit_string(emitter, "children") < 0)
 660                         return -1;
 661                 if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 662                                                     YAML_BLOCK_SEQUENCE_STYLE))
 663                         return -1;
 664                 if (!yaml_emitter_emit(emitter, &event))
 665                         return -1;
 666
 667                 for (i = 0; i < tree->u.b.n; ++i)
 668                         if (emit_tree(emitter, tree->u.b.child[i]) < 0)
 669                                 return -1;
 670
 671                 if (!yaml_sequence_end_event_initialize(&event))
 672                         return -1;
 673                 if (!yaml_emitter_emit(emitter, &event))
 674                         return -1;
 675                 break;
 676         case pet_tree_break:
 677         case pet_tree_continue:
 678                 break;
 679         case pet_tree_decl:
 680                 if (emit_named_expr(emitter, "variable", tree->u.d.var) < 0)
 681                         return -1;
 682                 break;
 683         case pet_tree_decl_init:
 684                 if (emit_named_expr(emitter, "variable", tree->u.d.var) < 0)
 685                         return -1;
 686                 if (emit_named_expr(emitter,
 687                                     "initialization", tree->u.d.init) < 0)
 688                         return -1;
 689                 break;
 690         case pet_tree_expr:
 691                 if (emit_named_expr(emitter, "expr", tree->u.e.expr) < 0)
 692                         return -1;
 693                 break;
 694         case pet_tree_for:
 695                 if (tree->u.l.independent)
 696                         if (emit_named_int(emitter, "independent", 1) < 0)
 697                                 return -1;
 698                 if (emit_named_int(emitter, "declared", tree->u.l.declared) < 0)
 699                         return -1;
 700                 if (emit_named_expr(emitter, "variable", tree->u.l.iv) < 0)
 701                         return -1;
 702                 if (emit_named_expr(emitter,
 703                                     "initialization", tree->u.l.init) < 0)
 704                         return -1;
 705                 if (emit_named_expr(emitter, "condition", tree->u.l.cond) < 0)
 706                         return -1;
 707                 if (emit_named_expr(emitter, "increment", tree->u.l.inc) < 0)
 708                         return -1;
 709                 if (emit_string(emitter, "body") < 0)
 710                         return -1;
 711                 if (emit_tree(emitter, tree->u.l.body) < 0)
 712                         return -1;
 713                 break;
 714         case pet_tree_while:
 715                 if (emit_named_expr(emitter, "condition", tree->u.l.cond) < 0)
 716                         return -1;
 717                 if (emit_string(emitter, "body") < 0)
 718                         return -1;
 719                 if (emit_tree(emitter, tree->u.l.body) < 0)
 720                         return -1;
 721                 break;
 722         case pet_tree_infinite_loop:
 723                 if (emit_string(emitter, "body") < 0)
 724                         return -1;
 725                 if (emit_tree(emitter, tree->u.l.body) < 0)
 726                         return -1;
 727                 break;
 728         case pet_tree_if:
 729                 if (emit_named_expr(emitter, "condition", tree->u.i.cond) < 0)
 730                         return -1;
 731                 if (emit_string(emitter, "then") < 0)
 732                         return -1;
 733                 if (emit_tree(emitter, tree->u.i.then_body) < 0)
 734                         return -1;
 735                 break;
 736         case pet_tree_if_else:
 737                 if (emit_named_expr(emitter, "condition", tree->u.i.cond) < 0)
 738                         return -1;
 739                 if (emit_string(emitter, "then") < 0)
 740                         return -1;
 741                 if (emit_tree(emitter, tree->u.i.then_body) < 0)
 742                         return -1;
 743                 if (emit_string(emitter, "else") < 0)
 744                         return -1;
 745                 if (emit_tree(emitter, tree->u.i.else_body) < 0)
 746                         return -1;
 747                 break;
 748         }
 749
 750         if (!yaml_mapping_end_event_initialize(&event))
 751                 return -1;
 752         if (!yaml_emitter_emit(emitter, &event))
 753                 return -1;
 754
 755         return 0;
 756 }
 757
 758 static int emit_stmt(yaml_emitter_t *emitter, struct pet_stmt *stmt)
 759 {
 760         yaml_event_t event;
 761
 762         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 763                                                 YAML_BLOCK_MAPPING_STYLE))
 764                 return -1;
 765         if (!yaml_emitter_emit(emitter, &event))
 766                 return -1;
 767
 768         if (emit_string(emitter, "line") < 0)
 769                 return -1;
 770         if (emit_int(emitter, pet_loc_get_line(stmt->loc)) < 0)
 771                 return -1;
 772
 773         if (emit_string(emitter, "domain") < 0)
 774                 return -1;
 775         if (emit_set(emitter, stmt->domain) < 0)
 776                 return -1;
 777
 778         if (emit_string(emitter, "schedule") < 0)
 779                 return -1;
 780         if (emit_map(emitter, stmt->schedule) < 0)
 781                 return -1;
 782
 783         if (emit_string(emitter, "body") < 0)
 784                 return -1;
 785         if (emit_tree(emitter, stmt->body) < 0)
 786                 return -1;
 787
 788         if (stmt->n_arg > 0) {
 789                 int i;
 790
 791                 if (emit_string(emitter, "arguments") < 0)
 792                         return -1;
 793                 if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 794                                                     YAML_BLOCK_SEQUENCE_STYLE))
 795                         return -1;
 796                 if (!yaml_emitter_emit(emitter, &event))
 797                         return -1;
 798
 799                 for (i = 0; i < stmt->n_arg; ++i)
 800                         if (emit_expr(emitter, stmt->args[i]) < 0)
 801                                 return -1;
 802
 803                 if (!yaml_sequence_end_event_initialize(&event))
 804                         return -1;
 805                 if (!yaml_emitter_emit(emitter, &event))
 806                         return -1;
 807         }
 808
 809         if (!yaml_mapping_end_event_initialize(&event))
 810                 return -1;
 811         if (!yaml_emitter_emit(emitter, &event))
 812                 return -1;
 813
 814         return 0;
 815 }
 816
 817 static int emit_statements(yaml_emitter_t *emitter, int n_stmt,
 818         struct pet_stmt **stmts)
 819 {
 820         int i;
 821         yaml_event_t event;
 822
 823         if (emit_string(emitter, "statements") < 0)
 824                 return -1;
 825         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 826                                                 YAML_BLOCK_SEQUENCE_STYLE))
 827                 return -1;
 828         if (!yaml_emitter_emit(emitter, &event))
 829                 return -1;
 830
 831         for (i = 0; i < n_stmt; ++i)
 832                 if (emit_stmt(emitter, stmts[i]) < 0)
 833                         return -1;
 834
 835         if (!yaml_sequence_end_event_initialize(&event))
 836                 return -1;
 837         if (!yaml_emitter_emit(emitter, &event))
 838                 return -1;
 839
 840         return 0;
 841 }
 842
 843 /* Print "implication" to "emitter".
 844  */
 845 static int emit_implication(yaml_emitter_t *emitter,
 846         struct pet_implication *implication)
 847 {
 848         yaml_event_t event;
 849
 850         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 851                                                 YAML_BLOCK_MAPPING_STYLE))
 852                 return -1;
 853         if (!yaml_emitter_emit(emitter, &event))
 854                 return -1;
 855
 856         if (emit_named_int(emitter, "satisfied", implication->satisfied) < 0)
 857                 return -1;
 858
 859         if (emit_named_map(emitter, "extension", implication->extension) < 0)
 860                 return -1;
 861
 862         if (!yaml_mapping_end_event_initialize(&event))
 863                 return -1;
 864         if (!yaml_emitter_emit(emitter, &event))
 865                 return -1;
 866
 867         return 0;
 868 }
 869
 870 /* Print the list of "n_implication" "implications", if any, to "emitter".
 871  */
 872 static int emit_implications(yaml_emitter_t *emitter, int n_implication,
 873         struct pet_implication **implications)
 874 {
 875         int i;
 876         yaml_event_t event;
 877
 878         if (n_implication == 0)
 879                 return 0;
 880
 881         if (emit_string(emitter, "implications") < 0)
 882                 return -1;
 883         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 884                                                 YAML_BLOCK_SEQUENCE_STYLE))
 885                 return -1;
 886         if (!yaml_emitter_emit(emitter, &event))
 887                 return -1;
 888
 889         for (i = 0; i < n_implication; ++i)
 890                 if (emit_implication(emitter, implications[i]) < 0)
 891                         return -1;
 892
 893         if (!yaml_sequence_end_event_initialize(&event))
 894                 return -1;
 895         if (!yaml_emitter_emit(emitter, &event))
 896                 return -1;
 897
 898         return 0;
 899 }
 900
 901 /* Print "independence" to "emitter".
 902  */
 903 static int emit_independence(yaml_emitter_t *emitter,
 904         struct pet_independence *independence)
 905 {
 906         yaml_event_t event;
 907
 908         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 909                                                 YAML_BLOCK_MAPPING_STYLE))
 910                 return -1;
 911         if (!yaml_emitter_emit(emitter, &event))
 912                 return -1;
 913
 914         if (emit_named_union_map(emitter, "filter", independence->filter) < 0)
 915                 return -1;
 916
 917         if (emit_named_union_set(emitter, "local", independence->local) < 0)
 918                 return -1;
 919
 920         if (!yaml_mapping_end_event_initialize(&event))
 921                 return -1;
 922         if (!yaml_emitter_emit(emitter, &event))
 923                 return -1;
 924
 925         return 0;
 926 }
 927
 928 /* Print the list of "n_independence" "independences", if any, to "emitter".
 929  */
 930 static int emit_independences(yaml_emitter_t *emitter, int n_independence,
 931         struct pet_independence **independences)
 932 {
 933         int i;
 934         yaml_event_t event;
 935
 936         if (n_independence == 0)
 937                 return 0;
 938
 939         if (emit_string(emitter, "independences") < 0)
 940                 return -1;
 941         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 942                                                 YAML_BLOCK_SEQUENCE_STYLE))
 943                 return -1;
 944         if (!yaml_emitter_emit(emitter, &event))
 945                 return -1;
 946
 947         for (i = 0; i < n_independence; ++i)
 948                 if (emit_independence(emitter, independences[i]) < 0)
 949                         return -1;
 950
 951         if (!yaml_sequence_end_event_initialize(&event))
 952                 return -1;
 953         if (!yaml_emitter_emit(emitter, &event))
 954                 return -1;
 955
 956         return 0;
 957 }
 958
 959 static int emit_scop(yaml_emitter_t *emitter, struct pet_scop *scop)
 960 {
 961         yaml_event_t event;
 962
 963         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 964                                                 YAML_BLOCK_MAPPING_STYLE))
 965                 return -1;
 966         if (!yaml_emitter_emit(emitter, &event))
 967                 return -1;
 968
 969         if (emit_named_unsigned(emitter,
 970                                 "start", pet_loc_get_start(scop->loc)) < 0)
 971                 return -1;
 972         if (emit_named_unsigned(emitter, "end", pet_loc_get_end(scop->loc)) < 0)
 973                 return -1;
 974         if (emit_named_string(emitter,
 975                                 "indent", pet_loc_get_indent(scop->loc)) < 0)
 976                 return -1;
 977         if (emit_string(emitter, "context") < 0)
 978                 return -1;
 979         if (emit_set(emitter, scop->context) < 0)
 980                 return -1;
 981         if (!isl_set_plain_is_universe(scop->context_value) &&
 982             emit_named_set(emitter, "context_value", scop->context_value) < 0)
 983                 return -1;
 984
 985         if (emit_types(emitter, scop->n_type, scop->types) < 0)
 986                 return -1;
 987         if (emit_arrays(emitter, scop->n_array, scop->arrays) < 0)
 988                 return -1;
 989
 990         if (emit_statements(emitter, scop->n_stmt, scop->stmts) < 0)
 991                 return -1;
 992
 993         if (emit_implications(emitter, scop->n_implication,
 994                                 scop->implications) < 0)
 995                 return -1;
 996
 997         if (emit_independences(emitter, scop->n_independence,
 998                                 scop->independences) < 0)
 999                 return -1;
1000
1001         if (!yaml_mapping_end_event_initialize(&event))
1002                 return -1;
1003         if (!yaml_emitter_emit(emitter, &event))
1004                 return -1;
1005
1006         return 0;
1007 }
1008
1009 /* Print a YAML serialization of "scop" to "out".
1010  */
1011 int pet_scop_emit(FILE *out, struct pet_scop *scop)
1012 {
1013         yaml_emitter_t emitter;
1014         yaml_event_t event;
1015
1016         yaml_emitter_initialize(&emitter);
1017
1018         yaml_emitter_set_output_file(&emitter, out);
1019
1020         yaml_stream_start_event_initialize(&event, YAML_UTF8_ENCODING);
1021         if (!yaml_emitter_emit(&emitter, &event))
1022                 goto error;
1023
1024         if (!yaml_document_start_event_initialize(&event, NULL, NULL, NULL, 1))
1025                 goto error;
1026         if (!yaml_emitter_emit(&emitter, &event))
1027                 goto error;
1028
1029         if (emit_scop(&emitter, scop) < 0)
1030                 goto error;
1031
1032         if (!yaml_document_end_event_initialize(&event, 1))
1033                 goto error;
1034         if (!yaml_emitter_emit(&emitter, &event))
1035                 goto error;
1036
1037         yaml_stream_end_event_initialize(&event);
1038         if (!yaml_emitter_emit(&emitter, &event))
1039                 goto error;
1040
1041         yaml_emitter_delete(&emitter);
1042         return 0;
1043 error:
1044         yaml_emitter_delete(&emitter);
1045         return -1;
1046 }