src/emitter.c

   1
   2 #include "yaml_private.h"
   3
   4 /*
   5  * Flush the buffer if needed.
   6  */
   7
   8 #define FLUSH(emitter)                                                          \
   9     ((emitter->buffer.pointer+5 < emitter->buffer.end)                          \
  10      || yaml_emitter_flush(emitter))
  11
  12 /*
  13  * Put a character to the output buffer.
  14  */
  15
  16 #define PUT(emitter,value)                                                      \
  17     (FLUSH(emitter)                                                             \
  18      && (*(emitter->buffer.pointer++) = (yaml_char_t)(value),                   \
  19          emitter->column ++,                                                    \
  20          1))
  21
  22 /*
  23  * Put a line break to the output buffer.
  24  */
  25
  26 #define PUT_BREAK(emitter)                                                      \
  27     (FLUSH(emitter)                                                             \
  28      && ((emitter->line_break == YAML_CR_BREAK ?                                \
  29              (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') :              \
  30           emitter->line_break == YAML_LN_BREAK ?                                \
  31              (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') :              \
  32           emitter->line_break == YAML_CRLN_BREAK ?                              \
  33              (*(emitter->buffer.pointer++) = (yaml_char_t) '\r',                \
  34               *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0),          \
  35          emitter->column = 0,                                                   \
  36          emitter->line ++,                                                      \
  37          1))
  38
  39 /*
  40  * Copy a character from a string into buffer.
  41  */
  42
  43 #define WRITE(emitter,string)                                                   \
  44     (FLUSH(emitter)                                                             \
  45      && (COPY(emitter->buffer,string),                                          \
  46          emitter->column ++,                                                    \
  47          1))
  48
  49 /*
  50  * Copy a line break character from a string into buffer.
  51  */
  52
  53 #define WRITE_BREAK(emitter,string)                                             \
  54     (FLUSH(emitter)                                                             \
  55      && (CHECK(string,'\n') ?                                                   \
  56          (PUT_BREAK(emitter),                                                   \
  57           string.pointer ++,                                                    \
  58           1) :                                                                  \
  59          (COPY(emitter->buffer,string),                                         \
  60           emitter->column = 0,                                                  \
  61           emitter->line ++,                                                     \
  62           1)))
  63
  64 /*
  65  * API functions.
  66  */
  67
  68 YAML_DECLARE(int)
  69 yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
  70
  71 /*
  72  * Utility functions.
  73  */
  74
  75 static int
  76 yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem);
  77
  78 static int
  79 yaml_emitter_need_more_events(yaml_emitter_t *emitter);
  80
  81 static int
  82 yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
  83         yaml_tag_directive_t value, int allow_duplicates);
  84
  85 static int
  86 yaml_emitter_increase_indent(yaml_emitter_t *emitter,
  87         int flow, int indentless);
  88
  89 /*
  90  * State functions.
  91  */
  92
  93 static int
  94 yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event);
  95
  96 static int
  97 yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
  98         yaml_event_t *event);
  99
 100 static int
 101 yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
 102         yaml_event_t *event, int first);
 103
 104 static int
 105 yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
 106         yaml_event_t *event);
 107
 108 static int
 109 yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
 110         yaml_event_t *event);
 111
 112 static int
 113 yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
 114         yaml_event_t *event, int first);
 115
 116 static int
 117 yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
 118         yaml_event_t *event, int first);
 119
 120 static int
 121 yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
 122         yaml_event_t *event, int simple);
 123
 124 static int
 125 yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
 126         yaml_event_t *event, int first);
 127
 128 static int
 129 yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
 130         yaml_event_t *event, int first);
 131
 132 static int
 133 yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
 134         yaml_event_t *event, int simple);
 135
 136 static int
 137 yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
 138         int root, int sequence, int mapping, int simple_key);
 139
 140 static int
 141 yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event);
 142
 143 static int
 144 yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event);
 145
 146 static int
 147 yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event);
 148
 149 static int
 150 yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event);
 151
 152 /*
 153  * Checkers.
 154  */
 155
 156 static int
 157 yaml_emitter_check_empty_document(yaml_emitter_t *emitter);
 158
 159 static int
 160 yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter);
 161
 162 static int
 163 yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter);
 164
 165 static int
 166 yaml_emitter_check_simple_key(yaml_emitter_t *emitter);
 167
 168 static int
 169 yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event);
 170
 171 /*
 172  * Processors.
 173  */
 174
 175 static int
 176 yaml_emitter_process_anchor(yaml_emitter_t *emitter);
 177
 178 static int
 179 yaml_emitter_process_tag(yaml_emitter_t *emitter);
 180
 181 static int
 182 yaml_emitter_process_scalar(yaml_emitter_t *emitter);
 183
 184 /*
 185  * Analyzers.
 186  */
 187
 188 static int
 189 yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
 190         yaml_version_directive_t version_directive);
 191
 192 static int
 193 yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
 194         yaml_tag_directive_t tag_directive);
 195
 196 static int
 197 yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
 198         yaml_char_t *anchor, int alias);
 199
 200 static int
 201 yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
 202         yaml_char_t *tag);
 203
 204 static int
 205 yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
 206         yaml_char_t *value, size_t length);
 207
 208 static int
 209 yaml_emitter_analyze_event(yaml_emitter_t *emitter,
 210         yaml_event_t *event);
 211
 212 /*
 213  * Writers.
 214  */
 215
 216 static int
 217 yaml_emitter_write_bom(yaml_emitter_t *emitter);
 218
 219 static int
 220 yaml_emitter_write_indent(yaml_emitter_t *emitter);
 221
 222 static int
 223 yaml_emitter_write_indicator(yaml_emitter_t *emitter,
 224         char *indicator, int need_whitespace,
 225         int is_whitespace, int is_indention);
 226
 227 static int
 228 yaml_emitter_write_anchor(yaml_emitter_t *emitter,
 229         yaml_char_t *value, size_t length);
 230
 231 static int
 232 yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
 233         yaml_char_t *value, size_t length);
 234
 235 static int
 236 yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
 237         yaml_char_t *value, size_t length, int need_whitespace);
 238
 239 static int
 240 yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
 241         yaml_char_t *value, size_t length, int allow_breaks);
 242
 243 static int
 244 yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
 245         yaml_char_t *value, size_t length, int allow_breaks);
 246
 247 static int
 248 yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
 249         yaml_char_t *value, size_t length, int allow_breaks);
 250
 251 static int
 252 yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
 253         yaml_string_t string);
 254
 255 static int
 256 yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
 257         yaml_char_t *value, size_t length);
 258
 259 static int
 260 yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
 261         yaml_char_t *value, size_t length);
 262
 263 /*
 264  * Set an emitter error and return 0.
 265  */
 266
 267 static int
 268 yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem)
 269 {
 270     emitter->error = YAML_EMITTER_ERROR;
 271     emitter->problem = problem;
 272
 273     return 0;
 274 }
 275
 276 /*
 277  * Emit an event.
 278  */
 279
 280 YAML_DECLARE(int)
 281 yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
 282 {
 283     if (!ENQUEUE(emitter, emitter->events, *event)) {
 284         yaml_event_delete(event);
 285         return 0;
 286     }
 287
 288     while (!yaml_emitter_need_more_events(emitter)) {
 289         if (!yaml_emitter_analyze_event(emitter, emitter->events.head))
 290             return 0;
 291         if (!yaml_emitter_state_machine(emitter, emitter->events.head))
 292             return 0;
 293         yaml_event_delete(&DEQUEUE(emitter, emitter->events));
 294     }
 295
 296     return 1;
 297 }
 298
 299 /*
 300  * Check if we need to accumulate more events before emitting.
 301  *
 302  * We accumulate extra
 303  *  - 1 event for DOCUMENT-START
 304  *  - 2 events for SEQUENCE-START
 305  *  - 3 events for MAPPING-START
 306  */
 307
 308 static int
 309 yaml_emitter_need_more_events(yaml_emitter_t *emitter)
 310 {
 311     int level = 0;
 312     int accumulate = 0;
 313     yaml_event_t *event;
 314
 315     if (QUEUE_EMPTY(emitter, emitter->events))
 316         return 1;
 317
 318     switch (emitter->events.head->type) {
 319         case YAML_DOCUMENT_START_EVENT:
 320             accumulate = 1;
 321             break;
 322         case YAML_SEQUENCE_START_EVENT:
 323             accumulate = 2;
 324             break;
 325         case YAML_MAPPING_START_EVENT:
 326             accumulate = 3;
 327             break;
 328         default:
 329             return 0;
 330     }
 331
 332     if (emitter->events.tail - emitter->events.head > accumulate)
 333         return 0;
 334
 335     for (event = emitter->events.head; event != emitter->events.tail; event ++) {
 336         switch (event->type) {
 337             case YAML_STREAM_START_EVENT:
 338             case YAML_DOCUMENT_START_EVENT:
 339             case YAML_SEQUENCE_START_EVENT:
 340             case YAML_MAPPING_START_EVENT:
 341                 level += 1;
 342                 break;
 343             case YAML_STREAM_END_EVENT:
 344             case YAML_DOCUMENT_END_EVENT:
 345             case YAML_SEQUENCE_END_EVENT:
 346             case YAML_MAPPING_END_EVENT:
 347                 level -= 1;
 348                 break;
 349             default:
 350                 break;
 351         }
 352         if (!level)
 353             return 0;
 354     }
 355
 356     return 1;
 357 }
 358
 359 /*
 360  * Append a directive to the directives stack.
 361  */
 362
 363 static int
 364 yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
 365         yaml_tag_directive_t value, int allow_duplicates)
 366 {
 367     yaml_tag_directive_t *tag_directive;
 368     yaml_tag_directive_t copy = { NULL, NULL };
 369
 370     for (tag_directive = emitter->tag_directives.start;
 371             tag_directive != emitter->tag_directives.top; tag_directive ++) {
 372         if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
 373             if (allow_duplicates)
 374                 return 1;
 375             return yaml_emitter_set_emitter_error(emitter,
 376                     "duplicate %TAG directive");
 377         }
 378     }
 379
 380     copy.handle = yaml_strdup(value.handle);
 381     copy.prefix = yaml_strdup(value.prefix);
 382     if (!copy.handle || !copy.prefix) {
 383         emitter->error = YAML_MEMORY_ERROR;
 384         goto error;
 385     }
 386
 387     if (!PUSH(emitter, emitter->tag_directives, copy))
 388         goto error;
 389
 390     return 1;
 391
 392 error:
 393     yaml_free(copy.handle);
 394     yaml_free(copy.prefix);
 395     return 0;
 396 }
 397
 398 /*
 399  * Increase the indentation level.
 400  */
 401
 402 static int
 403 yaml_emitter_increase_indent(yaml_emitter_t *emitter,
 404         int flow, int indentless)
 405 {
 406     if (!PUSH(emitter, emitter->indents, emitter->indent))
 407         return 0;
 408
 409     if (emitter->indent < 0) {
 410         emitter->indent = flow ? emitter->best_indent : 0;
 411     }
 412     else if (!indentless) {
 413         emitter->indent += emitter->best_indent;
 414     }
 415
 416     return 1;
 417 }
 418
 419 /*
 420  * State dispatcher.
 421  */
 422
 423 static int
 424 yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event)
 425 {
 426     switch (emitter->state)
 427     {
 428         case YAML_EMIT_STREAM_START_STATE:
 429             return yaml_emitter_emit_stream_start(emitter, event);
 430
 431         case YAML_EMIT_FIRST_DOCUMENT_START_STATE:
 432             return yaml_emitter_emit_document_start(emitter, event, 1);
 433
 434         case YAML_EMIT_DOCUMENT_START_STATE:
 435             return yaml_emitter_emit_document_start(emitter, event, 0);
 436
 437         case YAML_EMIT_DOCUMENT_CONTENT_STATE:
 438             return yaml_emitter_emit_document_content(emitter, event);
 439
 440         case YAML_EMIT_DOCUMENT_END_STATE:
 441             return yaml_emitter_emit_document_end(emitter, event);
 442
 443         case YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
 444             return yaml_emitter_emit_flow_sequence_item(emitter, event, 1);
 445
 446         case YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE:
 447             return yaml_emitter_emit_flow_sequence_item(emitter, event, 0);
 448
 449         case YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
 450             return yaml_emitter_emit_flow_mapping_key(emitter, event, 1);
 451
 452         case YAML_EMIT_FLOW_MAPPING_KEY_STATE:
 453             return yaml_emitter_emit_flow_mapping_key(emitter, event, 0);
 454
 455         case YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
 456             return yaml_emitter_emit_flow_mapping_value(emitter, event, 1);
 457
 458         case YAML_EMIT_FLOW_MAPPING_VALUE_STATE:
 459             return yaml_emitter_emit_flow_mapping_value(emitter, event, 0);
 460
 461         case YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
 462             return yaml_emitter_emit_block_sequence_item(emitter, event, 1);
 463
 464         case YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
 465             return yaml_emitter_emit_block_sequence_item(emitter, event, 0);
 466
 467         case YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
 468             return yaml_emitter_emit_block_mapping_key(emitter, event, 1);
 469
 470         case YAML_EMIT_BLOCK_MAPPING_KEY_STATE:
 471             return yaml_emitter_emit_block_mapping_key(emitter, event, 0);
 472
 473         case YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
 474             return yaml_emitter_emit_block_mapping_value(emitter, event, 1);
 475
 476         case YAML_EMIT_BLOCK_MAPPING_VALUE_STATE:
 477             return yaml_emitter_emit_block_mapping_value(emitter, event, 0);
 478
 479         case YAML_EMIT_END_STATE:
 480             return yaml_emitter_set_emitter_error(emitter,
 481                     "expected nothing after STREAM-END");
 482
 483         default:
 484             assert(1);      /* Invalid state. */
 485     }
 486
 487     return 0;
 488 }
 489
 490 /*
 491  * Expect STREAM-START.
 492  */
 493
 494 static int
 495 yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
 496         yaml_event_t *event)
 497 {
 498     if (event->type == YAML_STREAM_START_EVENT)
 499     {
 500         if (!emitter->encoding) {
 501             emitter->encoding = event->data.stream_start.encoding;
 502         }
 503
 504         if (!emitter->encoding) {
 505             emitter->encoding = YAML_UTF8_ENCODING;
 506         }
 507
 508         if (emitter->best_indent < 2 || emitter->best_indent > 9) {
 509             emitter->best_indent  = 2;
 510         }
 511
 512         if (emitter->best_width >= 0
 513                 && emitter->best_width <= emitter->best_indent*2) {
 514             emitter->best_width = 80;
 515         }
 516
 517         if (emitter->best_width < 0) {
 518             emitter->best_width = INT_MAX;
 519         }
 520
 521         if (!emitter->line_break) {
 522             emitter->line_break = YAML_LN_BREAK;
 523         }
 524
 525         emitter->indent = -1;
 526
 527         emitter->line = 0;
 528         emitter->column = 0;
 529         emitter->whitespace = 1;
 530         emitter->indention = 1;
 531
 532         if (emitter->encoding != YAML_UTF8_ENCODING) {
 533             if (!yaml_emitter_write_bom(emitter))
 534                 return 0;
 535         }
 536
 537         emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE;
 538
 539         return 1;
 540     }
 541
 542     return yaml_emitter_set_emitter_error(emitter,
 543             "expected STREAM-START");
 544 }
 545
 546 /*
 547  * Expect DOCUMENT-START or STREAM-END.
 548  */
 549
 550 static int
 551 yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
 552         yaml_event_t *event, int first)
 553 {
 554     if (event->type == YAML_DOCUMENT_START_EVENT)
 555     {
 556         yaml_tag_directive_t default_tag_directives[] = {
 557             {(yaml_char_t *)"!", (yaml_char_t *)"!"},
 558             {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
 559             {NULL, NULL}
 560         };
 561         yaml_tag_directive_t *tag_directive;
 562         int implicit;
 563
 564         if (event->data.document_start.version_directive) {
 565             if (!yaml_emitter_analyze_version_directive(emitter,
 566                         *event->data.document_start.version_directive))
 567                 return 0;
 568         }
 569
 570         for (tag_directive = event->data.document_start.tag_directives.start;
 571                 tag_directive != event->data.document_start.tag_directives.end;
 572                 tag_directive ++) {
 573             if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive))
 574                 return 0;
 575             if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 0))
 576                 return 0;
 577         }
 578
 579         for (tag_directive = default_tag_directives;
 580                 tag_directive->handle; tag_directive ++) {
 581             if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 1))
 582                 return 0;
 583         }
 584
 585         implicit = event->data.document_start.implicit;
 586         if (!first || emitter->canonical) {
 587             implicit = 0;
 588         }
 589
 590         if ((event->data.document_start.version_directive ||
 591                     (event->data.document_start.tag_directives.start
 592                      != event->data.document_start.tag_directives.end)) &&
 593                 emitter->open_ended)
 594         {
 595             if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
 596                 return 0;
 597             if (!yaml_emitter_write_indent(emitter))
 598                 return 0;
 599         }
 600
 601         if (event->data.document_start.version_directive) {
 602             implicit = 0;
 603             if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0))
 604                 return 0;
 605             if (!yaml_emitter_write_indicator(emitter, "1.1", 1, 0, 0))
 606                 return 0;
 607             if (!yaml_emitter_write_indent(emitter))
 608                 return 0;
 609         }
 610
 611         if (event->data.document_start.tag_directives.start
 612                 != event->data.document_start.tag_directives.end) {
 613             implicit = 0;
 614             for (tag_directive = event->data.document_start.tag_directives.start;
 615                     tag_directive != event->data.document_start.tag_directives.end;
 616                     tag_directive ++) {
 617                 if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0))
 618                     return 0;
 619                 if (!yaml_emitter_write_tag_handle(emitter, tag_directive->handle,
 620                             strlen((char *)tag_directive->handle)))
 621                     return 0;
 622                 if (!yaml_emitter_write_tag_content(emitter, tag_directive->prefix,
 623                             strlen((char *)tag_directive->prefix), 1))
 624                     return 0;
 625                 if (!yaml_emitter_write_indent(emitter))
 626                     return 0;
 627             }
 628         }
 629
 630         if (yaml_emitter_check_empty_document(emitter)) {
 631             implicit = 0;
 632         }
 633
 634         if (!implicit) {
 635             if (!yaml_emitter_write_indent(emitter))
 636                 return 0;
 637             if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0))
 638                 return 0;
 639             if (emitter->canonical) {
 640                 if (!yaml_emitter_write_indent(emitter))
 641                     return 0;
 642             }
 643         }
 644
 645         emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE;
 646
 647         return 1;
 648     }
 649
 650     else if (event->type == YAML_STREAM_END_EVENT)
 651     {
 652
 653         if (!yaml_emitter_flush(emitter))
 654             return 0;
 655
 656         emitter->state = YAML_EMIT_END_STATE;
 657
 658         return 1;
 659     }
 660
 661     return yaml_emitter_set_emitter_error(emitter,
 662             "expected DOCUMENT-START or STREAM-END");
 663 }
 664
 665 /*
 666  * Expect the root node.
 667  */
 668
 669 static int
 670 yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
 671         yaml_event_t *event)
 672 {
 673     if (!PUSH(emitter, emitter->states, YAML_EMIT_DOCUMENT_END_STATE))
 674         return 0;
 675
 676     return yaml_emitter_emit_node(emitter, event, 1, 0, 0, 0);
 677 }
 678
 679 /*
 680  * Expect DOCUMENT-END.
 681  */
 682
 683 static int
 684 yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
 685         yaml_event_t *event)
 686 {
 687     if (event->type == YAML_DOCUMENT_END_EVENT)
 688     {
 689         if (!yaml_emitter_write_indent(emitter))
 690             return 0;
 691         if (!event->data.document_end.implicit) {
 692             if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
 693                 return 0;
 694             if (!yaml_emitter_write_indent(emitter))
 695                 return 0;
 696         }
 697         if (!yaml_emitter_flush(emitter))
 698             return 0;
 699
 700         emitter->state = YAML_EMIT_DOCUMENT_START_STATE;
 701
 702         while (!STACK_EMPTY(emitter, emitter->tag_directives)) {
 703             yaml_tag_directive_t tag_directive = POP(emitter,
 704                     emitter->tag_directives);
 705             yaml_free(tag_directive.handle);
 706             yaml_free(tag_directive.prefix);
 707         }
 708
 709         return 1;
 710     }
 711
 712     return yaml_emitter_set_emitter_error(emitter,
 713             "expected DOCUMENT-END");
 714 }
 715
 716 /*
 717  *
 718  * Expect a flow item node.
 719  */
 720
 721 static int
 722 yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
 723         yaml_event_t *event, int first)
 724 {
 725     if (first)
 726     {
 727         if (!yaml_emitter_write_indicator(emitter, "[", 1, 1, 0))
 728             return 0;
 729         if (!yaml_emitter_increase_indent(emitter, 1, 0))
 730             return 0;
 731         emitter->flow_level ++;
 732     }
 733
 734     if (event->type == YAML_SEQUENCE_END_EVENT)
 735     {
 736         emitter->flow_level --;
 737         emitter->indent = POP(emitter, emitter->indents);
 738         if (emitter->canonical && !first) {
 739             if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
 740                 return 0;
 741             if (!yaml_emitter_write_indent(emitter))
 742                 return 0;
 743         }
 744         if (!yaml_emitter_write_indicator(emitter, "]", 0, 0, 0))
 745             return 0;
 746         emitter->state = POP(emitter, emitter->states);
 747
 748         return 1;
 749     }
 750
 751     if (!first) {
 752         if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
 753             return 0;
 754     }
 755
 756     if (emitter->canonical || emitter->column > emitter->best_width) {
 757         if (!yaml_emitter_write_indent(emitter))
 758             return 0;
 759     }
 760     if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE))
 761         return 0;
 762
 763     return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
 764 }
 765
 766 /*
 767  * Expect a flow key node.
 768  */
 769
 770 static int
 771 yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
 772         yaml_event_t *event, int first)
 773 {
 774     if (first)
 775     {
 776         if (!yaml_emitter_write_indicator(emitter, "{", 1, 1, 0))
 777             return 0;
 778         if (!yaml_emitter_increase_indent(emitter, 1, 0))
 779             return 0;
 780         emitter->flow_level ++;
 781     }
 782
 783     if (event->type == YAML_MAPPING_END_EVENT)
 784     {
 785         emitter->flow_level --;
 786         emitter->indent = POP(emitter, emitter->indents);
 787         if (emitter->canonical && !first) {
 788             if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
 789                 return 0;
 790             if (!yaml_emitter_write_indent(emitter))
 791                 return 0;
 792         }
 793         if (!yaml_emitter_write_indicator(emitter, "}", 0, 0, 0))
 794             return 0;
 795         emitter->state = POP(emitter, emitter->states);
 796
 797         return 1;
 798     }
 799
 800     if (!first) {
 801         if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
 802             return 0;
 803     }
 804     if (emitter->canonical || emitter->column > emitter->best_width) {
 805         if (!yaml_emitter_write_indent(emitter))
 806             return 0;
 807     }
 808
 809     if (!emitter->canonical && yaml_emitter_check_simple_key(emitter))
 810     {
 811         if (!PUSH(emitter, emitter->states,
 812                     YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE))
 813             return 0;
 814
 815         return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
 816     }
 817     else
 818     {
 819         if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 0))
 820             return 0;
 821         if (!PUSH(emitter, emitter->states,
 822                     YAML_EMIT_FLOW_MAPPING_VALUE_STATE))
 823             return 0;
 824
 825         return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
 826     }
 827 }
 828
 829 /*
 830  * Expect a flow value node.
 831  */
 832
 833 static int
 834 yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
 835         yaml_event_t *event, int simple)
 836 {
 837     if (simple) {
 838         if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
 839             return 0;
 840     }
 841     else {
 842         if (emitter->canonical || emitter->column > emitter->best_width) {
 843             if (!yaml_emitter_write_indent(emitter))
 844                 return 0;
 845         }
 846         if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0))
 847             return 0;
 848     }
 849     if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE))
 850         return 0;
 851     return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
 852 }
 853
 854 /*
 855  * Expect a block item node.
 856  */
 857
 858 static int
 859 yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
 860         yaml_event_t *event, int first)
 861 {
 862     if (first)
 863     {
 864         if (!yaml_emitter_increase_indent(emitter, 0,
 865                     (emitter->mapping_context && !emitter->indention)))
 866             return 0;
 867     }
 868
 869     if (event->type == YAML_SEQUENCE_END_EVENT)
 870     {
 871         emitter->indent = POP(emitter, emitter->indents);
 872         emitter->state = POP(emitter, emitter->states);
 873
 874         return 1;
 875     }
 876
 877     if (!yaml_emitter_write_indent(emitter))
 878         return 0;
 879     if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1))
 880         return 0;
 881     if (!PUSH(emitter, emitter->states,
 882                 YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE))
 883         return 0;
 884
 885     return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
 886 }
 887
 888 /*
 889  * Expect a block key node.
 890  */
 891
 892 static int
 893 yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
 894         yaml_event_t *event, int first)
 895 {
 896     if (first)
 897     {
 898         if (!yaml_emitter_increase_indent(emitter, 0, 0))
 899             return 0;
 900     }
 901
 902     if (event->type == YAML_MAPPING_END_EVENT)
 903     {
 904         emitter->indent = POP(emitter, emitter->indents);
 905         emitter->state = POP(emitter, emitter->states);
 906
 907         return 1;
 908     }
 909
 910     if (!yaml_emitter_write_indent(emitter))
 911         return 0;
 912
 913     if (yaml_emitter_check_simple_key(emitter))
 914     {
 915         if (!PUSH(emitter, emitter->states,
 916                     YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE))
 917             return 0;
 918
 919         return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
 920     }
 921     else
 922     {
 923         if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1))
 924             return 0;
 925         if (!PUSH(emitter, emitter->states,
 926                     YAML_EMIT_BLOCK_MAPPING_VALUE_STATE))
 927             return 0;
 928
 929         return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
 930     }
 931 }
 932
 933 /*
 934  * Expect a block value node.
 935  */
 936
 937 static int
 938 yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
 939         yaml_event_t *event, int simple)
 940 {
 941     if (simple) {
 942         if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
 943             return 0;
 944     }
 945     else {
 946         if (!yaml_emitter_write_indent(emitter))
 947             return 0;
 948         if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1))
 949             return 0;
 950     }
 951     if (!PUSH(emitter, emitter->states,
 952                 YAML_EMIT_BLOCK_MAPPING_KEY_STATE))
 953         return 0;
 954
 955     return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
 956 }
 957
 958 /*
 959  * Expect a node.
 960  */
 961
 962 static int
 963 yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
 964         int root, int sequence, int mapping, int simple_key)
 965 {
 966     emitter->root_context = root;
 967     emitter->sequence_context = sequence;
 968     emitter->mapping_context = mapping;
 969     emitter->simple_key_context = simple_key;
 970
 971     switch (event->type)
 972     {
 973         case YAML_ALIAS_EVENT:
 974             return yaml_emitter_emit_alias(emitter, event);
 975
 976         case YAML_SCALAR_EVENT:
 977             return yaml_emitter_emit_scalar(emitter, event);
 978
 979         case YAML_SEQUENCE_START_EVENT:
 980             return yaml_emitter_emit_sequence_start(emitter, event);
 981
 982         case YAML_MAPPING_START_EVENT:
 983             return yaml_emitter_emit_mapping_start(emitter, event);
 984
 985         default:
 986             return yaml_emitter_set_emitter_error(emitter,
 987                     "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS");
 988     }
 989
 990     return 0;
 991 }
 992
 993 /*
 994  * Expect ALIAS.
 995  */
 996
 997 static int
 998 yaml_emitter_emit_alias(yaml_emitter_t *emitter, SHIM(yaml_event_t *event))
 999 {
1000     if (!yaml_emitter_process_anchor(emitter))
1001         return 0;
1002     emitter->state = POP(emitter, emitter->states);
1003
1004     return 1;
1005 }
1006
1007 /*
1008  * Expect SCALAR.
1009  */
1010
1011 static int
1012 yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event)
1013 {
1014     if (!yaml_emitter_select_scalar_style(emitter, event))
1015         return 0;
1016     if (!yaml_emitter_process_anchor(emitter))
1017         return 0;
1018     if (!yaml_emitter_process_tag(emitter))
1019         return 0;
1020     if (!yaml_emitter_increase_indent(emitter, 1, 0))
1021         return 0;
1022     if (!yaml_emitter_process_scalar(emitter))
1023         return 0;
1024     emitter->indent = POP(emitter, emitter->indents);
1025     emitter->state = POP(emitter, emitter->states);
1026
1027     return 1;
1028 }
1029
1030 /*
1031  * Expect SEQUENCE-START.
1032  */
1033
1034 static int
1035 yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event)
1036 {
1037     if (!yaml_emitter_process_anchor(emitter))
1038         return 0;
1039     if (!yaml_emitter_process_tag(emitter))
1040         return 0;
1041
1042     if (emitter->flow_level || emitter->canonical
1043             || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE
1044             || yaml_emitter_check_empty_sequence(emitter)) {
1045         emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE;
1046     }
1047     else {
1048         emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE;
1049     }
1050
1051     return 1;
1052 }
1053
1054 /*
1055  * Expect MAPPING-START.
1056  */
1057
1058 static int
1059 yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event)
1060 {
1061     if (!yaml_emitter_process_anchor(emitter))
1062         return 0;
1063     if (!yaml_emitter_process_tag(emitter))
1064         return 0;
1065
1066     if (emitter->flow_level || emitter->canonical
1067             || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE
1068             || yaml_emitter_check_empty_mapping(emitter)) {
1069         emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE;
1070     }
1071     else {
1072         emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE;
1073     }
1074
1075     return 1;
1076 }
1077
1078 /*
1079  * Check if the document content is an empty scalar.
1080  */
1081
1082 static int
1083 yaml_emitter_check_empty_document(SHIM(yaml_emitter_t *emitter))
1084 {
1085     return 0;
1086 }
1087
1088 /*
1089  * Check if the next events represent an empty sequence.
1090  */
1091
1092 static int
1093 yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter)
1094 {
1095     if (emitter->events.tail - emitter->events.head < 2)
1096         return 0;
1097
1098     return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT
1099             && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT);
1100 }
1101
1102 /*
1103  * Check if the next events represent an empty mapping.
1104  */
1105
1106 static int
1107 yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter)
1108 {
1109     if (emitter->events.tail - emitter->events.head < 2)
1110         return 0;
1111
1112     return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT
1113             && emitter->events.head[1].type == YAML_MAPPING_END_EVENT);
1114 }
1115
1116 /*
1117  * Check if the next node can be expressed as a simple key.
1118  */
1119
1120 static int
1121 yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
1122 {
1123     yaml_event_t *event = emitter->events.head;
1124     size_t length = 0;
1125
1126     switch (event->type)
1127     {
1128         case YAML_ALIAS_EVENT:
1129             length += emitter->anchor_data.anchor_length;
1130             break;
1131
1132         case YAML_SCALAR_EVENT:
1133             if (emitter->scalar_data.multiline)
1134                 return 0;
1135             length += emitter->anchor_data.anchor_length
1136                 + emitter->tag_data.handle_length
1137                 + emitter->tag_data.suffix_length
1138                 + emitter->scalar_data.length;
1139             break;
1140
1141         case YAML_SEQUENCE_START_EVENT:
1142             if (!yaml_emitter_check_empty_sequence(emitter))
1143                 return 0;
1144             length += emitter->anchor_data.anchor_length
1145                 + emitter->tag_data.handle_length
1146                 + emitter->tag_data.suffix_length;
1147             break;
1148
1149         case YAML_MAPPING_START_EVENT:
1150             if (!yaml_emitter_check_empty_mapping(emitter))
1151                 return 0;
1152             length += emitter->anchor_data.anchor_length
1153                 + emitter->tag_data.handle_length
1154                 + emitter->tag_data.suffix_length;
1155             break;
1156
1157         default:
1158             return 0;
1159     }
1160
1161     if (length > 128)
1162         return 0;
1163
1164     return 1;
1165 }
1166
1167 /*
1168  * Determine an acceptable scalar style.
1169  */
1170
1171 static int
1172 yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event)
1173 {
1174     yaml_scalar_style_t style = event->data.scalar.style;
1175     int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix);
1176
1177     if (no_tag && !event->data.scalar.plain_implicit
1178             && !event->data.scalar.quoted_implicit) {
1179         return yaml_emitter_set_emitter_error(emitter,
1180                 "neither tag nor implicit flags are specified");
1181     }
1182
1183     if (style == YAML_ANY_SCALAR_STYLE)
1184         style = YAML_PLAIN_SCALAR_STYLE;
1185
1186     if (emitter->canonical)
1187         style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1188
1189     if (emitter->simple_key_context && emitter->scalar_data.multiline)
1190         style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1191
1192     if (style == YAML_PLAIN_SCALAR_STYLE)
1193     {
1194         if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed)
1195                 || (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed))
1196             style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1197         if (!emitter->scalar_data.length
1198                 && (emitter->flow_level || emitter->simple_key_context))
1199             style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1200         if (no_tag && !event->data.scalar.plain_implicit)
1201             style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1202     }
1203
1204     if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE)
1205     {
1206         if (!emitter->scalar_data.single_quoted_allowed)
1207             style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1208     }
1209
1210     if (style == YAML_LITERAL_SCALAR_STYLE || style == YAML_FOLDED_SCALAR_STYLE)
1211     {
1212         if (!emitter->scalar_data.block_allowed
1213                 || emitter->flow_level || emitter->simple_key_context)
1214             style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1215     }
1216
1217     if (no_tag && !event->data.scalar.quoted_implicit
1218             && style != YAML_PLAIN_SCALAR_STYLE)
1219     {
1220         emitter->tag_data.handle = (yaml_char_t *)"!";
1221         emitter->tag_data.handle_length = 1;
1222     }
1223
1224     emitter->scalar_data.style = style;
1225
1226     return 1;
1227 }
1228
1229 /*
1230  * Write an achor.
1231  */
1232
1233 static int
1234 yaml_emitter_process_anchor(yaml_emitter_t *emitter)
1235 {
1236     if (!emitter->anchor_data.anchor)
1237         return 1;
1238
1239     if (!yaml_emitter_write_indicator(emitter,
1240                 (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0))
1241         return 0;
1242
1243     return yaml_emitter_write_anchor(emitter,
1244             emitter->anchor_data.anchor, emitter->anchor_data.anchor_length);
1245 }
1246
1247 /*
1248  * Write a tag.
1249  */
1250
1251 static int
1252 yaml_emitter_process_tag(yaml_emitter_t *emitter)
1253 {
1254     if (!emitter->tag_data.handle && !emitter->tag_data.suffix)
1255         return 1;
1256
1257     if (emitter->tag_data.handle)
1258     {
1259         if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle,
1260                     emitter->tag_data.handle_length))
1261             return 0;
1262         if (emitter->tag_data.suffix) {
1263             if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
1264                         emitter->tag_data.suffix_length, 0))
1265                 return 0;
1266         }
1267     }
1268     else
1269     {
1270         if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0))
1271             return 0;
1272         if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
1273                     emitter->tag_data.suffix_length, 0))
1274             return 0;
1275         if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0))
1276             return 0;
1277     }
1278
1279     return 1;
1280 }
1281
1282 /*
1283  * Write a scalar.
1284  */
1285
1286 static int
1287 yaml_emitter_process_scalar(yaml_emitter_t *emitter)
1288 {
1289     switch (emitter->scalar_data.style)
1290     {
1291         case YAML_PLAIN_SCALAR_STYLE:
1292             return yaml_emitter_write_plain_scalar(emitter,
1293                     emitter->scalar_data.value, emitter->scalar_data.length,
1294                     !emitter->simple_key_context);
1295
1296         case YAML_SINGLE_QUOTED_SCALAR_STYLE:
1297             return yaml_emitter_write_single_quoted_scalar(emitter,
1298                     emitter->scalar_data.value, emitter->scalar_data.length,
1299                     !emitter->simple_key_context);
1300
1301         case YAML_DOUBLE_QUOTED_SCALAR_STYLE:
1302             return yaml_emitter_write_double_quoted_scalar(emitter,
1303                     emitter->scalar_data.value, emitter->scalar_data.length,
1304                     !emitter->simple_key_context);
1305
1306         case YAML_LITERAL_SCALAR_STYLE:
1307             return yaml_emitter_write_literal_scalar(emitter,
1308                     emitter->scalar_data.value, emitter->scalar_data.length);
1309
1310         case YAML_FOLDED_SCALAR_STYLE:
1311             return yaml_emitter_write_folded_scalar(emitter,
1312                     emitter->scalar_data.value, emitter->scalar_data.length);
1313
1314         default:
1315             assert(1);      /* Impossible. */
1316     }
1317
1318     return 0;
1319 }
1320
1321 /*
1322  * Check if a %YAML directive is valid.
1323  */
1324
1325 static int
1326 yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
1327         yaml_version_directive_t version_directive)
1328 {
1329     if (version_directive.major != 1 || version_directive.minor != 1) {
1330         return yaml_emitter_set_emitter_error(emitter,
1331                 "incompatible %YAML directive");
1332     }
1333
1334     return 1;
1335 }
1336
1337 /*
1338  * Check if a %TAG directive is valid.
1339  */
1340
1341 static int
1342 yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
1343         yaml_tag_directive_t tag_directive)
1344 {
1345     yaml_string_t handle;
1346     yaml_string_t prefix;
1347     size_t handle_length;
1348     size_t prefix_length;
1349
1350     handle_length = strlen((char *)tag_directive.handle);
1351     prefix_length = strlen((char *)tag_directive.prefix);
1352     STRING_ASSIGN(handle, tag_directive.handle, handle_length);
1353     STRING_ASSIGN(prefix, tag_directive.prefix, prefix_length);
1354
1355     if (handle.start == handle.end) {
1356         return yaml_emitter_set_emitter_error(emitter,
1357                 "tag handle must not be empty");
1358     }
1359
1360     if (handle.start[0] != '!') {
1361         return yaml_emitter_set_emitter_error(emitter,
1362                 "tag handle must start with '!'");
1363     }
1364
1365     if (handle.end[-1] != '!') {
1366         return yaml_emitter_set_emitter_error(emitter,
1367                 "tag handle must end with '!'");
1368     }
1369
1370     handle.pointer ++;
1371
1372     while (handle.pointer < handle.end-1) {
1373         if (!IS_ALPHA(handle)) {
1374             return yaml_emitter_set_emitter_error(emitter,
1375                     "tag handle must contain alphanumerical characters only");
1376         }
1377         MOVE(handle);
1378     }
1379
1380     if (prefix.start == prefix.end) {
1381         return yaml_emitter_set_emitter_error(emitter,
1382                 "tag prefix must not be empty");
1383     }
1384
1385     return 1;
1386 }
1387
1388 /*
1389  * Check if an anchor is valid.
1390  */
1391
1392 static int
1393 yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
1394         yaml_char_t *anchor, int alias)
1395 {
1396     size_t anchor_length;
1397     yaml_string_t string;
1398
1399     anchor_length = strlen((char *)anchor);
1400     STRING_ASSIGN(string, anchor, anchor_length);
1401
1402     if (string.start == string.end) {
1403         return yaml_emitter_set_emitter_error(emitter, alias ?
1404                 "alias value must not be empty" :
1405                 "anchor value must not be empty");
1406     }
1407
1408     while (string.pointer != string.end) {
1409         if (!IS_ALPHA(string)) {
1410             return yaml_emitter_set_emitter_error(emitter, alias ?
1411                     "alias value must contain alphanumerical characters only" :
1412                     "anchor value must contain alphanumerical characters only");
1413         }
1414         MOVE(string);
1415     }
1416
1417     emitter->anchor_data.anchor = string.start;
1418     emitter->anchor_data.anchor_length = string.end - string.start;
1419     emitter->anchor_data.alias = alias;
1420
1421     return 1;
1422 }
1423
1424 /*
1425  * Check if a tag is valid.
1426  */
1427
1428 static int
1429 yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
1430         yaml_char_t *tag)
1431 {
1432     size_t tag_length;
1433     yaml_string_t string;
1434     yaml_tag_directive_t *tag_directive;
1435
1436     tag_length = strlen((char *)tag);
1437     STRING_ASSIGN(string, tag, tag_length);
1438
1439     if (string.start == string.end) {
1440         return yaml_emitter_set_emitter_error(emitter,
1441                 "tag value must not be empty");
1442     }
1443
1444     for (tag_directive = emitter->tag_directives.start;
1445             tag_directive != emitter->tag_directives.top; tag_directive ++) {
1446         size_t prefix_length = strlen((char *)tag_directive->prefix);
1447         if (prefix_length < (size_t)(string.end - string.start)
1448                 && strncmp((char *)tag_directive->prefix, (char *)string.start,
1449                     prefix_length) == 0)
1450         {
1451             emitter->tag_data.handle = tag_directive->handle;
1452             emitter->tag_data.handle_length =
1453                 strlen((char *)tag_directive->handle);
1454             emitter->tag_data.suffix = string.start + prefix_length;
1455             emitter->tag_data.suffix_length =
1456                 (string.end - string.start) - prefix_length;
1457             return 1;
1458         }
1459     }
1460
1461     emitter->tag_data.suffix = string.start;
1462     emitter->tag_data.suffix_length = string.end - string.start;
1463
1464     return 1;
1465 }
1466
1467 /*
1468  * Check if a scalar is valid.
1469  */
1470
1471 static int
1472 yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
1473         yaml_char_t *value, size_t length)
1474 {
1475     yaml_string_t string;
1476
1477     int block_indicators = 0;
1478     int flow_indicators = 0;
1479     int line_breaks = 0;
1480     int special_characters = 0;
1481
1482     int leading_space = 0;
1483     int leading_break = 0;
1484     int trailing_space = 0;
1485     int trailing_break = 0;
1486     int break_space = 0;
1487     int space_break = 0;
1488
1489     int preceded_by_whitespace = 0;
1490     int followed_by_whitespace = 0;
1491     int previous_space = 0;
1492     int previous_break = 0;
1493
1494     STRING_ASSIGN(string, value, length);
1495
1496     emitter->scalar_data.value = value;
1497     emitter->scalar_data.length = length;
1498
1499     if (string.start == string.end)
1500     {
1501         emitter->scalar_data.multiline = 0;
1502         emitter->scalar_data.flow_plain_allowed = 0;
1503         emitter->scalar_data.block_plain_allowed = 1;
1504         emitter->scalar_data.single_quoted_allowed = 1;
1505         emitter->scalar_data.block_allowed = 0;
1506
1507         return 1;
1508     }
1509
1510     if ((CHECK_AT(string, '-', 0)
1511                 && CHECK_AT(string, '-', 1)
1512                 && CHECK_AT(string, '-', 2))
1513             || (CHECK_AT(string, '.', 0)
1514                 && CHECK_AT(string, '.', 1)
1515                 && CHECK_AT(string, '.', 2))) {
1516         block_indicators = 1;
1517         flow_indicators = 1;
1518     }
1519
1520     preceded_by_whitespace = 1;
1521     followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
1522
1523     while (string.pointer != string.end)
1524     {
1525         if (string.start == string.pointer)
1526         {
1527             if (CHECK(string, '#') || CHECK(string, ',')
1528                     || CHECK(string, '[') || CHECK(string, ']')
1529                     || CHECK(string, '{') || CHECK(string, '}')
1530                     || CHECK(string, '&') || CHECK(string, '*')
1531                     || CHECK(string, '!') || CHECK(string, '|')
1532                     || CHECK(string, '>') || CHECK(string, '\'')
1533                     || CHECK(string, '"') || CHECK(string, '%')
1534                     || CHECK(string, '@') || CHECK(string, '`')) {
1535                 flow_indicators = 1;
1536                 block_indicators = 1;
1537             }
1538
1539             if (CHECK(string, '?') || CHECK(string, ':')) {
1540                 flow_indicators = 1;
1541                 if (followed_by_whitespace) {
1542                     block_indicators = 1;
1543                 }
1544             }
1545
1546             if (CHECK(string, '-') && followed_by_whitespace) {
1547                 flow_indicators = 1;
1548                 block_indicators = 1;
1549             }
1550         }
1551         else
1552         {
1553             if (CHECK(string, ',') || CHECK(string, '?')
1554                     || CHECK(string, '[') || CHECK(string, ']')
1555                     || CHECK(string, '{') || CHECK(string, '}')) {
1556                 flow_indicators = 1;
1557             }
1558
1559             if (CHECK(string, ':')) {
1560                 flow_indicators = 1;
1561                 if (followed_by_whitespace) {
1562                     block_indicators = 1;
1563                 }
1564             }
1565
1566             if (CHECK(string, '#') && preceded_by_whitespace) {
1567                 flow_indicators = 1;
1568                 block_indicators = 1;
1569             }
1570         }
1571
1572         if (!IS_PRINTABLE(string)
1573                 || (!IS_ASCII(string) && !emitter->unicode)) {
1574             special_characters = 1;
1575         }
1576
1577         if (IS_BREAK(string)) {
1578             line_breaks = 1;
1579         }
1580
1581         if (IS_SPACE(string))
1582         {
1583             if (string.start == string.pointer) {
1584                 leading_space = 1;
1585             }
1586             if (string.pointer+WIDTH(string) == string.end) {
1587                 trailing_space = 1;
1588             }
1589             if (previous_break) {
1590                 break_space = 1;
1591             }
1592             previous_space = 1;
1593             previous_break = 0;
1594         }
1595         else if (IS_BREAK(string))
1596         {
1597             if (string.start == string.pointer) {
1598                 leading_break = 1;
1599             }
1600             if (string.pointer+WIDTH(string) == string.end) {
1601                 trailing_break = 1;
1602             }
1603             if (previous_space) {
1604                 space_break = 1;
1605             }
1606             previous_space = 0;
1607             previous_break = 1;
1608         }
1609         else
1610         {
1611             previous_space = 0;
1612             previous_break = 0;
1613         }
1614
1615         preceded_by_whitespace = IS_BLANKZ(string);
1616         MOVE(string);
1617         if (string.pointer != string.end) {
1618             followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
1619         }
1620     }
1621
1622     emitter->scalar_data.multiline = line_breaks;
1623
1624     emitter->scalar_data.flow_plain_allowed = 1;
1625     emitter->scalar_data.block_plain_allowed = 1;
1626     emitter->scalar_data.single_quoted_allowed = 1;
1627     emitter->scalar_data.block_allowed = 1;
1628
1629     if (leading_space || leading_break || trailing_space || trailing_break) {
1630         emitter->scalar_data.flow_plain_allowed = 0;
1631         emitter->scalar_data.block_plain_allowed = 0;
1632     }
1633
1634     if (trailing_space) {
1635         emitter->scalar_data.block_allowed = 0;
1636     }
1637
1638     if (break_space) {
1639         emitter->scalar_data.flow_plain_allowed = 0;
1640         emitter->scalar_data.block_plain_allowed = 0;
1641         emitter->scalar_data.single_quoted_allowed = 0;
1642     }
1643
1644     if (space_break || special_characters) {
1645         emitter->scalar_data.flow_plain_allowed = 0;
1646         emitter->scalar_data.block_plain_allowed = 0;
1647         emitter->scalar_data.single_quoted_allowed = 0;
1648         emitter->scalar_data.block_allowed = 0;
1649     }
1650
1651     if (line_breaks) {
1652         emitter->scalar_data.flow_plain_allowed = 0;
1653         emitter->scalar_data.block_plain_allowed = 0;
1654     }
1655
1656     if (flow_indicators) {
1657         emitter->scalar_data.flow_plain_allowed = 0;
1658     }
1659
1660     if (block_indicators) {
1661         emitter->scalar_data.block_plain_allowed = 0;
1662     }
1663
1664     return 1;
1665 }
1666
1667 /*
1668  * Check if the event data is valid.
1669  */
1670
1671 static int
1672 yaml_emitter_analyze_event(yaml_emitter_t *emitter,
1673         yaml_event_t *event)
1674 {
1675     emitter->anchor_data.anchor = NULL;
1676     emitter->anchor_data.anchor_length = 0;
1677     emitter->tag_data.handle = NULL;
1678     emitter->tag_data.handle_length = 0;
1679     emitter->tag_data.suffix = NULL;
1680     emitter->tag_data.suffix_length = 0;
1681     emitter->scalar_data.value = NULL;
1682     emitter->scalar_data.length = 0;
1683
1684     switch (event->type)
1685     {
1686         case YAML_ALIAS_EVENT:
1687             if (!yaml_emitter_analyze_anchor(emitter,
1688                         event->data.alias.anchor, 1))
1689                 return 0;
1690             return 1;
1691
1692         case YAML_SCALAR_EVENT:
1693             if (event->data.scalar.anchor) {
1694                 if (!yaml_emitter_analyze_anchor(emitter,
1695                             event->data.scalar.anchor, 0))
1696                     return 0;
1697             }
1698             if (event->data.scalar.tag && (emitter->canonical ||
1699                         (!event->data.scalar.plain_implicit
1700                          && !event->data.scalar.quoted_implicit))) {
1701                 if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag))
1702                     return 0;
1703             }
1704             if (!yaml_emitter_analyze_scalar(emitter,
1705                         event->data.scalar.value, event->data.scalar.length))
1706                 return 0;
1707             return 1;
1708
1709         case YAML_SEQUENCE_START_EVENT:
1710             if (event->data.sequence_start.anchor) {
1711                 if (!yaml_emitter_analyze_anchor(emitter,
1712                             event->data.sequence_start.anchor, 0))
1713                     return 0;
1714             }
1715             if (event->data.sequence_start.tag && (emitter->canonical ||
1716                         !event->data.sequence_start.implicit)) {
1717                 if (!yaml_emitter_analyze_tag(emitter,
1718                             event->data.sequence_start.tag))
1719                     return 0;
1720             }
1721             return 1;
1722
1723         case YAML_MAPPING_START_EVENT:
1724             if (event->data.mapping_start.anchor) {
1725                 if (!yaml_emitter_analyze_anchor(emitter,
1726                             event->data.mapping_start.anchor, 0))
1727                     return 0;
1728             }
1729             if (event->data.mapping_start.tag && (emitter->canonical ||
1730                         !event->data.mapping_start.implicit)) {
1731                 if (!yaml_emitter_analyze_tag(emitter,
1732                             event->data.mapping_start.tag))
1733                     return 0;
1734             }
1735             return 1;
1736
1737         default:
1738             return 1;
1739     }
1740 }
1741
1742 /*
1743  * Write the BOM character.
1744  */
1745
1746 static int
1747 yaml_emitter_write_bom(yaml_emitter_t *emitter)
1748 {
1749     if (!FLUSH(emitter)) return 0;
1750
1751     *(emitter->buffer.pointer++) = (yaml_char_t) '\xEF';
1752     *(emitter->buffer.pointer++) = (yaml_char_t) '\xBB';
1753     *(emitter->buffer.pointer++) = (yaml_char_t) '\xBF';
1754
1755     return 1;
1756 }
1757
1758 static int
1759 yaml_emitter_write_indent(yaml_emitter_t *emitter)
1760 {
1761     int indent = (emitter->indent >= 0) ? emitter->indent : 0;
1762
1763     if (!emitter->indention || emitter->column > indent
1764             || (emitter->column == indent && !emitter->whitespace)) {
1765         if (!PUT_BREAK(emitter)) return 0;
1766     }
1767
1768     while (emitter->column < indent) {
1769         if (!PUT(emitter, ' ')) return 0;
1770     }
1771
1772     emitter->whitespace = 1;
1773     emitter->indention = 1;
1774
1775     return 1;
1776 }
1777
1778 static int
1779 yaml_emitter_write_indicator(yaml_emitter_t *emitter,
1780         char *indicator, int need_whitespace,
1781         int is_whitespace, int is_indention)
1782 {
1783     size_t indicator_length;
1784     yaml_string_t string;
1785
1786     indicator_length = strlen(indicator);
1787     STRING_ASSIGN(string, (yaml_char_t *)indicator, indicator_length);
1788
1789     if (need_whitespace && !emitter->whitespace) {
1790         if (!PUT(emitter, ' ')) return 0;
1791     }
1792
1793     while (string.pointer != string.end) {
1794         if (!WRITE(emitter, string)) return 0;
1795     }
1796
1797     emitter->whitespace = is_whitespace;
1798     emitter->indention = (emitter->indention && is_indention);
1799     emitter->open_ended = 0;
1800
1801     return 1;
1802 }
1803
1804 static int
1805 yaml_emitter_write_anchor(yaml_emitter_t *emitter,
1806         yaml_char_t *value, size_t length)
1807 {
1808     yaml_string_t string;
1809     STRING_ASSIGN(string, value, length);
1810
1811     while (string.pointer != string.end) {
1812         if (!WRITE(emitter, string)) return 0;
1813     }
1814
1815     emitter->whitespace = 0;
1816     emitter->indention = 0;
1817
1818     return 1;
1819 }
1820
1821 static int
1822 yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
1823         yaml_char_t *value, size_t length)
1824 {
1825     yaml_string_t string;
1826     STRING_ASSIGN(string, value, length);
1827
1828     if (!emitter->whitespace) {
1829         if (!PUT(emitter, ' ')) return 0;
1830     }
1831
1832     while (string.pointer != string.end) {
1833         if (!WRITE(emitter, string)) return 0;
1834     }
1835
1836     emitter->whitespace = 0;
1837     emitter->indention = 0;
1838
1839     return 1;
1840 }
1841
1842 static int
1843 yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
1844         yaml_char_t *value, size_t length,
1845         int need_whitespace)
1846 {
1847     yaml_string_t string;
1848     STRING_ASSIGN(string, value, length);
1849
1850     if (need_whitespace && !emitter->whitespace) {
1851         if (!PUT(emitter, ' ')) return 0;
1852     }
1853
1854     while (string.pointer != string.end) {
1855         if (IS_ALPHA(string)
1856                 || CHECK(string, ';') || CHECK(string, '/')
1857                 || CHECK(string, '?') || CHECK(string, ':')
1858                 || CHECK(string, '@') || CHECK(string, '&')
1859                 || CHECK(string, '=') || CHECK(string, '+')
1860                 || CHECK(string, '$') || CHECK(string, ',')
1861                 || CHECK(string, '_') || CHECK(string, '.')
1862                 || CHECK(string, '~') || CHECK(string, '*')
1863                 || CHECK(string, '\'') || CHECK(string, '(')
1864                 || CHECK(string, ')') || CHECK(string, '[')
1865                 || CHECK(string, ']')) {
1866             if (!WRITE(emitter, string)) return 0;
1867         }
1868         else {
1869             int width = WIDTH(string);
1870             unsigned int value;
1871             while (width --) {
1872                 value = *(string.pointer++);
1873                 if (!PUT(emitter, '%')) return 0;
1874                 if (!PUT(emitter, (value >> 4)
1875                             + ((value >> 4) < 10 ? '0' : 'A' - 10)))
1876                     return 0;
1877                 if (!PUT(emitter, (value & 0x0F)
1878                             + ((value & 0x0F) < 10 ? '0' : 'A' - 10)))
1879                     return 0;
1880             }
1881         }
1882     }
1883
1884     emitter->whitespace = 0;
1885     emitter->indention = 0;
1886
1887     return 1;
1888 }
1889
1890 static int
1891 yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
1892         yaml_char_t *value, size_t length, int allow_breaks)
1893 {
1894     yaml_string_t string;
1895     int spaces = 0;
1896     int breaks = 0;
1897
1898     STRING_ASSIGN(string, value, length);
1899
1900     if (!emitter->whitespace) {
1901         if (!PUT(emitter, ' ')) return 0;
1902     }
1903
1904     while (string.pointer != string.end)
1905     {
1906         if (IS_SPACE(string))
1907         {
1908             if (allow_breaks && !spaces
1909                     && emitter->column > emitter->best_width
1910                     && !IS_SPACE_AT(string, 1)) {
1911                 if (!yaml_emitter_write_indent(emitter)) return 0;
1912                 MOVE(string);
1913             }
1914             else {
1915                 if (!WRITE(emitter, string)) return 0;
1916             }
1917             spaces = 1;
1918         }
1919         else if (IS_BREAK(string))
1920         {
1921             if (!breaks && CHECK(string, '\n')) {
1922                 if (!PUT_BREAK(emitter)) return 0;
1923             }
1924             if (!WRITE_BREAK(emitter, string)) return 0;
1925             emitter->indention = 1;
1926             breaks = 1;
1927         }
1928         else
1929         {
1930             if (breaks) {
1931                 if (!yaml_emitter_write_indent(emitter)) return 0;
1932             }
1933             if (!WRITE(emitter, string)) return 0;
1934             emitter->indention = 0;
1935             spaces = 0;
1936             breaks = 0;
1937         }
1938     }
1939
1940     emitter->whitespace = 0;
1941     emitter->indention = 0;
1942     if (emitter->root_context)
1943     {
1944         emitter->open_ended = 1;
1945     }
1946
1947     return 1;
1948 }
1949
1950 static int
1951 yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
1952         yaml_char_t *value, size_t length, int allow_breaks)
1953 {
1954     yaml_string_t string;
1955     int spaces = 0;
1956     int breaks = 0;
1957
1958     STRING_ASSIGN(string, value, length);
1959
1960     if (!yaml_emitter_write_indicator(emitter, "'", 1, 0, 0))
1961         return 0;
1962
1963     while (string.pointer != string.end)
1964     {
1965         if (IS_SPACE(string))
1966         {
1967             if (allow_breaks && !spaces
1968                     && emitter->column > emitter->best_width
1969                     && string.pointer != string.start
1970                     && string.pointer != string.end - 1
1971                     && !IS_SPACE_AT(string, 1)) {
1972                 if (!yaml_emitter_write_indent(emitter)) return 0;
1973                 MOVE(string);
1974             }
1975             else {
1976                 if (!WRITE(emitter, string)) return 0;
1977             }
1978             spaces = 1;
1979         }
1980         else if (IS_BREAK(string))
1981         {
1982             if (!breaks && CHECK(string, '\n')) {
1983                 if (!PUT_BREAK(emitter)) return 0;
1984             }
1985             if (!WRITE_BREAK(emitter, string)) return 0;
1986             emitter->indention = 1;
1987             breaks = 1;
1988         }
1989         else
1990         {
1991             if (breaks) {
1992                 if (!yaml_emitter_write_indent(emitter)) return 0;
1993             }
1994             if (CHECK(string, '\'')) {
1995                 if (!PUT(emitter, '\'')) return 0;
1996             }
1997             if (!WRITE(emitter, string)) return 0;
1998             emitter->indention = 0;
1999             spaces = 0;
2000             breaks = 0;
2001         }
2002     }
2003
2004     if (breaks)
2005         if (!yaml_emitter_write_indent(emitter)) return 0;
2006
2007     if (!yaml_emitter_write_indicator(emitter, "'", 0, 0, 0))
2008         return 0;
2009
2010     emitter->whitespace = 0;
2011     emitter->indention = 0;
2012
2013     return 1;
2014 }
2015
2016 static int
2017 yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
2018         yaml_char_t *value, size_t length, int allow_breaks)
2019 {
2020     yaml_string_t string;
2021     int spaces = 0;
2022
2023     STRING_ASSIGN(string, value, length);
2024
2025     if (!yaml_emitter_write_indicator(emitter, "\"", 1, 0, 0))
2026         return 0;
2027
2028     while (string.pointer != string.end)
2029     {
2030         if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string))
2031                 || IS_BOM(string) || IS_BREAK(string)
2032                 || CHECK(string, '"') || CHECK(string, '\\'))
2033         {
2034             unsigned char octet;
2035             unsigned int width;
2036             unsigned int value;
2037             int k;
2038
2039             octet = string.pointer[0];
2040             width = (octet & 0x80) == 0x00 ? 1 :
2041                     (octet & 0xE0) == 0xC0 ? 2 :
2042                     (octet & 0xF0) == 0xE0 ? 3 :
2043                     (octet & 0xF8) == 0xF0 ? 4 : 0;
2044             value = (octet & 0x80) == 0x00 ? octet & 0x7F :
2045                     (octet & 0xE0) == 0xC0 ? octet & 0x1F :
2046                     (octet & 0xF0) == 0xE0 ? octet & 0x0F :
2047                     (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
2048             for (k = 1; k < (int)width; k ++) {
2049                 octet = string.pointer[k];
2050                 value = (value << 6) + (octet & 0x3F);
2051             }
2052             string.pointer += width;
2053
2054             if (!PUT(emitter, '\\')) return 0;
2055
2056             switch (value)
2057             {
2058                 case 0x00:
2059                     if (!PUT(emitter, '0')) return 0;
2060                     break;
2061
2062                 case 0x07:
2063                     if (!PUT(emitter, 'a')) return 0;
2064                     break;
2065
2066                 case 0x08:
2067                     if (!PUT(emitter, 'b')) return 0;
2068                     break;
2069
2070                 case 0x09:
2071                     if (!PUT(emitter, 't')) return 0;
2072                     break;
2073
2074                 case 0x0A:
2075                     if (!PUT(emitter, 'n')) return 0;
2076                     break;
2077
2078                 case 0x0B:
2079                     if (!PUT(emitter, 'v')) return 0;
2080                     break;
2081
2082                 case 0x0C:
2083                     if (!PUT(emitter, 'f')) return 0;
2084                     break;
2085
2086                 case 0x0D:
2087                     if (!PUT(emitter, 'r')) return 0;
2088                     break;
2089
2090                 case 0x1B:
2091                     if (!PUT(emitter, 'e')) return 0;
2092                     break;
2093
2094                 case 0x22:
2095                     if (!PUT(emitter, '\"')) return 0;
2096                     break;
2097
2098                 case 0x5C:
2099                     if (!PUT(emitter, '\\')) return 0;
2100                     break;
2101
2102                 case 0x85:
2103                     if (!PUT(emitter, 'N')) return 0;
2104                     break;
2105
2106                 case 0xA0:
2107                     if (!PUT(emitter, '_')) return 0;
2108                     break;
2109
2110                 case 0x2028:
2111                     if (!PUT(emitter, 'L')) return 0;
2112                     break;
2113
2114                 case 0x2029:
2115                     if (!PUT(emitter, 'P')) return 0;
2116                     break;
2117
2118                 default:
2119                     if (value <= 0xFF) {
2120                         if (!PUT(emitter, 'x')) return 0;
2121                         width = 2;
2122                     }
2123                     else if (value <= 0xFFFF) {
2124                         if (!PUT(emitter, 'u')) return 0;
2125                         width = 4;
2126                     }
2127                     else {
2128                         if (!PUT(emitter, 'U')) return 0;
2129                         width = 8;
2130                     }
2131                     for (k = (width-1)*4; k >= 0; k -= 4) {
2132                         int digit = (value >> k) & 0x0F;
2133                         if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10)))
2134                             return 0;
2135                     }
2136             }
2137             spaces = 0;
2138         }
2139         else if (IS_SPACE(string))
2140         {
2141             if (allow_breaks && !spaces
2142                     && emitter->column > emitter->best_width
2143                     && string.pointer != string.start
2144                     && string.pointer != string.end - 1) {
2145                 if (!yaml_emitter_write_indent(emitter)) return 0;
2146                 if (IS_SPACE_AT(string, 1)) {
2147                     if (!PUT(emitter, '\\')) return 0;
2148                 }
2149                 MOVE(string);
2150             }
2151             else {
2152                 if (!WRITE(emitter, string)) return 0;
2153             }
2154             spaces = 1;
2155         }
2156         else
2157         {
2158             if (!WRITE(emitter, string)) return 0;
2159             spaces = 0;
2160         }
2161     }
2162
2163     if (!yaml_emitter_write_indicator(emitter, "\"", 0, 0, 0))
2164         return 0;
2165
2166     emitter->whitespace = 0;
2167     emitter->indention = 0;
2168
2169     return 1;
2170 }
2171
2172 static int
2173 yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
2174         yaml_string_t string)
2175 {
2176     char indent_hint[2];
2177     char *chomp_hint = NULL;
2178
2179     if (IS_SPACE(string) || IS_BREAK(string))
2180     {
2181         indent_hint[0] = '0' + (char)emitter->best_indent;
2182         indent_hint[1] = '\0';
2183         if (!yaml_emitter_write_indicator(emitter, indent_hint, 0, 0, 0))
2184             return 0;
2185     }
2186
2187     emitter->open_ended = 0;
2188
2189     string.pointer = string.end;
2190     if (string.start == string.pointer)
2191     {
2192         chomp_hint = "-";
2193     }
2194     else
2195     {
2196         do {
2197             string.pointer --;
2198         } while ((*string.pointer & 0xC0) == 0x80);
2199         if (!IS_BREAK(string))
2200         {
2201             chomp_hint = "-";
2202         }
2203         else if (string.start == string.pointer)
2204         {
2205             chomp_hint = "+";
2206             emitter->open_ended = 1;
2207         }
2208         else
2209         {
2210             do {
2211                 string.pointer --;
2212             } while ((*string.pointer & 0xC0) == 0x80);
2213             if (IS_BREAK(string))
2214             {
2215                 chomp_hint = "+";
2216                 emitter->open_ended = 1;
2217             }
2218         }
2219     }
2220
2221     if (chomp_hint)
2222     {
2223         if (!yaml_emitter_write_indicator(emitter, chomp_hint, 0, 0, 0))
2224             return 0;
2225     }
2226
2227     return 1;
2228 }
2229
2230 static int
2231 yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
2232         yaml_char_t *value, size_t length)
2233 {
2234     yaml_string_t string;
2235     int breaks = 1;
2236
2237     STRING_ASSIGN(string, value, length);
2238
2239     if (!yaml_emitter_write_indicator(emitter, "|", 1, 0, 0))
2240         return 0;
2241     if (!yaml_emitter_write_block_scalar_hints(emitter, string))
2242         return 0;
2243     if (!PUT_BREAK(emitter)) return 0;
2244     emitter->indention = 1;
2245     emitter->whitespace = 1;
2246
2247     while (string.pointer != string.end)
2248     {
2249         if (IS_BREAK(string))
2250         {
2251             if (!WRITE_BREAK(emitter, string)) return 0;
2252             emitter->indention = 1;
2253             breaks = 1;
2254         }
2255         else
2256         {
2257             if (breaks) {
2258                 if (!yaml_emitter_write_indent(emitter)) return 0;
2259             }
2260             if (!WRITE(emitter, string)) return 0;
2261             emitter->indention = 0;
2262             breaks = 0;
2263         }
2264     }
2265
2266     return 1;
2267 }
2268
2269 static int
2270 yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
2271         yaml_char_t *value, size_t length)
2272 {
2273     yaml_string_t string;
2274     int breaks = 1;
2275     int leading_spaces = 1;
2276
2277     STRING_ASSIGN(string, value, length);
2278
2279     if (!yaml_emitter_write_indicator(emitter, ">", 1, 0, 0))
2280         return 0;
2281     if (!yaml_emitter_write_block_scalar_hints(emitter, string))
2282         return 0;
2283     if (!PUT_BREAK(emitter)) return 0;
2284     emitter->indention = 1;
2285     emitter->whitespace = 1;
2286
2287     while (string.pointer != string.end)
2288     {
2289         if (IS_BREAK(string))
2290         {
2291             if (!breaks && !leading_spaces && CHECK(string, '\n')) {
2292                 int k = 0;
2293                 while (IS_BREAK_AT(string, k)) {
2294                     k += WIDTH_AT(string, k);
2295                 }
2296                 if (!IS_BLANKZ_AT(string, k)) {
2297                     if (!PUT_BREAK(emitter)) return 0;
2298                 }
2299             }
2300             if (!WRITE_BREAK(emitter, string)) return 0;
2301             emitter->indention = 1;
2302             breaks = 1;
2303         }
2304         else
2305         {
2306             if (breaks) {
2307                 if (!yaml_emitter_write_indent(emitter)) return 0;
2308                 leading_spaces = IS_BLANK(string);
2309             }
2310             if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1)
2311                     && emitter->column > emitter->best_width) {
2312                 if (!yaml_emitter_write_indent(emitter)) return 0;
2313                 MOVE(string);
2314             }
2315             else {
2316                 if (!WRITE(emitter, string)) return 0;
2317             }
2318             emitter->indention = 0;
2319             breaks = 0;
2320         }
2321     }
2322
2323     return 1;
2324 }