isl_printer.c

   1 #include <string.h>
   2 #include <isl_int.h>
   3 #include <isl/id.h>
   4 #include <isl/id_to_id.h>
   5 #include <isl_printer_private.h>
   6
   7 static __isl_give isl_printer *file_start_line(__isl_take isl_printer *p)
   8 {
   9         fprintf(p->file, "%s%*s%s", p->indent_prefix ? p->indent_prefix : "",
  10                                     p->indent, "", p->prefix ? p->prefix : "");
  11         return p;
  12 }
  13
  14 static __isl_give isl_printer *file_end_line(__isl_take isl_printer *p)
  15 {
  16         fprintf(p->file, "%s\n", p->suffix ? p->suffix : "");
  17         return p;
  18 }
  19
  20 static __isl_give isl_printer *file_flush(__isl_take isl_printer *p)
  21 {
  22         fflush(p->file);
  23         return p;
  24 }
  25
  26 static __isl_give isl_printer *file_print_str(__isl_take isl_printer *p,
  27         const char *s)
  28 {
  29         fprintf(p->file, "%s", s);
  30         return p;
  31 }
  32
  33 static __isl_give isl_printer *file_print_double(__isl_take isl_printer *p,
  34         double d)
  35 {
  36         fprintf(p->file, "%g", d);
  37         return p;
  38 }
  39
  40 static __isl_give isl_printer *file_print_int(__isl_take isl_printer *p, int i)
  41 {
  42         fprintf(p->file, "%d", i);
  43         return p;
  44 }
  45
  46 static __isl_give isl_printer *file_print_isl_int(__isl_take isl_printer *p, isl_int i)
  47 {
  48         isl_int_print(p->file, i, p->width);
  49         return p;
  50 }
  51
  52 static int grow_buf(__isl_keep isl_printer *p, int extra)
  53 {
  54         int new_size;
  55         char *new_buf;
  56
  57         if (p->buf_size == 0)
  58                 return -1;
  59
  60         new_size = ((p->buf_n + extra + 1) * 3) / 2;
  61         new_buf = isl_realloc_array(p->ctx, p->buf, char, new_size);
  62         if (!new_buf) {
  63                 p->buf_size = 0;
  64                 return -1;
  65         }
  66         p->buf = new_buf;
  67         p->buf_size = new_size;
  68
  69         return 0;
  70 }
  71
  72 static __isl_give isl_printer *str_print(__isl_take isl_printer *p,
  73         const char *s, int len)
  74 {
  75         if (p->buf_n + len + 1 >= p->buf_size && grow_buf(p, len))
  76                 goto error;
  77         memcpy(p->buf + p->buf_n, s, len);
  78         p->buf_n += len;
  79
  80         p->buf[p->buf_n] = '\0';
  81         return p;
  82 error:
  83         isl_printer_free(p);
  84         return NULL;
  85 }
  86
  87 static __isl_give isl_printer *str_print_indent(__isl_take isl_printer *p,
  88         int indent)
  89 {
  90         int i;
  91
  92         if (p->buf_n + indent + 1 >= p->buf_size && grow_buf(p, indent))
  93                 goto error;
  94         for (i = 0; i < indent; ++i)
  95                 p->buf[p->buf_n++] = ' ';
  96         return p;
  97 error:
  98         isl_printer_free(p);
  99         return NULL;
 100 }
 101
 102 static __isl_give isl_printer *str_start_line(__isl_take isl_printer *p)
 103 {
 104         if (p->indent_prefix)
 105                 p = str_print(p, p->indent_prefix, strlen(p->indent_prefix));
 106         p = str_print_indent(p, p->indent);
 107         if (p->prefix)
 108                 p = str_print(p, p->prefix, strlen(p->prefix));
 109         return p;
 110 }
 111
 112 static __isl_give isl_printer *str_end_line(__isl_take isl_printer *p)
 113 {
 114         if (p->suffix)
 115                 p = str_print(p, p->suffix, strlen(p->suffix));
 116         p = str_print(p, "\n", strlen("\n"));
 117         return p;
 118 }
 119
 120 static __isl_give isl_printer *str_flush(__isl_take isl_printer *p)
 121 {
 122         p->buf_n = 0;
 123         p->buf[p->buf_n] = '\0';
 124         return p;
 125 }
 126
 127 static __isl_give isl_printer *str_print_str(__isl_take isl_printer *p,
 128         const char *s)
 129 {
 130         return str_print(p, s, strlen(s));
 131 }
 132
 133 static __isl_give isl_printer *str_print_double(__isl_take isl_printer *p,
 134         double d)
 135 {
 136         int left = p->buf_size - p->buf_n;
 137         int need = snprintf(p->buf + p->buf_n, left, "%g", d);
 138         if (need >= left) {
 139                 if (grow_buf(p, need))
 140                         goto error;
 141                 left = p->buf_size - p->buf_n;
 142                 need = snprintf(p->buf + p->buf_n, left, "%g", d);
 143         }
 144         p->buf_n += need;
 145         return p;
 146 error:
 147         isl_printer_free(p);
 148         return NULL;
 149 }
 150
 151 static __isl_give isl_printer *str_print_int(__isl_take isl_printer *p, int i)
 152 {
 153         int left = p->buf_size - p->buf_n;
 154         int need = snprintf(p->buf + p->buf_n, left, "%d", i);
 155         if (need >= left) {
 156                 if (grow_buf(p, need))
 157                         goto error;
 158                 left = p->buf_size - p->buf_n;
 159                 need = snprintf(p->buf + p->buf_n, left, "%d", i);
 160         }
 161         p->buf_n += need;
 162         return p;
 163 error:
 164         isl_printer_free(p);
 165         return NULL;
 166 }
 167
 168 static __isl_give isl_printer *str_print_isl_int(__isl_take isl_printer *p,
 169         isl_int i)
 170 {
 171         char *s;
 172         int len;
 173
 174         s = isl_int_get_str(i);
 175         len = strlen(s);
 176         if (len < p->width)
 177                 p = str_print_indent(p, p->width - len);
 178         p = str_print(p, s, len);
 179         isl_int_free_str(s);
 180         return p;
 181 }
 182
 183 struct isl_printer_ops {
 184         __isl_give isl_printer *(*start_line)(__isl_take isl_printer *p);
 185         __isl_give isl_printer *(*end_line)(__isl_take isl_printer *p);
 186         __isl_give isl_printer *(*print_double)(__isl_take isl_printer *p,
 187                 double d);
 188         __isl_give isl_printer *(*print_int)(__isl_take isl_printer *p, int i);
 189         __isl_give isl_printer *(*print_isl_int)(__isl_take isl_printer *p,
 190                                                 isl_int i);
 191         __isl_give isl_printer *(*print_str)(__isl_take isl_printer *p,
 192                                                 const char *s);
 193         __isl_give isl_printer *(*flush)(__isl_take isl_printer *p);
 194 };
 195
 196 static struct isl_printer_ops file_ops = {
 197         file_start_line,
 198         file_end_line,
 199         file_print_double,
 200         file_print_int,
 201         file_print_isl_int,
 202         file_print_str,
 203         file_flush
 204 };
 205
 206 static struct isl_printer_ops str_ops = {
 207         str_start_line,
 208         str_end_line,
 209         str_print_double,
 210         str_print_int,
 211         str_print_isl_int,
 212         str_print_str,
 213         str_flush
 214 };
 215
 216 __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx, FILE *file)
 217 {
 218         struct isl_printer *p = isl_calloc_type(ctx, struct isl_printer);
 219         if (!p)
 220                 return NULL;
 221         p->ctx = ctx;
 222         isl_ctx_ref(p->ctx);
 223         p->ops = &file_ops;
 224         p->file = file;
 225         p->buf = NULL;
 226         p->buf_n = 0;
 227         p->buf_size = 0;
 228         p->indent = 0;
 229         p->output_format = ISL_FORMAT_ISL;
 230         p->indent_prefix = NULL;
 231         p->prefix = NULL;
 232         p->suffix = NULL;
 233         p->width = 0;
 234         p->yaml_style = ISL_YAML_STYLE_FLOW;
 235
 236         return p;
 237 }
 238
 239 __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx)
 240 {
 241         struct isl_printer *p = isl_calloc_type(ctx, struct isl_printer);
 242         if (!p)
 243                 return NULL;
 244         p->ctx = ctx;
 245         isl_ctx_ref(p->ctx);
 246         p->ops = &str_ops;
 247         p->file = NULL;
 248         p->buf = isl_alloc_array(ctx, char, 256);
 249         if (!p->buf)
 250                 goto error;
 251         p->buf_n = 0;
 252         p->buf[0] = '\0';
 253         p->buf_size = 256;
 254         p->indent = 0;
 255         p->output_format = ISL_FORMAT_ISL;
 256         p->indent_prefix = NULL;
 257         p->prefix = NULL;
 258         p->suffix = NULL;
 259         p->width = 0;
 260         p->yaml_style = ISL_YAML_STYLE_FLOW;
 261
 262         return p;
 263 error:
 264         isl_printer_free(p);
 265         return NULL;
 266 }
 267
 268 __isl_null isl_printer *isl_printer_free(__isl_take isl_printer *p)
 269 {
 270         if (!p)
 271                 return NULL;
 272         free(p->buf);
 273         free(p->indent_prefix);
 274         free(p->prefix);
 275         free(p->suffix);
 276         free(p->yaml_state);
 277         isl_id_to_id_free(p->notes);
 278         isl_ctx_deref(p->ctx);
 279         free(p);
 280
 281         return NULL;
 282 }
 283
 284 isl_ctx *isl_printer_get_ctx(__isl_keep isl_printer *printer)
 285 {
 286         return printer ? printer->ctx : NULL;
 287 }
 288
 289 FILE *isl_printer_get_file(__isl_keep isl_printer *printer)
 290 {
 291         if (!printer)
 292                 return NULL;
 293         if (!printer->file)
 294                 isl_die(isl_printer_get_ctx(printer), isl_error_invalid,
 295                         "not a file printer", return NULL);
 296         return printer->file;
 297 }
 298
 299 __isl_give isl_printer *isl_printer_set_isl_int_width(__isl_take isl_printer *p,
 300         int width)
 301 {
 302         if (!p)
 303                 return NULL;
 304
 305         p->width = width;
 306
 307         return p;
 308 }
 309
 310 __isl_give isl_printer *isl_printer_set_indent(__isl_take isl_printer *p,
 311         int indent)
 312 {
 313         if (!p)
 314                 return NULL;
 315
 316         p->indent = indent;
 317
 318         return p;
 319 }
 320
 321 __isl_give isl_printer *isl_printer_indent(__isl_take isl_printer *p,
 322         int indent)
 323 {
 324         if (!p)
 325                 return NULL;
 326
 327         p->indent += indent;
 328         if (p->indent < 0)
 329                 p->indent = 0;
 330
 331         return p;
 332 }
 333
 334 /* Replace the indent prefix of "p" by "prefix".
 335  */
 336 __isl_give isl_printer *isl_printer_set_indent_prefix(__isl_take isl_printer *p,
 337         const char *prefix)
 338 {
 339         if (!p)
 340                 return NULL;
 341
 342         free(p->indent_prefix);
 343         p->indent_prefix = prefix ? strdup(prefix) : NULL;
 344
 345         return p;
 346 }
 347
 348 __isl_give isl_printer *isl_printer_set_prefix(__isl_take isl_printer *p,
 349         const char *prefix)
 350 {
 351         if (!p)
 352                 return NULL;
 353
 354         free(p->prefix);
 355         p->prefix = prefix ? strdup(prefix) : NULL;
 356
 357         return p;
 358 }
 359
 360 __isl_give isl_printer *isl_printer_set_suffix(__isl_take isl_printer *p,
 361         const char *suffix)
 362 {
 363         if (!p)
 364                 return NULL;
 365
 366         free(p->suffix);
 367         p->suffix = suffix ? strdup(suffix) : NULL;
 368
 369         return p;
 370 }
 371
 372 __isl_give isl_printer *isl_printer_set_output_format(__isl_take isl_printer *p,
 373         int output_format)
 374 {
 375         if (!p)
 376                 return NULL;
 377
 378         p->output_format = output_format;
 379
 380         return p;
 381 }
 382
 383 int isl_printer_get_output_format(__isl_keep isl_printer *p)
 384 {
 385         if (!p)
 386                 return -1;
 387         return p->output_format;
 388 }
 389
 390 /* Does "p" have a note with identifier "id"?
 391  */
 392 isl_bool isl_printer_has_note(__isl_keep isl_printer *p,
 393         __isl_keep isl_id *id)
 394 {
 395         if (!p || !id)
 396                 return isl_bool_error;
 397         if (!p->notes)
 398                 return isl_bool_false;
 399         return isl_id_to_id_has(p->notes, id);
 400 }
 401
 402 /* Retrieve the note identified by "id" from "p".
 403  * The note is assumed to exist.
 404  */
 405 __isl_give isl_id *isl_printer_get_note(__isl_keep isl_printer *p,
 406         __isl_take isl_id *id)
 407 {
 408         isl_bool has_note;
 409
 410         has_note = isl_printer_has_note(p, id);
 411         if (has_note < 0)
 412                 goto error;
 413         if (!has_note)
 414                 isl_die(isl_printer_get_ctx(p), isl_error_invalid,
 415                         "no such note", goto error);
 416
 417         return isl_id_to_id_get(p->notes, id);
 418 error:
 419         isl_id_free(id);
 420         return NULL;
 421 }
 422
 423 /* Associate "note" to the identifier "id" in "p",
 424  * replacing the previous note associated to the identifier, if any.
 425  */
 426 __isl_give isl_printer *isl_printer_set_note(__isl_take isl_printer *p,
 427         __isl_take isl_id *id, __isl_take isl_id *note)
 428 {
 429         if (!p || !id || !note)
 430                 goto error;
 431         if (!p->notes) {
 432                 p->notes = isl_id_to_id_alloc(isl_printer_get_ctx(p), 1);
 433                 if (!p->notes)
 434                         goto error;
 435         }
 436         p->notes = isl_id_to_id_set(p->notes, id, note);
 437         if (!p->notes)
 438                 return isl_printer_free(p);
 439         return p;
 440 error:
 441         isl_printer_free(p);
 442         isl_id_free(id);
 443         isl_id_free(note);
 444         return NULL;
 445 }
 446
 447 /* Keep track of whether the printing to "p" is being performed from
 448  * an isl_*_dump function as specified by "dump".
 449  */
 450 __isl_give isl_printer *isl_printer_set_dump(__isl_take isl_printer *p,
 451         int dump)
 452 {
 453         if (!p)
 454                 return NULL;
 455
 456         p->dump = dump;
 457
 458         return p;
 459 }
 460
 461 /* Set the YAML style of "p" to "yaml_style" and return the updated printer.
 462  */
 463 __isl_give isl_printer *isl_printer_set_yaml_style(__isl_take isl_printer *p,
 464         int yaml_style)
 465 {
 466         if (!p)
 467                 return NULL;
 468
 469         p->yaml_style = yaml_style;
 470
 471         return p;
 472 }
 473
 474 /* Return the YAML style of "p" or -1 on error.
 475  */
 476 int isl_printer_get_yaml_style(__isl_keep isl_printer *p)
 477 {
 478         if (!p)
 479                 return -1;
 480         return p->yaml_style;
 481 }
 482
 483 /* Push "state" onto the stack of currently active YAML elements and
 484  * return the updated printer.
 485  */
 486 static __isl_give isl_printer *push_state(__isl_take isl_printer *p,
 487         enum isl_yaml_state state)
 488 {
 489         if (!p)
 490                 return NULL;
 491
 492         if (p->yaml_size < p->yaml_depth + 1) {
 493                 enum isl_yaml_state *state;
 494                 state = isl_realloc_array(p->ctx, p->yaml_state,
 495                                         enum isl_yaml_state, p->yaml_depth + 1);
 496                 if (!state)
 497                         return isl_printer_free(p);
 498                 p->yaml_state = state;
 499                 p->yaml_size = p->yaml_depth + 1;
 500         }
 501
 502         p->yaml_state[p->yaml_depth] = state;
 503         p->yaml_depth++;
 504
 505         return p;
 506 }
 507
 508 /* Remove the innermost active YAML element from the stack and
 509  * return the updated printer.
 510  */
 511 static __isl_give isl_printer *pop_state(__isl_take isl_printer *p)
 512 {
 513         if (!p)
 514                 return NULL;
 515         p->yaml_depth--;
 516         return p;
 517 }
 518
 519 /* Set the state of the innermost active YAML element to "state" and
 520  * return the updated printer.
 521  */
 522 static __isl_give isl_printer *update_state(__isl_take isl_printer *p,
 523         enum isl_yaml_state state)
 524 {
 525         if (!p)
 526                 return NULL;
 527         if (p->yaml_depth < 1)
 528                 isl_die(isl_printer_get_ctx(p), isl_error_invalid,
 529                         "not in YAML construct", return isl_printer_free(p));
 530
 531         p->yaml_state[p->yaml_depth - 1] = state;
 532
 533         return p;
 534 }
 535
 536 /* Return the state of the innermost active YAML element.
 537  * Return isl_yaml_none if we are not inside any YAML element.
 538  */
 539 static enum isl_yaml_state current_state(__isl_keep isl_printer *p)
 540 {
 541         if (!p)
 542                 return isl_yaml_none;
 543         if (p->yaml_depth < 1)
 544                 return isl_yaml_none;
 545         return p->yaml_state[p->yaml_depth - 1];
 546 }
 547
 548 /* If we are printing a YAML document and we are at the start of an element,
 549  * print whatever is needed before we can print the actual element and
 550  * keep track of the fact that we are now printing the element.
 551  * If "eol" is set, then whatever we print is going to be the last
 552  * thing that gets printed on this line.
 553  *
 554  * If we are about the print the first key of a mapping, then nothing
 555  * extra needs to be printed.  For any other key, however, we need
 556  * to either move to the next line (in block format) or print a comma
 557  * (in flow format).
 558  * Before printing a value in a mapping, we need to print a colon.
 559  *
 560  * For sequences, in flow format, we only need to print a comma
 561  * for each element except the first.
 562  * In block format, before the first element in the sequence,
 563  * we move to a new line, print a dash and increase the indentation.
 564  * Before any other element, we print a dash on a new line,
 565  * temporarily moving the indentation back.
 566  */
 567 static __isl_give isl_printer *enter_state(__isl_take isl_printer *p,
 568         int eol)
 569 {
 570         enum isl_yaml_state state;
 571
 572         if (!p)
 573                 return NULL;
 574
 575         state = current_state(p);
 576         if (state == isl_yaml_mapping_val_start) {
 577                 if (eol)
 578                         p = p->ops->print_str(p, ":");
 579                 else
 580                         p = p->ops->print_str(p, ": ");
 581                 p = update_state(p, isl_yaml_mapping_val);
 582         } else if (state == isl_yaml_mapping_first_key_start) {
 583                 p = update_state(p, isl_yaml_mapping_key);
 584         } else if (state == isl_yaml_mapping_key_start) {
 585                 if (p->yaml_style == ISL_YAML_STYLE_FLOW)
 586                         p = p->ops->print_str(p, ", ");
 587                 else {
 588                         p = p->ops->end_line(p);
 589                         p = p->ops->start_line(p);
 590                 }
 591                 p = update_state(p, isl_yaml_mapping_key);
 592         } else if (state == isl_yaml_sequence_first_start) {
 593                 if (p->yaml_style != ISL_YAML_STYLE_FLOW) {
 594                         p = p->ops->end_line(p);
 595                         p = p->ops->start_line(p);
 596                         p = p->ops->print_str(p, "- ");
 597                         p = isl_printer_indent(p, 2);
 598                 }
 599                 p = update_state(p, isl_yaml_sequence);
 600         } else if (state == isl_yaml_sequence_start) {
 601                 if (p->yaml_style == ISL_YAML_STYLE_FLOW)
 602                         p = p->ops->print_str(p, ", ");
 603                 else {
 604                         p = p->ops->end_line(p);
 605                         p = isl_printer_indent(p, -2);
 606                         p = p->ops->start_line(p);
 607                         p = p->ops->print_str(p, "- ");
 608                         p = isl_printer_indent(p, 2);
 609                 }
 610                 p = update_state(p, isl_yaml_sequence);
 611         }
 612
 613         return p;
 614 }
 615
 616 __isl_give isl_printer *isl_printer_print_str(__isl_take isl_printer *p,
 617         const char *s)
 618 {
 619         if (!p)
 620                 return NULL;
 621         if (!s)
 622                 return isl_printer_free(p);
 623         p = enter_state(p, 0);
 624         if (!p)
 625                 return NULL;
 626         return p->ops->print_str(p, s);
 627 }
 628
 629 __isl_give isl_printer *isl_printer_print_double(__isl_take isl_printer *p,
 630         double d)
 631 {
 632         p = enter_state(p, 0);
 633         if (!p)
 634                 return NULL;
 635
 636         return p->ops->print_double(p, d);
 637 }
 638
 639 __isl_give isl_printer *isl_printer_print_int(__isl_take isl_printer *p, int i)
 640 {
 641         p = enter_state(p, 0);
 642         if (!p)
 643                 return NULL;
 644
 645         return p->ops->print_int(p, i);
 646 }
 647
 648 __isl_give isl_printer *isl_printer_print_isl_int(__isl_take isl_printer *p,
 649         isl_int i)
 650 {
 651         p = enter_state(p, 0);
 652         if (!p)
 653                 return NULL;
 654
 655         return p->ops->print_isl_int(p, i);
 656 }
 657
 658 __isl_give isl_printer *isl_printer_start_line(__isl_take isl_printer *p)
 659 {
 660         if (!p)
 661                 return NULL;
 662
 663         return p->ops->start_line(p);
 664 }
 665
 666 __isl_give isl_printer *isl_printer_end_line(__isl_take isl_printer *p)
 667 {
 668         if (!p)
 669                 return NULL;
 670
 671         return p->ops->end_line(p);
 672 }
 673
 674 /* Return a copy of the string constructed by the string printer "printer".
 675  */
 676 __isl_give char *isl_printer_get_str(__isl_keep isl_printer *printer)
 677 {
 678         if (!printer)
 679                 return NULL;
 680         if (printer->ops != &str_ops)
 681                 isl_die(isl_printer_get_ctx(printer), isl_error_invalid,
 682                         "isl_printer_get_str can only be called on a string "
 683                         "printer", return NULL);
 684         if (!printer->buf)
 685                 return NULL;
 686         return strdup(printer->buf);
 687 }
 688
 689 __isl_give isl_printer *isl_printer_flush(__isl_take isl_printer *p)
 690 {
 691         if (!p)
 692                 return NULL;
 693
 694         return p->ops->flush(p);
 695 }
 696
 697 /* Start a YAML mapping and push a new state to reflect that we
 698  * are about to print the first key in a mapping.
 699  *
 700  * In flow style, print the opening brace.
 701  * In block style, move to the next line with an increased indentation,
 702  * except if this is the outer mapping or if we are inside a sequence
 703  * (in which case we have already increased the indentation and we want
 704  * to print the first key on the same line as the dash).
 705  */
 706 __isl_give isl_printer *isl_printer_yaml_start_mapping(
 707         __isl_take isl_printer *p)
 708 {
 709         enum isl_yaml_state state;
 710
 711         if (!p)
 712                 return NULL;
 713         p = enter_state(p, p->yaml_style == ISL_YAML_STYLE_BLOCK);
 714         if (!p)
 715                 return NULL;
 716         state = current_state(p);
 717         if (p->yaml_style == ISL_YAML_STYLE_FLOW)
 718                 p = p->ops->print_str(p, "{ ");
 719         else if (state != isl_yaml_none && state != isl_yaml_sequence) {
 720                 p = p->ops->end_line(p);
 721                 p = isl_printer_indent(p, 2);
 722                 p = p->ops->start_line(p);
 723         }
 724         p = push_state(p, isl_yaml_mapping_first_key_start);
 725         return p;
 726 }
 727
 728 /* Finish a YAML mapping and pop it from the state stack.
 729  *
 730  * In flow style, print the closing brace.
 731  *
 732  * In block style, first check if we are still in the
 733  * isl_yaml_mapping_first_key_start state.  If so, we have not printed
 734  * anything yet, so print "{}" to indicate an empty mapping.
 735  * If we increased the indentation in isl_printer_yaml_start_mapping,
 736  * then decrease it again.
 737  * If this is the outer mapping then print a newline.
 738  */
 739 __isl_give isl_printer *isl_printer_yaml_end_mapping(
 740         __isl_take isl_printer *p)
 741 {
 742         enum isl_yaml_state state;
 743
 744         state = current_state(p);
 745         p = pop_state(p);
 746         if (!p)
 747                 return NULL;
 748         if (p->yaml_style == ISL_YAML_STYLE_FLOW)
 749                 return p->ops->print_str(p, " }");
 750         if (state == isl_yaml_mapping_first_key_start)
 751                 p = p->ops->print_str(p, "{}");
 752         if (!p)
 753                 return NULL;
 754         state = current_state(p);
 755         if (state != isl_yaml_none && state != isl_yaml_sequence)
 756                 p = isl_printer_indent(p, -2);
 757         if (state == isl_yaml_none)
 758                 p = p->ops->end_line(p);
 759         return p;
 760 }
 761
 762 /* Start a YAML sequence and push a new state to reflect that we
 763  * are about to print the first element in a sequence.
 764  *
 765  * In flow style, print the opening bracket.
 766  */
 767 __isl_give isl_printer *isl_printer_yaml_start_sequence(
 768         __isl_take isl_printer *p)
 769 {
 770         if (!p)
 771                 return NULL;
 772         p = enter_state(p, p->yaml_style == ISL_YAML_STYLE_BLOCK);
 773         p = push_state(p, isl_yaml_sequence_first_start);
 774         if (!p)
 775                 return NULL;
 776         if (p->yaml_style == ISL_YAML_STYLE_FLOW)
 777                 p = p->ops->print_str(p, "[ ");
 778         return p;
 779 }
 780
 781 /* Finish a YAML sequence and pop it from the state stack.
 782  *
 783  * In flow style, print the closing bracket.
 784  *
 785  * In block style, check if we are still in the
 786  * isl_yaml_sequence_first_start state.  If so, we have not printed
 787  * anything yet, so print "[]" or " []" to indicate an empty sequence.
 788  * We print the extra space when we instructed enter_state not
 789  * to print a space at the end of the line.
 790  * Otherwise, undo the increase in indentation performed by
 791  * enter_state when moving away from the isl_yaml_sequence_first_start
 792  * state.
 793  * If this is the outer sequence then print a newline.
 794  */
 795 __isl_give isl_printer *isl_printer_yaml_end_sequence(
 796         __isl_take isl_printer *p)
 797 {
 798         enum isl_yaml_state state, up;
 799
 800         state = current_state(p);
 801         p = pop_state(p);
 802         if (!p)
 803                 return NULL;
 804         if (p->yaml_style == ISL_YAML_STYLE_FLOW)
 805                 return p->ops->print_str(p, " ]");
 806         up = current_state(p);
 807         if (state == isl_yaml_sequence_first_start) {
 808                 if (up == isl_yaml_mapping_val)
 809                         p = p->ops->print_str(p, " []");
 810                 else
 811                         p = p->ops->print_str(p, "[]");
 812         } else {
 813                 p = isl_printer_indent(p, -2);
 814         }
 815         if (!p)
 816                 return NULL;
 817         state = current_state(p);
 818         if (state == isl_yaml_none)
 819                 p = p->ops->end_line(p);
 820         return p;
 821 }
 822
 823 /* Mark the fact that the current element is finished and that
 824  * the next output belongs to the next element.
 825  * In particular, if we are printing a key, then prepare for
 826  * printing the subsequent value.  If we are printing a value,
 827  * prepare for printing the next key.  If we are printing an
 828  * element in a sequence, prepare for printing the next element.
 829  */
 830 __isl_give isl_printer *isl_printer_yaml_next(__isl_take isl_printer *p)
 831 {
 832         enum isl_yaml_state state;
 833
 834         if (!p)
 835                 return NULL;
 836         if (p->yaml_depth < 1)
 837                 isl_die(isl_printer_get_ctx(p), isl_error_invalid,
 838                         "not in YAML construct", return isl_printer_free(p));
 839
 840         state = current_state(p);
 841         if (state == isl_yaml_mapping_key)
 842                 state = isl_yaml_mapping_val_start;
 843         else if (state == isl_yaml_mapping_val)
 844                 state = isl_yaml_mapping_key_start;
 845         else if (state == isl_yaml_sequence)
 846                 state = isl_yaml_sequence_start;
 847         p = update_state(p, state);
 848
 849         return p;
 850 }