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 the schedule "schedule" to "emitter".
 313  */
 314 static int emit_schedule(yaml_emitter_t *emitter,
 315         __isl_keep isl_schedule *schedule)
 316 {
 317         isl_ctx *ctx = isl_schedule_get_ctx(schedule);
 318         isl_printer *p;
 319         char *str;
 320         int r;
 321
 322         p = isl_printer_to_str(ctx);
 323         p = isl_printer_print_schedule(p, schedule);
 324         str = isl_printer_get_str(p);
 325         isl_printer_free(p);
 326         r = emit_string(emitter, str);
 327         free(str);
 328         return r;
 329 }
 330
 331 /* Print the string "name" and the schedule "schedule" to "emitter".
 332  */
 333 static int emit_named_schedule(yaml_emitter_t *emitter, const char *name,
 334         __isl_keep isl_schedule *schedule)
 335 {
 336         if (emit_string(emitter, name) < 0)
 337                 return -1;
 338         if (emit_schedule(emitter, schedule) < 0)
 339                 return -1;
 340         return 0;
 341 }
 342
 343 /* Print "type" to "emitter".
 344  */
 345 static int emit_type(yaml_emitter_t *emitter, struct pet_type *type)
 346 {
 347         yaml_event_t event;
 348
 349         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 350                                                 YAML_BLOCK_MAPPING_STYLE))
 351                 return -1;
 352         if (!yaml_emitter_emit(emitter, &event))
 353                 return -1;
 354
 355         if (emit_string(emitter, "name") < 0)
 356                 return -1;
 357         if (emit_string(emitter, type->name) < 0)
 358                 return -1;
 359
 360         if (emit_string(emitter, "definition") < 0)
 361                 return -1;
 362         if (emit_string(emitter, type->definition) < 0)
 363                 return -1;
 364
 365         if (!yaml_mapping_end_event_initialize(&event))
 366                 return -1;
 367         if (!yaml_emitter_emit(emitter, &event))
 368                 return -1;
 369
 370         return 0;
 371 }
 372
 373 /* Print the list of "n_type" "types", if any, to "emitter".
 374  */
 375 static int emit_types(yaml_emitter_t *emitter, int n_type,
 376         struct pet_type **types)
 377 {
 378         int i;
 379         yaml_event_t event;
 380
 381         if (n_type == 0)
 382                 return 0;
 383
 384         if (emit_string(emitter, "types") < 0)
 385                 return -1;
 386         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 387                                                 YAML_BLOCK_SEQUENCE_STYLE))
 388                 return -1;
 389         if (!yaml_emitter_emit(emitter, &event))
 390                 return -1;
 391
 392         for (i = 0; i < n_type; ++i)
 393                 if (emit_type(emitter, types[i]) < 0)
 394                         return -1;
 395
 396         if (!yaml_sequence_end_event_initialize(&event))
 397                 return -1;
 398         if (!yaml_emitter_emit(emitter, &event))
 399                 return -1;
 400
 401         return 0;
 402 }
 403
 404 static int emit_array(yaml_emitter_t *emitter, struct pet_array *array)
 405 {
 406         yaml_event_t event;
 407
 408         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 409                                                 YAML_BLOCK_MAPPING_STYLE))
 410                 return -1;
 411         if (!yaml_emitter_emit(emitter, &event))
 412                 return -1;
 413
 414         if (emit_string(emitter, "context") < 0)
 415                 return -1;
 416         if (emit_set(emitter, array->context) < 0)
 417                 return -1;
 418
 419         if (emit_string(emitter, "extent") < 0)
 420                 return -1;
 421         if (emit_set(emitter, array->extent) < 0)
 422                 return -1;
 423
 424         if (array->value_bounds) {
 425                 if (emit_string(emitter, "value_bounds") < 0)
 426                         return -1;
 427                 if (emit_set(emitter, array->value_bounds) < 0)
 428                         return -1;
 429         }
 430
 431         if (emit_string(emitter, "element_type") < 0)
 432                 return -1;
 433         if (emit_string(emitter, array->element_type) < 0)
 434                 return -1;
 435         if (emit_named_int(emitter, "element_size", array->element_size) < 0)
 436                 return -1;
 437
 438         if (array->element_is_record)
 439                 if (emit_named_int(emitter, "element_is_record",
 440                                         array->element_is_record) < 0)
 441                         return -1;
 442
 443         if (array->live_out) {
 444                 if (emit_string(emitter, "live_out") < 0)
 445                         return -1;
 446                 if (emit_string(emitter, "1") < 0)
 447                         return -1;
 448         }
 449
 450         if (array->uniquely_defined) {
 451                 if (emit_string(emitter, "uniquely_defined") < 0)
 452                         return -1;
 453                 if (emit_string(emitter, "1") < 0)
 454                         return -1;
 455         }
 456
 457         if (array->declared && emit_named_int(emitter, "declared", 1) < 0)
 458                 return -1;
 459         if (array->exposed && emit_named_int(emitter, "exposed", 1) < 0)
 460                 return -1;
 461
 462         if (!yaml_mapping_end_event_initialize(&event))
 463                 return -1;
 464         if (!yaml_emitter_emit(emitter, &event))
 465                 return -1;
 466
 467         return 0;
 468 }
 469
 470 static int emit_arrays(yaml_emitter_t *emitter, int n_array,
 471         struct pet_array **arrays)
 472 {
 473         int i;
 474         yaml_event_t event;
 475
 476         if (emit_string(emitter, "arrays") < 0)
 477                 return -1;
 478         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 479                                                 YAML_BLOCK_SEQUENCE_STYLE))
 480                 return -1;
 481         if (!yaml_emitter_emit(emitter, &event))
 482                 return -1;
 483
 484         for (i = 0; i < n_array; ++i)
 485                 if (emit_array(emitter, arrays[i]) < 0)
 486                         return -1;
 487
 488         if (!yaml_sequence_end_event_initialize(&event))
 489                 return -1;
 490         if (!yaml_emitter_emit(emitter, &event))
 491                 return -1;
 492
 493         return 0;
 494 }
 495
 496 static int emit_expr_type(yaml_emitter_t *emitter, enum pet_expr_type type)
 497 {
 498         if (emit_string(emitter, pet_type_str(type)) < 0)
 499                 return -1;
 500         return 0;
 501 }
 502
 503 /* Print the fields of the access expression "expr" to "emitter".
 504  *
 505  * Only print the access relations that are present and relevant
 506  * for the type of access.
 507  *
 508  * If the depth of the access is equal to the depth that can be derived from
 509  * the index expression, then there is no need to print it.
 510  */
 511 static int emit_access_expr(yaml_emitter_t *emitter, __isl_keep pet_expr *expr)
 512 {
 513         int depth;
 514
 515         if (expr->acc.kill && expr->acc.access[pet_expr_access_fake_killed] &&
 516             emit_named_union_map(emitter, "killed",
 517                     expr->acc.access[pet_expr_access_fake_killed]) < 0)
 518                 return -1;
 519         if (expr->acc.read && expr->acc.access[pet_expr_access_may_read] &&
 520             emit_named_union_map(emitter, "may_read",
 521                     expr->acc.access[pet_expr_access_may_read]) < 0)
 522                 return -1;
 523         if (expr->acc.write && expr->acc.access[pet_expr_access_may_write] &&
 524             emit_named_union_map(emitter, "may_write",
 525                     expr->acc.access[pet_expr_access_may_write]) < 0)
 526                 return -1;
 527         if (expr->acc.write && expr->acc.access[pet_expr_access_must_write] &&
 528             emit_named_union_map(emitter, "must_write",
 529                     expr->acc.access[pet_expr_access_must_write]) < 0)
 530                 return -1;
 531         if (emit_named_multi_pw_aff(emitter, "index", expr->acc.index) < 0)
 532                 return -1;
 533         depth = isl_multi_pw_aff_dim(expr->acc.index, isl_dim_out);
 534         if (expr->acc.depth != depth &&
 535             emit_named_int(emitter, "depth", expr->acc.depth) < 0)
 536                 return -1;
 537         if (expr->acc.ref_id &&
 538             emit_named_id(emitter, "reference", expr->acc.ref_id) < 0)
 539                 return -1;
 540         if (expr->acc.kill) {
 541                 if (emit_named_unsigned(emitter, "kill", 1) < 0)
 542                         return -1;
 543         } else {
 544                 if (emit_string(emitter, "read") < 0)
 545                         return -1;
 546                 if (emit_int(emitter, expr->acc.read) < 0)
 547                         return -1;
 548                 if (emit_string(emitter, "write") < 0)
 549                         return -1;
 550                 if (emit_int(emitter, expr->acc.write) < 0)
 551                         return -1;
 552         }
 553
 554         return 0;
 555 }
 556
 557 static int emit_expr(yaml_emitter_t *emitter, __isl_keep pet_expr *expr)
 558 {
 559         yaml_event_t event;
 560
 561         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 562                                                 YAML_BLOCK_MAPPING_STYLE))
 563                 return -1;
 564         if (!yaml_emitter_emit(emitter, &event))
 565                 return -1;
 566
 567         if (emit_string(emitter, "type") < 0)
 568                 return -1;
 569         if (emit_expr_type(emitter, expr->type) < 0)
 570                 return -1;
 571
 572         switch (expr->type) {
 573         case pet_expr_error:
 574                 return -1;
 575         case pet_expr_int:
 576                 if (emit_named_val(emitter, "value", expr->i) < 0)
 577                         return -1;
 578                 break;
 579         case pet_expr_double:
 580                 if (emit_string(emitter, "value") < 0)
 581                         return -1;
 582                 if (emit_double(emitter, expr->d.val) < 0)
 583                         return -1;
 584                 if (emit_string(emitter, "string") < 0)
 585                         return -1;
 586                 if (emit_string(emitter, expr->d.s) < 0)
 587                         return -1;
 588                 break;
 589         case pet_expr_access:
 590                 if (emit_access_expr(emitter, expr) < 0)
 591                         return -1;
 592                 break;
 593         case pet_expr_op:
 594                 if (emit_string(emitter, "operation") < 0)
 595                         return -1;
 596                 if (emit_string(emitter, pet_op_str(expr->op)) < 0)
 597                         return -1;
 598                 break;
 599         case pet_expr_call:
 600                 if (emit_string(emitter, "name") < 0)
 601                         return -1;
 602                 if (emit_string(emitter, expr->c.name) < 0)
 603                         return -1;
 604                 break;
 605         case pet_expr_cast:
 606                 if (emit_string(emitter, "type_name") < 0)
 607                         return -1;
 608                 if (emit_string(emitter, expr->type_name) < 0)
 609                         return -1;
 610                 break;
 611         }
 612
 613         if (expr->n_arg > 0) {
 614                 int i;
 615
 616                 if (emit_string(emitter, "arguments") < 0)
 617                         return -1;
 618                 if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 619                                                     YAML_BLOCK_SEQUENCE_STYLE))
 620                         return -1;
 621                 if (!yaml_emitter_emit(emitter, &event))
 622                         return -1;
 623
 624                 for (i = 0; i < expr->n_arg; ++i)
 625                         if (emit_expr(emitter, expr->args[i]) < 0)
 626                                 return -1;
 627
 628                 if (!yaml_sequence_end_event_initialize(&event))
 629                         return -1;
 630                 if (!yaml_emitter_emit(emitter, &event))
 631                         return -1;
 632         }
 633
 634         if (!yaml_mapping_end_event_initialize(&event))
 635                 return -1;
 636         if (!yaml_emitter_emit(emitter, &event))
 637                 return -1;
 638
 639         return 0;
 640 }
 641
 642 /* Print the string "name" and the expression "expr" to "emitter".
 643  */
 644 static int emit_named_expr(yaml_emitter_t *emitter, const char *name,
 645          __isl_keep pet_expr *expr)
 646 {
 647         if (emit_string(emitter, name) < 0)
 648                 return -1;
 649         if (emit_expr(emitter, expr) < 0)
 650                 return -1;
 651         return 0;
 652 }
 653
 654 /* Print "type" to "emitter".
 655  */
 656 static int emit_tree_type(yaml_emitter_t *emitter, enum pet_tree_type type)
 657 {
 658         if (emit_string(emitter, pet_tree_type_str(type)) < 0)
 659                 return -1;
 660         return 0;
 661 }
 662
 663 /* Recursively print "tree" to "emitter".
 664  */
 665 static int emit_tree(yaml_emitter_t *emitter, __isl_keep pet_tree *tree)
 666 {
 667         yaml_event_t event;
 668         int i;
 669
 670         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 671                                                 YAML_BLOCK_MAPPING_STYLE))
 672                 return -1;
 673         if (!yaml_emitter_emit(emitter, &event))
 674                 return -1;
 675
 676         if (emit_string(emitter, "type") < 0)
 677                 return -1;
 678         if (emit_tree_type(emitter, tree->type) < 0)
 679                 return -1;
 680
 681         switch (tree->type) {
 682         case pet_tree_error:
 683                 return -1;
 684         case pet_tree_block:
 685                 if (emit_named_int(emitter, "block", tree->u.b.block) < 0)
 686                         return -1;
 687                 if (tree->u.b.n == 0)
 688                         break;
 689
 690                 if (emit_string(emitter, "children") < 0)
 691                         return -1;
 692                 if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 693                                                     YAML_BLOCK_SEQUENCE_STYLE))
 694                         return -1;
 695                 if (!yaml_emitter_emit(emitter, &event))
 696                         return -1;
 697
 698                 for (i = 0; i < tree->u.b.n; ++i)
 699                         if (emit_tree(emitter, tree->u.b.child[i]) < 0)
 700                                 return -1;
 701
 702                 if (!yaml_sequence_end_event_initialize(&event))
 703                         return -1;
 704                 if (!yaml_emitter_emit(emitter, &event))
 705                         return -1;
 706                 break;
 707         case pet_tree_break:
 708         case pet_tree_continue:
 709                 break;
 710         case pet_tree_decl:
 711                 if (emit_named_expr(emitter, "variable", tree->u.d.var) < 0)
 712                         return -1;
 713                 break;
 714         case pet_tree_decl_init:
 715                 if (emit_named_expr(emitter, "variable", tree->u.d.var) < 0)
 716                         return -1;
 717                 if (emit_named_expr(emitter,
 718                                     "initialization", tree->u.d.init) < 0)
 719                         return -1;
 720                 break;
 721         case pet_tree_expr:
 722                 if (emit_named_expr(emitter, "expr", tree->u.e.expr) < 0)
 723                         return -1;
 724                 break;
 725         case pet_tree_for:
 726                 if (tree->u.l.independent)
 727                         if (emit_named_int(emitter, "independent", 1) < 0)
 728                                 return -1;
 729                 if (emit_named_int(emitter, "declared", tree->u.l.declared) < 0)
 730                         return -1;
 731                 if (emit_named_expr(emitter, "variable", tree->u.l.iv) < 0)
 732                         return -1;
 733                 if (emit_named_expr(emitter,
 734                                     "initialization", tree->u.l.init) < 0)
 735                         return -1;
 736                 if (emit_named_expr(emitter, "condition", tree->u.l.cond) < 0)
 737                         return -1;
 738                 if (emit_named_expr(emitter, "increment", tree->u.l.inc) < 0)
 739                         return -1;
 740                 if (emit_string(emitter, "body") < 0)
 741                         return -1;
 742                 if (emit_tree(emitter, tree->u.l.body) < 0)
 743                         return -1;
 744                 break;
 745         case pet_tree_while:
 746                 if (emit_named_expr(emitter, "condition", tree->u.l.cond) < 0)
 747                         return -1;
 748                 if (emit_string(emitter, "body") < 0)
 749                         return -1;
 750                 if (emit_tree(emitter, tree->u.l.body) < 0)
 751                         return -1;
 752                 break;
 753         case pet_tree_infinite_loop:
 754                 if (emit_string(emitter, "body") < 0)
 755                         return -1;
 756                 if (emit_tree(emitter, tree->u.l.body) < 0)
 757                         return -1;
 758                 break;
 759         case pet_tree_if:
 760                 if (emit_named_expr(emitter, "condition", tree->u.i.cond) < 0)
 761                         return -1;
 762                 if (emit_string(emitter, "then") < 0)
 763                         return -1;
 764                 if (emit_tree(emitter, tree->u.i.then_body) < 0)
 765                         return -1;
 766                 break;
 767         case pet_tree_if_else:
 768                 if (emit_named_expr(emitter, "condition", tree->u.i.cond) < 0)
 769                         return -1;
 770                 if (emit_string(emitter, "then") < 0)
 771                         return -1;
 772                 if (emit_tree(emitter, tree->u.i.then_body) < 0)
 773                         return -1;
 774                 if (emit_string(emitter, "else") < 0)
 775                         return -1;
 776                 if (emit_tree(emitter, tree->u.i.else_body) < 0)
 777                         return -1;
 778                 break;
 779         }
 780
 781         if (!yaml_mapping_end_event_initialize(&event))
 782                 return -1;
 783         if (!yaml_emitter_emit(emitter, &event))
 784                 return -1;
 785
 786         return 0;
 787 }
 788
 789 static int emit_stmt(yaml_emitter_t *emitter, struct pet_stmt *stmt)
 790 {
 791         yaml_event_t event;
 792
 793         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 794                                                 YAML_BLOCK_MAPPING_STYLE))
 795                 return -1;
 796         if (!yaml_emitter_emit(emitter, &event))
 797                 return -1;
 798
 799         if (emit_string(emitter, "line") < 0)
 800                 return -1;
 801         if (emit_int(emitter, pet_loc_get_line(stmt->loc)) < 0)
 802                 return -1;
 803
 804         if (emit_string(emitter, "domain") < 0)
 805                 return -1;
 806         if (emit_set(emitter, stmt->domain) < 0)
 807                 return -1;
 808
 809         if (emit_string(emitter, "body") < 0)
 810                 return -1;
 811         if (emit_tree(emitter, stmt->body) < 0)
 812                 return -1;
 813
 814         if (stmt->n_arg > 0) {
 815                 int i;
 816
 817                 if (emit_string(emitter, "arguments") < 0)
 818                         return -1;
 819                 if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 820                                                     YAML_BLOCK_SEQUENCE_STYLE))
 821                         return -1;
 822                 if (!yaml_emitter_emit(emitter, &event))
 823                         return -1;
 824
 825                 for (i = 0; i < stmt->n_arg; ++i)
 826                         if (emit_expr(emitter, stmt->args[i]) < 0)
 827                                 return -1;
 828
 829                 if (!yaml_sequence_end_event_initialize(&event))
 830                         return -1;
 831                 if (!yaml_emitter_emit(emitter, &event))
 832                         return -1;
 833         }
 834
 835         if (!yaml_mapping_end_event_initialize(&event))
 836                 return -1;
 837         if (!yaml_emitter_emit(emitter, &event))
 838                 return -1;
 839
 840         return 0;
 841 }
 842
 843 static int emit_statements(yaml_emitter_t *emitter, int n_stmt,
 844         struct pet_stmt **stmts)
 845 {
 846         int i;
 847         yaml_event_t event;
 848
 849         if (emit_string(emitter, "statements") < 0)
 850                 return -1;
 851         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 852                                                 YAML_BLOCK_SEQUENCE_STYLE))
 853                 return -1;
 854         if (!yaml_emitter_emit(emitter, &event))
 855                 return -1;
 856
 857         for (i = 0; i < n_stmt; ++i)
 858                 if (emit_stmt(emitter, stmts[i]) < 0)
 859                         return -1;
 860
 861         if (!yaml_sequence_end_event_initialize(&event))
 862                 return -1;
 863         if (!yaml_emitter_emit(emitter, &event))
 864                 return -1;
 865
 866         return 0;
 867 }
 868
 869 /* Print "implication" to "emitter".
 870  */
 871 static int emit_implication(yaml_emitter_t *emitter,
 872         struct pet_implication *implication)
 873 {
 874         yaml_event_t event;
 875
 876         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 877                                                 YAML_BLOCK_MAPPING_STYLE))
 878                 return -1;
 879         if (!yaml_emitter_emit(emitter, &event))
 880                 return -1;
 881
 882         if (emit_named_int(emitter, "satisfied", implication->satisfied) < 0)
 883                 return -1;
 884
 885         if (emit_named_map(emitter, "extension", implication->extension) < 0)
 886                 return -1;
 887
 888         if (!yaml_mapping_end_event_initialize(&event))
 889                 return -1;
 890         if (!yaml_emitter_emit(emitter, &event))
 891                 return -1;
 892
 893         return 0;
 894 }
 895
 896 /* Print the list of "n_implication" "implications", if any, to "emitter".
 897  */
 898 static int emit_implications(yaml_emitter_t *emitter, int n_implication,
 899         struct pet_implication **implications)
 900 {
 901         int i;
 902         yaml_event_t event;
 903
 904         if (n_implication == 0)
 905                 return 0;
 906
 907         if (emit_string(emitter, "implications") < 0)
 908                 return -1;
 909         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 910                                                 YAML_BLOCK_SEQUENCE_STYLE))
 911                 return -1;
 912         if (!yaml_emitter_emit(emitter, &event))
 913                 return -1;
 914
 915         for (i = 0; i < n_implication; ++i)
 916                 if (emit_implication(emitter, implications[i]) < 0)
 917                         return -1;
 918
 919         if (!yaml_sequence_end_event_initialize(&event))
 920                 return -1;
 921         if (!yaml_emitter_emit(emitter, &event))
 922                 return -1;
 923
 924         return 0;
 925 }
 926
 927 /* Print "independence" to "emitter".
 928  */
 929 static int emit_independence(yaml_emitter_t *emitter,
 930         struct pet_independence *independence)
 931 {
 932         yaml_event_t event;
 933
 934         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 935                                                 YAML_BLOCK_MAPPING_STYLE))
 936                 return -1;
 937         if (!yaml_emitter_emit(emitter, &event))
 938                 return -1;
 939
 940         if (emit_named_union_map(emitter, "filter", independence->filter) < 0)
 941                 return -1;
 942
 943         if (emit_named_union_set(emitter, "local", independence->local) < 0)
 944                 return -1;
 945
 946         if (!yaml_mapping_end_event_initialize(&event))
 947                 return -1;
 948         if (!yaml_emitter_emit(emitter, &event))
 949                 return -1;
 950
 951         return 0;
 952 }
 953
 954 /* Print the list of "n_independence" "independences", if any, to "emitter".
 955  */
 956 static int emit_independences(yaml_emitter_t *emitter, int n_independence,
 957         struct pet_independence **independences)
 958 {
 959         int i;
 960         yaml_event_t event;
 961
 962         if (n_independence == 0)
 963                 return 0;
 964
 965         if (emit_string(emitter, "independences") < 0)
 966                 return -1;
 967         if (!yaml_sequence_start_event_initialize(&event, NULL, NULL, 1,
 968                                                 YAML_BLOCK_SEQUENCE_STYLE))
 969                 return -1;
 970         if (!yaml_emitter_emit(emitter, &event))
 971                 return -1;
 972
 973         for (i = 0; i < n_independence; ++i)
 974                 if (emit_independence(emitter, independences[i]) < 0)
 975                         return -1;
 976
 977         if (!yaml_sequence_end_event_initialize(&event))
 978                 return -1;
 979         if (!yaml_emitter_emit(emitter, &event))
 980                 return -1;
 981
 982         return 0;
 983 }
 984
 985 static int emit_scop(yaml_emitter_t *emitter, struct pet_scop *scop)
 986 {
 987         yaml_event_t event;
 988
 989         if (!yaml_mapping_start_event_initialize(&event, NULL, NULL, 1,
 990                                                 YAML_BLOCK_MAPPING_STYLE))
 991                 return -1;
 992         if (!yaml_emitter_emit(emitter, &event))
 993                 return -1;
 994
 995         if (emit_named_unsigned(emitter,
 996                                 "start", pet_loc_get_start(scop->loc)) < 0)
 997                 return -1;
 998         if (emit_named_unsigned(emitter, "end", pet_loc_get_end(scop->loc)) < 0)
 999                 return -1;
1000         if (emit_named_string(emitter,
1001                                 "indent", pet_loc_get_indent(scop->loc)) < 0)
1002                 return -1;
1003         if (emit_string(emitter, "context") < 0)
1004                 return -1;
1005         if (emit_set(emitter, scop->context) < 0)
1006                 return -1;
1007         if (!isl_set_plain_is_universe(scop->context_value) &&
1008             emit_named_set(emitter, "context_value", scop->context_value) < 0)
1009                 return -1;
1010         if (emit_named_schedule(emitter, "schedule", scop->schedule) < 0)
1011                 return -1;
1012
1013         if (emit_types(emitter, scop->n_type, scop->types) < 0)
1014                 return -1;
1015         if (emit_arrays(emitter, scop->n_array, scop->arrays) < 0)
1016                 return -1;
1017
1018         if (emit_statements(emitter, scop->n_stmt, scop->stmts) < 0)
1019                 return -1;
1020
1021         if (emit_implications(emitter, scop->n_implication,
1022                                 scop->implications) < 0)
1023                 return -1;
1024
1025         if (emit_independences(emitter, scop->n_independence,
1026                                 scop->independences) < 0)
1027                 return -1;
1028
1029         if (!yaml_mapping_end_event_initialize(&event))
1030                 return -1;
1031         if (!yaml_emitter_emit(emitter, &event))
1032                 return -1;
1033
1034         return 0;
1035 }
1036
1037 /* Print a YAML serialization of "scop" to "out".
1038  */
1039 int pet_scop_emit(FILE *out, struct pet_scop *scop)
1040 {
1041         yaml_emitter_t emitter;
1042         yaml_event_t event;
1043
1044         yaml_emitter_initialize(&emitter);
1045
1046         yaml_emitter_set_output_file(&emitter, out);
1047
1048         yaml_stream_start_event_initialize(&event, YAML_UTF8_ENCODING);
1049         if (!yaml_emitter_emit(&emitter, &event))
1050                 goto error;
1051
1052         if (!yaml_document_start_event_initialize(&event, NULL, NULL, NULL, 1))
1053                 goto error;
1054         if (!yaml_emitter_emit(&emitter, &event))
1055                 goto error;
1056
1057         if (emit_scop(&emitter, scop) < 0)
1058                 goto error;
1059
1060         if (!yaml_document_end_event_initialize(&event, 1))
1061                 goto error;
1062         if (!yaml_emitter_emit(&emitter, &event))
1063                 goto error;
1064
1065         yaml_stream_end_event_initialize(&event);
1066         if (!yaml_emitter_emit(&emitter, &event))
1067                 goto error;
1068
1069         yaml_emitter_delete(&emitter);
1070         return 0;
1071 error:
1072         yaml_emitter_delete(&emitter);
1073         return -1;
1074 }