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 const 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 emitter->open_ended = 0; 499 if (event->type == YAML_STREAM_START_EVENT) 500 { 501 if (!emitter->encoding) { 502 emitter->encoding = event->data.stream_start.encoding; 503 } 504 505 if (!emitter->encoding) { 506 emitter->encoding = YAML_UTF8_ENCODING; 507 } 508 509 if (emitter->best_indent < 2 || emitter->best_indent > 9) { 510 emitter->best_indent = 2; 511 } 512 513 if (emitter->best_width >= 0 514 && emitter->best_width <= emitter->best_indent*2) { 515 emitter->best_width = 80; 516 } 517 518 if (emitter->best_width < 0) { 519 emitter->best_width = INT_MAX; 520 } 521 522 if (!emitter->line_break) { 523 emitter->line_break = YAML_LN_BREAK; 524 } 525 526 emitter->indent = -1; 527 528 emitter->line = 0; 529 emitter->column = 0; 530 emitter->whitespace = 1; 531 emitter->indention = 1; 532 533 if (emitter->encoding != YAML_UTF8_ENCODING) { 534 if (!yaml_emitter_write_bom(emitter)) 535 return 0; 536 } 537 538 emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE; 539 540 return 1; 541 } 542 543 return yaml_emitter_set_emitter_error(emitter, 544 "expected STREAM-START"); 545 } 546 547 /* 548 * Expect DOCUMENT-START or STREAM-END. 549 */ 550 551 static int 552 yaml_emitter_emit_document_start(yaml_emitter_t *emitter, 553 yaml_event_t *event, int first) 554 { 555 if (event->type == YAML_DOCUMENT_START_EVENT) 556 { 557 yaml_tag_directive_t default_tag_directives[] = { 558 {(yaml_char_t *)"!", (yaml_char_t *)"!"}, 559 {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"}, 560 {NULL, NULL} 561 }; 562 yaml_tag_directive_t *tag_directive; 563 int implicit; 564 565 if (event->data.document_start.version_directive) { 566 if (!yaml_emitter_analyze_version_directive(emitter, 567 *event->data.document_start.version_directive)) 568 return 0; 569 } 570 571 for (tag_directive = event->data.document_start.tag_directives.start; 572 tag_directive != event->data.document_start.tag_directives.end; 573 tag_directive ++) { 574 if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive)) 575 return 0; 576 if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 0)) 577 return 0; 578 } 579 580 for (tag_directive = default_tag_directives; 581 tag_directive->handle; tag_directive ++) { 582 if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 1)) 583 return 0; 584 } 585 586 implicit = event->data.document_start.implicit; 587 if (!first || emitter->canonical) { 588 implicit = 0; 589 } 590 591 if ((event->data.document_start.version_directive || 592 (event->data.document_start.tag_directives.start 593 != event->data.document_start.tag_directives.end)) && 594 emitter->open_ended) 595 { 596 if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) 597 return 0; 598 if (!yaml_emitter_write_indent(emitter)) 599 return 0; 600 } 601 emitter->open_ended = 0; 602 603 if (event->data.document_start.version_directive) { 604 implicit = 0; 605 if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0)) 606 return 0; 607 if (event->data.document_start.version_directive->minor == 1) { 608 if (!yaml_emitter_write_indicator(emitter, "1.1", 1, 0, 0)) 609 return 0; 610 } 611 else { 612 if (!yaml_emitter_write_indicator(emitter, "1.2", 1, 0, 0)) 613 return 0; 614 } 615 if (!yaml_emitter_write_indent(emitter)) 616 return 0; 617 } 618 619 if (event->data.document_start.tag_directives.start 620 != event->data.document_start.tag_directives.end) { 621 implicit = 0; 622 for (tag_directive = event->data.document_start.tag_directives.start; 623 tag_directive != event->data.document_start.tag_directives.end; 624 tag_directive ++) { 625 if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0)) 626 return 0; 627 if (!yaml_emitter_write_tag_handle(emitter, tag_directive->handle, 628 strlen((char *)tag_directive->handle))) 629 return 0; 630 if (!yaml_emitter_write_tag_content(emitter, tag_directive->prefix, 631 strlen((char *)tag_directive->prefix), 1)) 632 return 0; 633 if (!yaml_emitter_write_indent(emitter)) 634 return 0; 635 } 636 } 637 638 if (yaml_emitter_check_empty_document(emitter)) { 639 implicit = 0; 640 } 641 642 if (!implicit) { 643 if (!yaml_emitter_write_indent(emitter)) 644 return 0; 645 if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0)) 646 return 0; 647 if (emitter->canonical) { 648 if (!yaml_emitter_write_indent(emitter)) 649 return 0; 650 } 651 } 652 653 emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE; 654 655 emitter->open_ended = 0; 656 return 1; 657 } 658 659 else if (event->type == YAML_STREAM_END_EVENT) 660 { 661 662 /** 663 * This can happen if a block scalar with trailing empty lines 664 * is at the end of the stream 665 */ 666 if (emitter->open_ended == 2) 667 { 668 if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) 669 return 0; 670 emitter->open_ended = 0; 671 if (!yaml_emitter_write_indent(emitter)) 672 return 0; 673 } 674 if (!yaml_emitter_flush(emitter)) 675 return 0; 676 677 emitter->state = YAML_EMIT_END_STATE; 678 679 return 1; 680 } 681 682 return yaml_emitter_set_emitter_error(emitter, 683 "expected DOCUMENT-START or STREAM-END"); 684 } 685 686 /* 687 * Expect the root node. 688 */ 689 690 static int 691 yaml_emitter_emit_document_content(yaml_emitter_t *emitter, 692 yaml_event_t *event) 693 { 694 if (!PUSH(emitter, emitter->states, YAML_EMIT_DOCUMENT_END_STATE)) 695 return 0; 696 697 return yaml_emitter_emit_node(emitter, event, 1, 0, 0, 0); 698 } 699 700 /* 701 * Expect DOCUMENT-END. 702 */ 703 704 static int 705 yaml_emitter_emit_document_end(yaml_emitter_t *emitter, 706 yaml_event_t *event) 707 { 708 if (event->type == YAML_DOCUMENT_END_EVENT) 709 { 710 if (!yaml_emitter_write_indent(emitter)) 711 return 0; 712 if (!event->data.document_end.implicit) { 713 if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0)) 714 return 0; 715 emitter->open_ended = 0; 716 if (!yaml_emitter_write_indent(emitter)) 717 return 0; 718 } 719 else if (!emitter->open_ended) 720 emitter->open_ended = 1; 721 if (!yaml_emitter_flush(emitter)) 722 return 0; 723 724 emitter->state = YAML_EMIT_DOCUMENT_START_STATE; 725 726 while (!STACK_EMPTY(emitter, emitter->tag_directives)) { 727 yaml_tag_directive_t tag_directive = POP(emitter, 728 emitter->tag_directives); 729 yaml_free(tag_directive.handle); 730 yaml_free(tag_directive.prefix); 731 } 732 733 return 1; 734 } 735 736 return yaml_emitter_set_emitter_error(emitter, 737 "expected DOCUMENT-END"); 738 } 739 740 /* 741 * 742 * Expect a flow item node. 743 */ 744 745 static int 746 yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter, 747 yaml_event_t *event, int first) 748 { 749 if (first) 750 { 751 if (!yaml_emitter_write_indicator(emitter, "[", 1, 1, 0)) 752 return 0; 753 if (!yaml_emitter_increase_indent(emitter, 1, 0)) 754 return 0; 755 emitter->flow_level ++; 756 } 757 758 if (event->type == YAML_SEQUENCE_END_EVENT) 759 { 760 emitter->flow_level --; 761 emitter->indent = POP(emitter, emitter->indents); 762 if (emitter->canonical && !first) { 763 if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) 764 return 0; 765 if (!yaml_emitter_write_indent(emitter)) 766 return 0; 767 } 768 if (!yaml_emitter_write_indicator(emitter, "]", 0, 0, 0)) 769 return 0; 770 emitter->state = POP(emitter, emitter->states); 771 772 return 1; 773 } 774 775 if (!first) { 776 if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) 777 return 0; 778 } 779 780 if (emitter->canonical || emitter->column > emitter->best_width) { 781 if (!yaml_emitter_write_indent(emitter)) 782 return 0; 783 } 784 if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE)) 785 return 0; 786 787 return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0); 788 } 789 790 /* 791 * Expect a flow key node. 792 */ 793 794 static int 795 yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter, 796 yaml_event_t *event, int first) 797 { 798 if (first) 799 { 800 if (!yaml_emitter_write_indicator(emitter, "{", 1, 1, 0)) 801 return 0; 802 if (!yaml_emitter_increase_indent(emitter, 1, 0)) 803 return 0; 804 emitter->flow_level ++; 805 } 806 807 if (event->type == YAML_MAPPING_END_EVENT) 808 { 809 emitter->flow_level --; 810 emitter->indent = POP(emitter, emitter->indents); 811 if (emitter->canonical && !first) { 812 if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) 813 return 0; 814 if (!yaml_emitter_write_indent(emitter)) 815 return 0; 816 } 817 if (!yaml_emitter_write_indicator(emitter, "}", 0, 0, 0)) 818 return 0; 819 emitter->state = POP(emitter, emitter->states); 820 821 return 1; 822 } 823 824 if (!first) { 825 if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0)) 826 return 0; 827 } 828 if (emitter->canonical || emitter->column > emitter->best_width) { 829 if (!yaml_emitter_write_indent(emitter)) 830 return 0; 831 } 832 833 if (!emitter->canonical && yaml_emitter_check_simple_key(emitter)) 834 { 835 if (!PUSH(emitter, emitter->states, 836 YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)) 837 return 0; 838 839 return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1); 840 } 841 else 842 { 843 if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 0)) 844 return 0; 845 if (!PUSH(emitter, emitter->states, 846 YAML_EMIT_FLOW_MAPPING_VALUE_STATE)) 847 return 0; 848 849 return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 850 } 851 } 852 853 /* 854 * Expect a flow value node. 855 */ 856 857 static int 858 yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter, 859 yaml_event_t *event, int simple) 860 { 861 if (simple) { 862 if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0)) 863 return 0; 864 } 865 else { 866 if (emitter->canonical || emitter->column > emitter->best_width) { 867 if (!yaml_emitter_write_indent(emitter)) 868 return 0; 869 } 870 if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0)) 871 return 0; 872 } 873 if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE)) 874 return 0; 875 return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 876 } 877 878 /* 879 * Expect a block item node. 880 */ 881 882 static int 883 yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter, 884 yaml_event_t *event, int first) 885 { 886 if (first) 887 { 888 if (!yaml_emitter_increase_indent(emitter, 0, 889 (emitter->mapping_context && !emitter->indention))) 890 return 0; 891 } 892 893 if (event->type == YAML_SEQUENCE_END_EVENT) 894 { 895 emitter->indent = POP(emitter, emitter->indents); 896 emitter->state = POP(emitter, emitter->states); 897 898 return 1; 899 } 900 901 if (!yaml_emitter_write_indent(emitter)) 902 return 0; 903 if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1)) 904 return 0; 905 if (!PUSH(emitter, emitter->states, 906 YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE)) 907 return 0; 908 909 return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0); 910 } 911 912 /* 913 * Expect a block key node. 914 */ 915 916 static int 917 yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter, 918 yaml_event_t *event, int first) 919 { 920 if (first) 921 { 922 if (!yaml_emitter_increase_indent(emitter, 0, 0)) 923 return 0; 924 } 925 926 if (event->type == YAML_MAPPING_END_EVENT) 927 { 928 emitter->indent = POP(emitter, emitter->indents); 929 emitter->state = POP(emitter, emitter->states); 930 931 return 1; 932 } 933 934 if (!yaml_emitter_write_indent(emitter)) 935 return 0; 936 937 if (yaml_emitter_check_simple_key(emitter)) 938 { 939 if (!PUSH(emitter, emitter->states, 940 YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)) 941 return 0; 942 943 return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1); 944 } 945 else 946 { 947 if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1)) 948 return 0; 949 if (!PUSH(emitter, emitter->states, 950 YAML_EMIT_BLOCK_MAPPING_VALUE_STATE)) 951 return 0; 952 953 return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 954 } 955 } 956 957 /* 958 * Expect a block value node. 959 */ 960 961 static int 962 yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter, 963 yaml_event_t *event, int simple) 964 { 965 if (simple) { 966 if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0)) 967 return 0; 968 } 969 else { 970 if (!yaml_emitter_write_indent(emitter)) 971 return 0; 972 if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1)) 973 return 0; 974 } 975 if (!PUSH(emitter, emitter->states, 976 YAML_EMIT_BLOCK_MAPPING_KEY_STATE)) 977 return 0; 978 979 return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0); 980 } 981 982 /* 983 * Expect a node. 984 */ 985 986 static int 987 yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event, 988 int root, int sequence, int mapping, int simple_key) 989 { 990 emitter->root_context = root; 991 emitter->sequence_context = sequence; 992 emitter->mapping_context = mapping; 993 emitter->simple_key_context = simple_key; 994 995 switch (event->type) 996 { 997 case YAML_ALIAS_EVENT: 998 return yaml_emitter_emit_alias(emitter, event); 999 1000 case YAML_SCALAR_EVENT: 1001 return yaml_emitter_emit_scalar(emitter, event); 1002 1003 case YAML_SEQUENCE_START_EVENT: 1004 return yaml_emitter_emit_sequence_start(emitter, event); 1005 1006 case YAML_MAPPING_START_EVENT: 1007 return yaml_emitter_emit_mapping_start(emitter, event); 1008 1009 default: 1010 return yaml_emitter_set_emitter_error(emitter, 1011 "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS"); 1012 } 1013 1014 return 0; 1015 } 1016 1017 /* 1018 * Expect ALIAS. 1019 */ 1020 1021 static int 1022 yaml_emitter_emit_alias(yaml_emitter_t *emitter, SHIM(yaml_event_t *event)) 1023 { 1024 if (!yaml_emitter_process_anchor(emitter)) 1025 return 0; 1026 if (emitter->simple_key_context) 1027 if (!PUT(emitter, ' ')) return 0; 1028 emitter->state = POP(emitter, emitter->states); 1029 1030 return 1; 1031 } 1032 1033 /* 1034 * Expect SCALAR. 1035 */ 1036 1037 static int 1038 yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event) 1039 { 1040 if (!yaml_emitter_select_scalar_style(emitter, event)) 1041 return 0; 1042 if (!yaml_emitter_process_anchor(emitter)) 1043 return 0; 1044 if (!yaml_emitter_process_tag(emitter)) 1045 return 0; 1046 if (!yaml_emitter_increase_indent(emitter, 1, 0)) 1047 return 0; 1048 if (!yaml_emitter_process_scalar(emitter)) 1049 return 0; 1050 emitter->indent = POP(emitter, emitter->indents); 1051 emitter->state = POP(emitter, emitter->states); 1052 1053 return 1; 1054 } 1055 1056 /* 1057 * Expect SEQUENCE-START. 1058 */ 1059 1060 static int 1061 yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event) 1062 { 1063 if (!yaml_emitter_process_anchor(emitter)) 1064 return 0; 1065 if (!yaml_emitter_process_tag(emitter)) 1066 return 0; 1067 1068 if (emitter->flow_level || emitter->canonical 1069 || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE 1070 || yaml_emitter_check_empty_sequence(emitter)) { 1071 emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE; 1072 } 1073 else { 1074 emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE; 1075 } 1076 1077 return 1; 1078 } 1079 1080 /* 1081 * Expect MAPPING-START. 1082 */ 1083 1084 static int 1085 yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event) 1086 { 1087 if (!yaml_emitter_process_anchor(emitter)) 1088 return 0; 1089 if (!yaml_emitter_process_tag(emitter)) 1090 return 0; 1091 1092 if (emitter->flow_level || emitter->canonical 1093 || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE 1094 || yaml_emitter_check_empty_mapping(emitter)) { 1095 emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE; 1096 } 1097 else { 1098 emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE; 1099 } 1100 1101 return 1; 1102 } 1103 1104 /* 1105 * Check if the document content is an empty scalar. 1106 */ 1107 1108 static int 1109 yaml_emitter_check_empty_document(SHIM(yaml_emitter_t *emitter)) 1110 { 1111 return 0; 1112 } 1113 1114 /* 1115 * Check if the next events represent an empty sequence. 1116 */ 1117 1118 static int 1119 yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter) 1120 { 1121 if (emitter->events.tail - emitter->events.head < 2) 1122 return 0; 1123 1124 return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT 1125 && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT); 1126 } 1127 1128 /* 1129 * Check if the next events represent an empty mapping. 1130 */ 1131 1132 static int 1133 yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter) 1134 { 1135 if (emitter->events.tail - emitter->events.head < 2) 1136 return 0; 1137 1138 return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT 1139 && emitter->events.head[1].type == YAML_MAPPING_END_EVENT); 1140 } 1141 1142 /* 1143 * Check if the next node can be expressed as a simple key. 1144 */ 1145 1146 static int 1147 yaml_emitter_check_simple_key(yaml_emitter_t *emitter) 1148 { 1149 yaml_event_t *event = emitter->events.head; 1150 size_t length = 0; 1151 1152 switch (event->type) 1153 { 1154 case YAML_ALIAS_EVENT: 1155 length += emitter->anchor_data.anchor_length; 1156 break; 1157 1158 case YAML_SCALAR_EVENT: 1159 if (emitter->scalar_data.multiline) 1160 return 0; 1161 length += emitter->anchor_data.anchor_length 1162 + emitter->tag_data.handle_length 1163 + emitter->tag_data.suffix_length 1164 + emitter->scalar_data.length; 1165 break; 1166 1167 case YAML_SEQUENCE_START_EVENT: 1168 if (!yaml_emitter_check_empty_sequence(emitter)) 1169 return 0; 1170 length += emitter->anchor_data.anchor_length 1171 + emitter->tag_data.handle_length 1172 + emitter->tag_data.suffix_length; 1173 break; 1174 1175 case YAML_MAPPING_START_EVENT: 1176 if (!yaml_emitter_check_empty_mapping(emitter)) 1177 return 0; 1178 length += emitter->anchor_data.anchor_length 1179 + emitter->tag_data.handle_length 1180 + emitter->tag_data.suffix_length; 1181 break; 1182 1183 default: 1184 return 0; 1185 } 1186 1187 if (length > 128) 1188 return 0; 1189 1190 return 1; 1191 } 1192 1193 /* 1194 * Determine an acceptable scalar style. 1195 */ 1196 1197 static int 1198 yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event) 1199 { 1200 yaml_scalar_style_t style = event->data.scalar.style; 1201 int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix); 1202 1203 if (no_tag && !event->data.scalar.plain_implicit 1204 && !event->data.scalar.quoted_implicit) { 1205 return yaml_emitter_set_emitter_error(emitter, 1206 "neither tag nor implicit flags are specified"); 1207 } 1208 1209 if (style == YAML_ANY_SCALAR_STYLE) 1210 style = YAML_PLAIN_SCALAR_STYLE; 1211 1212 if (emitter->canonical) 1213 style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1214 1215 if (emitter->simple_key_context && emitter->scalar_data.multiline) 1216 style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1217 1218 if (style == YAML_PLAIN_SCALAR_STYLE) 1219 { 1220 if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed) 1221 || (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed)) 1222 style = YAML_SINGLE_QUOTED_SCALAR_STYLE; 1223 if (!emitter->scalar_data.length 1224 && (emitter->flow_level || emitter->simple_key_context)) 1225 style = YAML_SINGLE_QUOTED_SCALAR_STYLE; 1226 if (no_tag && !event->data.scalar.plain_implicit) 1227 style = YAML_SINGLE_QUOTED_SCALAR_STYLE; 1228 } 1229 1230 if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE) 1231 { 1232 if (!emitter->scalar_data.single_quoted_allowed) 1233 style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1234 } 1235 1236 if (style == YAML_LITERAL_SCALAR_STYLE || style == YAML_FOLDED_SCALAR_STYLE) 1237 { 1238 if (!emitter->scalar_data.block_allowed 1239 || emitter->flow_level || emitter->simple_key_context) 1240 style = YAML_DOUBLE_QUOTED_SCALAR_STYLE; 1241 } 1242 1243 if (no_tag && !event->data.scalar.quoted_implicit 1244 && style != YAML_PLAIN_SCALAR_STYLE) 1245 { 1246 emitter->tag_data.handle = (yaml_char_t *)"!"; 1247 emitter->tag_data.handle_length = 1; 1248 } 1249 1250 emitter->scalar_data.style = style; 1251 1252 return 1; 1253 } 1254 1255 /* 1256 * Write an anchor. 1257 */ 1258 1259 static int 1260 yaml_emitter_process_anchor(yaml_emitter_t *emitter) 1261 { 1262 if (!emitter->anchor_data.anchor) 1263 return 1; 1264 1265 if (!yaml_emitter_write_indicator(emitter, 1266 (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0)) 1267 return 0; 1268 1269 return yaml_emitter_write_anchor(emitter, 1270 emitter->anchor_data.anchor, emitter->anchor_data.anchor_length); 1271 } 1272 1273 /* 1274 * Write a tag. 1275 */ 1276 1277 static int 1278 yaml_emitter_process_tag(yaml_emitter_t *emitter) 1279 { 1280 if (!emitter->tag_data.handle && !emitter->tag_data.suffix) 1281 return 1; 1282 1283 if (emitter->tag_data.handle) 1284 { 1285 if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle, 1286 emitter->tag_data.handle_length)) 1287 return 0; 1288 if (emitter->tag_data.suffix) { 1289 if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix, 1290 emitter->tag_data.suffix_length, 0)) 1291 return 0; 1292 } 1293 } 1294 else 1295 { 1296 if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0)) 1297 return 0; 1298 if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix, 1299 emitter->tag_data.suffix_length, 0)) 1300 return 0; 1301 if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0)) 1302 return 0; 1303 } 1304 1305 return 1; 1306 } 1307 1308 /* 1309 * Write a scalar. 1310 */ 1311 1312 static int 1313 yaml_emitter_process_scalar(yaml_emitter_t *emitter) 1314 { 1315 switch (emitter->scalar_data.style) 1316 { 1317 case YAML_PLAIN_SCALAR_STYLE: 1318 return yaml_emitter_write_plain_scalar(emitter, 1319 emitter->scalar_data.value, emitter->scalar_data.length, 1320 !emitter->simple_key_context); 1321 1322 case YAML_SINGLE_QUOTED_SCALAR_STYLE: 1323 return yaml_emitter_write_single_quoted_scalar(emitter, 1324 emitter->scalar_data.value, emitter->scalar_data.length, 1325 !emitter->simple_key_context); 1326 1327 case YAML_DOUBLE_QUOTED_SCALAR_STYLE: 1328 return yaml_emitter_write_double_quoted_scalar(emitter, 1329 emitter->scalar_data.value, emitter->scalar_data.length, 1330 !emitter->simple_key_context); 1331 1332 case YAML_LITERAL_SCALAR_STYLE: 1333 return yaml_emitter_write_literal_scalar(emitter, 1334 emitter->scalar_data.value, emitter->scalar_data.length); 1335 1336 case YAML_FOLDED_SCALAR_STYLE: 1337 return yaml_emitter_write_folded_scalar(emitter, 1338 emitter->scalar_data.value, emitter->scalar_data.length); 1339 1340 default: 1341 assert(1); /* Impossible. */ 1342 } 1343 1344 return 0; 1345 } 1346 1347 /* 1348 * Check if a %YAML directive is valid. 1349 */ 1350 1351 static int 1352 yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter, 1353 yaml_version_directive_t version_directive) 1354 { 1355 if (version_directive.major != 1 || ( 1356 version_directive.minor != 1 1357 && version_directive.minor != 2 1358 )) { 1359 return yaml_emitter_set_emitter_error(emitter, 1360 "incompatible %YAML directive"); 1361 } 1362 1363 return 1; 1364 } 1365 1366 /* 1367 * Check if a %TAG directive is valid. 1368 */ 1369 1370 static int 1371 yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter, 1372 yaml_tag_directive_t tag_directive) 1373 { 1374 yaml_string_t handle; 1375 yaml_string_t prefix; 1376 size_t handle_length; 1377 size_t prefix_length; 1378 1379 handle_length = strlen((char *)tag_directive.handle); 1380 prefix_length = strlen((char *)tag_directive.prefix); 1381 STRING_ASSIGN(handle, tag_directive.handle, handle_length); 1382 STRING_ASSIGN(prefix, tag_directive.prefix, prefix_length); 1383 1384 if (handle.start == handle.end) { 1385 return yaml_emitter_set_emitter_error(emitter, 1386 "tag handle must not be empty"); 1387 } 1388 1389 if (handle.start[0] != '!') { 1390 return yaml_emitter_set_emitter_error(emitter, 1391 "tag handle must start with '!'"); 1392 } 1393 1394 if (handle.end[-1] != '!') { 1395 return yaml_emitter_set_emitter_error(emitter, 1396 "tag handle must end with '!'"); 1397 } 1398 1399 handle.pointer ++; 1400 1401 while (handle.pointer < handle.end-1) { 1402 if (!IS_ALPHA(handle)) { 1403 return yaml_emitter_set_emitter_error(emitter, 1404 "tag handle must contain alphanumerical characters only"); 1405 } 1406 MOVE(handle); 1407 } 1408 1409 if (prefix.start == prefix.end) { 1410 return yaml_emitter_set_emitter_error(emitter, 1411 "tag prefix must not be empty"); 1412 } 1413 1414 return 1; 1415 } 1416 1417 /* 1418 * Check if an anchor is valid. 1419 */ 1420 1421 static int 1422 yaml_emitter_analyze_anchor(yaml_emitter_t *emitter, 1423 yaml_char_t *anchor, int alias) 1424 { 1425 size_t anchor_length; 1426 yaml_string_t string; 1427 1428 anchor_length = strlen((char *)anchor); 1429 STRING_ASSIGN(string, anchor, anchor_length); 1430 1431 if (string.start == string.end) { 1432 return yaml_emitter_set_emitter_error(emitter, alias ? 1433 "alias value must not be empty" : 1434 "anchor value must not be empty"); 1435 } 1436 1437 while (string.pointer != string.end) { 1438 if (!IS_ALPHA(string)) { 1439 return yaml_emitter_set_emitter_error(emitter, alias ? 1440 "alias value must contain alphanumerical characters only" : 1441 "anchor value must contain alphanumerical characters only"); 1442 } 1443 MOVE(string); 1444 } 1445 1446 emitter->anchor_data.anchor = string.start; 1447 emitter->anchor_data.anchor_length = string.end - string.start; 1448 emitter->anchor_data.alias = alias; 1449 1450 return 1; 1451 } 1452 1453 /* 1454 * Check if a tag is valid. 1455 */ 1456 1457 static int 1458 yaml_emitter_analyze_tag(yaml_emitter_t *emitter, 1459 yaml_char_t *tag) 1460 { 1461 size_t tag_length; 1462 yaml_string_t string; 1463 yaml_tag_directive_t *tag_directive; 1464 1465 tag_length = strlen((char *)tag); 1466 STRING_ASSIGN(string, tag, tag_length); 1467 1468 if (string.start == string.end) { 1469 return yaml_emitter_set_emitter_error(emitter, 1470 "tag value must not be empty"); 1471 } 1472 1473 for (tag_directive = emitter->tag_directives.start; 1474 tag_directive != emitter->tag_directives.top; tag_directive ++) { 1475 size_t prefix_length = strlen((char *)tag_directive->prefix); 1476 if (prefix_length < (size_t)(string.end - string.start) 1477 && strncmp((char *)tag_directive->prefix, (char *)string.start, 1478 prefix_length) == 0) 1479 { 1480 emitter->tag_data.handle = tag_directive->handle; 1481 emitter->tag_data.handle_length = 1482 strlen((char *)tag_directive->handle); 1483 emitter->tag_data.suffix = string.start + prefix_length; 1484 emitter->tag_data.suffix_length = 1485 (string.end - string.start) - prefix_length; 1486 return 1; 1487 } 1488 } 1489 1490 emitter->tag_data.suffix = string.start; 1491 emitter->tag_data.suffix_length = string.end - string.start; 1492 1493 return 1; 1494 } 1495 1496 /* 1497 * Check if a scalar is valid. 1498 */ 1499 1500 static int 1501 yaml_emitter_analyze_scalar(yaml_emitter_t *emitter, 1502 yaml_char_t *value, size_t length) 1503 { 1504 yaml_string_t string; 1505 1506 int block_indicators = 0; 1507 int flow_indicators = 0; 1508 int line_breaks = 0; 1509 int special_characters = 0; 1510 1511 int leading_space = 0; 1512 int leading_break = 0; 1513 int trailing_space = 0; 1514 int trailing_break = 0; 1515 int break_space = 0; 1516 int space_break = 0; 1517 1518 int preceded_by_whitespace = 0; 1519 int followed_by_whitespace = 0; 1520 int previous_space = 0; 1521 int previous_break = 0; 1522 1523 STRING_ASSIGN(string, value, length); 1524 1525 emitter->scalar_data.value = value; 1526 emitter->scalar_data.length = length; 1527 1528 if (string.start == string.end) 1529 { 1530 emitter->scalar_data.multiline = 0; 1531 emitter->scalar_data.flow_plain_allowed = 0; 1532 emitter->scalar_data.block_plain_allowed = 1; 1533 emitter->scalar_data.single_quoted_allowed = 1; 1534 emitter->scalar_data.block_allowed = 0; 1535 1536 return 1; 1537 } 1538 1539 if ((CHECK_AT(string, '-', 0) 1540 && CHECK_AT(string, '-', 1) 1541 && CHECK_AT(string, '-', 2)) 1542 || (CHECK_AT(string, '.', 0) 1543 && CHECK_AT(string, '.', 1) 1544 && CHECK_AT(string, '.', 2))) { 1545 block_indicators = 1; 1546 flow_indicators = 1; 1547 } 1548 1549 preceded_by_whitespace = 1; 1550 followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string)); 1551 1552 while (string.pointer != string.end) 1553 { 1554 if (string.start == string.pointer) 1555 { 1556 if (CHECK(string, '#') || CHECK(string, ',') 1557 || CHECK(string, '[') || CHECK(string, ']') 1558 || CHECK(string, '{') || CHECK(string, '}') 1559 || CHECK(string, '&') || CHECK(string, '*') 1560 || CHECK(string, '!') || CHECK(string, '|') 1561 || CHECK(string, '>') || CHECK(string, '\'') 1562 || CHECK(string, '"') || CHECK(string, '%') 1563 || CHECK(string, '@') || CHECK(string, '`')) { 1564 flow_indicators = 1; 1565 block_indicators = 1; 1566 } 1567 1568 if (CHECK(string, '?') || CHECK(string, ':')) { 1569 flow_indicators = 1; 1570 if (followed_by_whitespace) { 1571 block_indicators = 1; 1572 } 1573 } 1574 1575 if (CHECK(string, '-') && followed_by_whitespace) { 1576 flow_indicators = 1; 1577 block_indicators = 1; 1578 } 1579 } 1580 else 1581 { 1582 if (CHECK(string, ',') || CHECK(string, '?') 1583 || CHECK(string, '[') || CHECK(string, ']') 1584 || CHECK(string, '{') || CHECK(string, '}')) { 1585 flow_indicators = 1; 1586 } 1587 1588 if (CHECK(string, ':')) { 1589 flow_indicators = 1; 1590 if (followed_by_whitespace) { 1591 block_indicators = 1; 1592 } 1593 } 1594 1595 if (CHECK(string, '#') && preceded_by_whitespace) { 1596 flow_indicators = 1; 1597 block_indicators = 1; 1598 } 1599 } 1600 1601 if (!IS_PRINTABLE(string) 1602 || (!IS_ASCII(string) && !emitter->unicode)) { 1603 special_characters = 1; 1604 } 1605 1606 if (IS_BREAK(string)) { 1607 line_breaks = 1; 1608 } 1609 1610 if (IS_SPACE(string)) 1611 { 1612 if (string.start == string.pointer) { 1613 leading_space = 1; 1614 } 1615 if (string.pointer+WIDTH(string) == string.end) { 1616 trailing_space = 1; 1617 } 1618 if (previous_break) { 1619 break_space = 1; 1620 } 1621 previous_space = 1; 1622 previous_break = 0; 1623 } 1624 else if (IS_BREAK(string)) 1625 { 1626 if (string.start == string.pointer) { 1627 leading_break = 1; 1628 } 1629 if (string.pointer+WIDTH(string) == string.end) { 1630 trailing_break = 1; 1631 } 1632 if (previous_space) { 1633 space_break = 1; 1634 } 1635 previous_space = 0; 1636 previous_break = 1; 1637 } 1638 else 1639 { 1640 previous_space = 0; 1641 previous_break = 0; 1642 } 1643 1644 preceded_by_whitespace = IS_BLANKZ(string); 1645 MOVE(string); 1646 if (string.pointer != string.end) { 1647 followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string)); 1648 } 1649 } 1650 1651 emitter->scalar_data.multiline = line_breaks; 1652 1653 emitter->scalar_data.flow_plain_allowed = 1; 1654 emitter->scalar_data.block_plain_allowed = 1; 1655 emitter->scalar_data.single_quoted_allowed = 1; 1656 emitter->scalar_data.block_allowed = 1; 1657 1658 if (leading_space || leading_break || trailing_space || trailing_break) { 1659 emitter->scalar_data.flow_plain_allowed = 0; 1660 emitter->scalar_data.block_plain_allowed = 0; 1661 } 1662 1663 if (trailing_space) { 1664 emitter->scalar_data.block_allowed = 0; 1665 } 1666 1667 if (break_space) { 1668 emitter->scalar_data.flow_plain_allowed = 0; 1669 emitter->scalar_data.block_plain_allowed = 0; 1670 emitter->scalar_data.single_quoted_allowed = 0; 1671 } 1672 1673 if (space_break || special_characters) { 1674 emitter->scalar_data.flow_plain_allowed = 0; 1675 emitter->scalar_data.block_plain_allowed = 0; 1676 emitter->scalar_data.single_quoted_allowed = 0; 1677 emitter->scalar_data.block_allowed = 0; 1678 } 1679 1680 if (line_breaks) { 1681 emitter->scalar_data.flow_plain_allowed = 0; 1682 emitter->scalar_data.block_plain_allowed = 0; 1683 } 1684 1685 if (flow_indicators) { 1686 emitter->scalar_data.flow_plain_allowed = 0; 1687 } 1688 1689 if (block_indicators) { 1690 emitter->scalar_data.block_plain_allowed = 0; 1691 } 1692 1693 return 1; 1694 } 1695 1696 /* 1697 * Check if the event data is valid. 1698 */ 1699 1700 static int 1701 yaml_emitter_analyze_event(yaml_emitter_t *emitter, 1702 yaml_event_t *event) 1703 { 1704 emitter->anchor_data.anchor = NULL; 1705 emitter->anchor_data.anchor_length = 0; 1706 emitter->tag_data.handle = NULL; 1707 emitter->tag_data.handle_length = 0; 1708 emitter->tag_data.suffix = NULL; 1709 emitter->tag_data.suffix_length = 0; 1710 emitter->scalar_data.value = NULL; 1711 emitter->scalar_data.length = 0; 1712 1713 switch (event->type) 1714 { 1715 case YAML_ALIAS_EVENT: 1716 if (!yaml_emitter_analyze_anchor(emitter, 1717 event->data.alias.anchor, 1)) 1718 return 0; 1719 return 1; 1720 1721 case YAML_SCALAR_EVENT: 1722 if (event->data.scalar.anchor) { 1723 if (!yaml_emitter_analyze_anchor(emitter, 1724 event->data.scalar.anchor, 0)) 1725 return 0; 1726 } 1727 if (event->data.scalar.tag && (emitter->canonical || 1728 (!event->data.scalar.plain_implicit 1729 && !event->data.scalar.quoted_implicit))) { 1730 if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag)) 1731 return 0; 1732 } 1733 if (!yaml_emitter_analyze_scalar(emitter, 1734 event->data.scalar.value, event->data.scalar.length)) 1735 return 0; 1736 return 1; 1737 1738 case YAML_SEQUENCE_START_EVENT: 1739 if (event->data.sequence_start.anchor) { 1740 if (!yaml_emitter_analyze_anchor(emitter, 1741 event->data.sequence_start.anchor, 0)) 1742 return 0; 1743 } 1744 if (event->data.sequence_start.tag && (emitter->canonical || 1745 !event->data.sequence_start.implicit)) { 1746 if (!yaml_emitter_analyze_tag(emitter, 1747 event->data.sequence_start.tag)) 1748 return 0; 1749 } 1750 return 1; 1751 1752 case YAML_MAPPING_START_EVENT: 1753 if (event->data.mapping_start.anchor) { 1754 if (!yaml_emitter_analyze_anchor(emitter, 1755 event->data.mapping_start.anchor, 0)) 1756 return 0; 1757 } 1758 if (event->data.mapping_start.tag && (emitter->canonical || 1759 !event->data.mapping_start.implicit)) { 1760 if (!yaml_emitter_analyze_tag(emitter, 1761 event->data.mapping_start.tag)) 1762 return 0; 1763 } 1764 return 1; 1765 1766 default: 1767 return 1; 1768 } 1769 } 1770 1771 /* 1772 * Write the BOM character. 1773 */ 1774 1775 static int 1776 yaml_emitter_write_bom(yaml_emitter_t *emitter) 1777 { 1778 if (!FLUSH(emitter)) return 0; 1779 1780 *(emitter->buffer.pointer++) = (yaml_char_t) '\xEF'; 1781 *(emitter->buffer.pointer++) = (yaml_char_t) '\xBB'; 1782 *(emitter->buffer.pointer++) = (yaml_char_t) '\xBF'; 1783 1784 return 1; 1785 } 1786 1787 static int 1788 yaml_emitter_write_indent(yaml_emitter_t *emitter) 1789 { 1790 int indent = (emitter->indent >= 0) ? emitter->indent : 0; 1791 1792 if (!emitter->indention || emitter->column > indent 1793 || (emitter->column == indent && !emitter->whitespace)) { 1794 if (!PUT_BREAK(emitter)) return 0; 1795 } 1796 1797 while (emitter->column < indent) { 1798 if (!PUT(emitter, ' ')) return 0; 1799 } 1800 1801 emitter->whitespace = 1; 1802 emitter->indention = 1; 1803 1804 return 1; 1805 } 1806 1807 static int 1808 yaml_emitter_write_indicator(yaml_emitter_t *emitter, 1809 const char *indicator, int need_whitespace, 1810 int is_whitespace, int is_indention) 1811 { 1812 size_t indicator_length; 1813 yaml_string_t string; 1814 1815 indicator_length = strlen(indicator); 1816 STRING_ASSIGN(string, (yaml_char_t *)indicator, indicator_length); 1817 1818 if (need_whitespace && !emitter->whitespace) { 1819 if (!PUT(emitter, ' ')) return 0; 1820 } 1821 1822 while (string.pointer != string.end) { 1823 if (!WRITE(emitter, string)) return 0; 1824 } 1825 1826 emitter->whitespace = is_whitespace; 1827 emitter->indention = (emitter->indention && is_indention); 1828 1829 return 1; 1830 } 1831 1832 static int 1833 yaml_emitter_write_anchor(yaml_emitter_t *emitter, 1834 yaml_char_t *value, size_t length) 1835 { 1836 yaml_string_t string; 1837 STRING_ASSIGN(string, value, length); 1838 1839 while (string.pointer != string.end) { 1840 if (!WRITE(emitter, string)) return 0; 1841 } 1842 1843 emitter->whitespace = 0; 1844 emitter->indention = 0; 1845 1846 return 1; 1847 } 1848 1849 static int 1850 yaml_emitter_write_tag_handle(yaml_emitter_t *emitter, 1851 yaml_char_t *value, size_t length) 1852 { 1853 yaml_string_t string; 1854 STRING_ASSIGN(string, value, length); 1855 1856 if (!emitter->whitespace) { 1857 if (!PUT(emitter, ' ')) return 0; 1858 } 1859 1860 while (string.pointer != string.end) { 1861 if (!WRITE(emitter, string)) return 0; 1862 } 1863 1864 emitter->whitespace = 0; 1865 emitter->indention = 0; 1866 1867 return 1; 1868 } 1869 1870 static int 1871 yaml_emitter_write_tag_content(yaml_emitter_t *emitter, 1872 yaml_char_t *value, size_t length, 1873 int need_whitespace) 1874 { 1875 yaml_string_t string; 1876 STRING_ASSIGN(string, value, length); 1877 1878 if (need_whitespace && !emitter->whitespace) { 1879 if (!PUT(emitter, ' ')) return 0; 1880 } 1881 1882 while (string.pointer != string.end) { 1883 if (IS_ALPHA(string) 1884 || CHECK(string, ';') || CHECK(string, '/') 1885 || CHECK(string, '?') || CHECK(string, ':') 1886 || CHECK(string, '@') || CHECK(string, '&') 1887 || CHECK(string, '=') || CHECK(string, '+') 1888 || CHECK(string, '$') || CHECK(string, ',') 1889 || CHECK(string, '_') || CHECK(string, '.') 1890 || CHECK(string, '~') || CHECK(string, '*') 1891 || CHECK(string, '\'') || CHECK(string, '(') 1892 || CHECK(string, ')') || CHECK(string, '[') 1893 || CHECK(string, ']')) { 1894 if (!WRITE(emitter, string)) return 0; 1895 } 1896 else { 1897 int width = WIDTH(string); 1898 unsigned int value; 1899 while (width --) { 1900 value = *(string.pointer++); 1901 if (!PUT(emitter, '%')) return 0; 1902 if (!PUT(emitter, (value >> 4) 1903 + ((value >> 4) < 10 ? '0' : 'A' - 10))) 1904 return 0; 1905 if (!PUT(emitter, (value & 0x0F) 1906 + ((value & 0x0F) < 10 ? '0' : 'A' - 10))) 1907 return 0; 1908 } 1909 } 1910 } 1911 1912 emitter->whitespace = 0; 1913 emitter->indention = 0; 1914 1915 return 1; 1916 } 1917 1918 static int 1919 yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter, 1920 yaml_char_t *value, size_t length, int allow_breaks) 1921 { 1922 yaml_string_t string; 1923 int spaces = 0; 1924 int breaks = 0; 1925 1926 STRING_ASSIGN(string, value, length); 1927 1928 /** 1929 * Avoid trailing spaces for empty values in block mode. 1930 * In flow mode, we still want the space to prevent ambiguous things 1931 * like {a:}. 1932 * Currently, the emitter forbids any plain empty scalar in flow mode 1933 * (e.g. it outputs {a: ''} instead), so emitter->flow_level will 1934 * never be true here. 1935 * But if the emitter is ever changed to allow emitting empty values, 1936 * the check for flow_level is already here. 1937 */ 1938 if (!emitter->whitespace && (length || emitter->flow_level)) { 1939 if (!PUT(emitter, ' ')) return 0; 1940 } 1941 1942 while (string.pointer != string.end) 1943 { 1944 if (IS_SPACE(string)) 1945 { 1946 if (allow_breaks && !spaces 1947 && emitter->column > emitter->best_width 1948 && !IS_SPACE_AT(string, 1)) { 1949 if (!yaml_emitter_write_indent(emitter)) return 0; 1950 MOVE(string); 1951 } 1952 else { 1953 if (!WRITE(emitter, string)) return 0; 1954 } 1955 spaces = 1; 1956 } 1957 else if (IS_BREAK(string)) 1958 { 1959 if (!breaks && CHECK(string, '\n')) { 1960 if (!PUT_BREAK(emitter)) return 0; 1961 } 1962 if (!WRITE_BREAK(emitter, string)) return 0; 1963 emitter->indention = 1; 1964 breaks = 1; 1965 } 1966 else 1967 { 1968 if (breaks) { 1969 if (!yaml_emitter_write_indent(emitter)) return 0; 1970 } 1971 if (!WRITE(emitter, string)) return 0; 1972 emitter->indention = 0; 1973 spaces = 0; 1974 breaks = 0; 1975 } 1976 } 1977 1978 emitter->whitespace = 0; 1979 emitter->indention = 0; 1980 1981 return 1; 1982 } 1983 1984 static int 1985 yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter, 1986 yaml_char_t *value, size_t length, int allow_breaks) 1987 { 1988 yaml_string_t string; 1989 int spaces = 0; 1990 int breaks = 0; 1991 1992 STRING_ASSIGN(string, value, length); 1993 1994 if (!yaml_emitter_write_indicator(emitter, "'", 1, 0, 0)) 1995 return 0; 1996 1997 while (string.pointer != string.end) 1998 { 1999 if (IS_SPACE(string)) 2000 { 2001 if (allow_breaks && !spaces 2002 && emitter->column > emitter->best_width 2003 && string.pointer != string.start 2004 && string.pointer != string.end - 1 2005 && !IS_SPACE_AT(string, 1)) { 2006 if (!yaml_emitter_write_indent(emitter)) return 0; 2007 MOVE(string); 2008 } 2009 else { 2010 if (!WRITE(emitter, string)) return 0; 2011 } 2012 spaces = 1; 2013 } 2014 else if (IS_BREAK(string)) 2015 { 2016 if (!breaks && CHECK(string, '\n')) { 2017 if (!PUT_BREAK(emitter)) return 0; 2018 } 2019 if (!WRITE_BREAK(emitter, string)) return 0; 2020 emitter->indention = 1; 2021 breaks = 1; 2022 } 2023 else 2024 { 2025 if (breaks) { 2026 if (!yaml_emitter_write_indent(emitter)) return 0; 2027 } 2028 if (CHECK(string, '\'')) { 2029 if (!PUT(emitter, '\'')) return 0; 2030 } 2031 if (!WRITE(emitter, string)) return 0; 2032 emitter->indention = 0; 2033 spaces = 0; 2034 breaks = 0; 2035 } 2036 } 2037 2038 if (breaks) 2039 if (!yaml_emitter_write_indent(emitter)) return 0; 2040 2041 if (!yaml_emitter_write_indicator(emitter, "'", 0, 0, 0)) 2042 return 0; 2043 2044 emitter->whitespace = 0; 2045 emitter->indention = 0; 2046 2047 return 1; 2048 } 2049 2050 static int 2051 yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter, 2052 yaml_char_t *value, size_t length, int allow_breaks) 2053 { 2054 yaml_string_t string; 2055 int spaces = 0; 2056 2057 STRING_ASSIGN(string, value, length); 2058 2059 if (!yaml_emitter_write_indicator(emitter, "\"", 1, 0, 0)) 2060 return 0; 2061 2062 while (string.pointer != string.end) 2063 { 2064 if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string)) 2065 || IS_BOM(string) || IS_BREAK(string) 2066 || CHECK(string, '"') || CHECK(string, '\\')) 2067 { 2068 unsigned char octet; 2069 unsigned int width; 2070 unsigned int value; 2071 int k; 2072 2073 octet = string.pointer[0]; 2074 width = (octet & 0x80) == 0x00 ? 1 : 2075 (octet & 0xE0) == 0xC0 ? 2 : 2076 (octet & 0xF0) == 0xE0 ? 3 : 2077 (octet & 0xF8) == 0xF0 ? 4 : 0; 2078 value = (octet & 0x80) == 0x00 ? octet & 0x7F : 2079 (octet & 0xE0) == 0xC0 ? octet & 0x1F : 2080 (octet & 0xF0) == 0xE0 ? octet & 0x0F : 2081 (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; 2082 for (k = 1; k < (int)width; k ++) { 2083 octet = string.pointer[k]; 2084 value = (value << 6) + (octet & 0x3F); 2085 } 2086 string.pointer += width; 2087 2088 if (!PUT(emitter, '\\')) return 0; 2089 2090 switch (value) 2091 { 2092 case 0x00: 2093 if (!PUT(emitter, '0')) return 0; 2094 break; 2095 2096 case 0x07: 2097 if (!PUT(emitter, 'a')) return 0; 2098 break; 2099 2100 case 0x08: 2101 if (!PUT(emitter, 'b')) return 0; 2102 break; 2103 2104 case 0x09: 2105 if (!PUT(emitter, 't')) return 0; 2106 break; 2107 2108 case 0x0A: 2109 if (!PUT(emitter, 'n')) return 0; 2110 break; 2111 2112 case 0x0B: 2113 if (!PUT(emitter, 'v')) return 0; 2114 break; 2115 2116 case 0x0C: 2117 if (!PUT(emitter, 'f')) return 0; 2118 break; 2119 2120 case 0x0D: 2121 if (!PUT(emitter, 'r')) return 0; 2122 break; 2123 2124 case 0x1B: 2125 if (!PUT(emitter, 'e')) return 0; 2126 break; 2127 2128 case 0x22: 2129 if (!PUT(emitter, '\"')) return 0; 2130 break; 2131 2132 case 0x5C: 2133 if (!PUT(emitter, '\\')) return 0; 2134 break; 2135 2136 case 0x85: 2137 if (!PUT(emitter, 'N')) return 0; 2138 break; 2139 2140 case 0xA0: 2141 if (!PUT(emitter, '_')) return 0; 2142 break; 2143 2144 case 0x2028: 2145 if (!PUT(emitter, 'L')) return 0; 2146 break; 2147 2148 case 0x2029: 2149 if (!PUT(emitter, 'P')) return 0; 2150 break; 2151 2152 default: 2153 if (value <= 0xFF) { 2154 if (!PUT(emitter, 'x')) return 0; 2155 width = 2; 2156 } 2157 else if (value <= 0xFFFF) { 2158 if (!PUT(emitter, 'u')) return 0; 2159 width = 4; 2160 } 2161 else { 2162 if (!PUT(emitter, 'U')) return 0; 2163 width = 8; 2164 } 2165 for (k = (width-1)*4; k >= 0; k -= 4) { 2166 int digit = (value >> k) & 0x0F; 2167 if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10))) 2168 return 0; 2169 } 2170 } 2171 spaces = 0; 2172 } 2173 else if (IS_SPACE(string)) 2174 { 2175 if (allow_breaks && !spaces 2176 && emitter->column > emitter->best_width 2177 && string.pointer != string.start 2178 && string.pointer != string.end - 1) { 2179 if (!yaml_emitter_write_indent(emitter)) return 0; 2180 if (IS_SPACE_AT(string, 1)) { 2181 if (!PUT(emitter, '\\')) return 0; 2182 } 2183 MOVE(string); 2184 } 2185 else { 2186 if (!WRITE(emitter, string)) return 0; 2187 } 2188 spaces = 1; 2189 } 2190 else 2191 { 2192 if (!WRITE(emitter, string)) return 0; 2193 spaces = 0; 2194 } 2195 } 2196 2197 if (!yaml_emitter_write_indicator(emitter, "\"", 0, 0, 0)) 2198 return 0; 2199 2200 emitter->whitespace = 0; 2201 emitter->indention = 0; 2202 2203 return 1; 2204 } 2205 2206 static int 2207 yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter, 2208 yaml_string_t string) 2209 { 2210 char indent_hint[2]; 2211 const char *chomp_hint = NULL; 2212 2213 if (IS_SPACE(string) || IS_BREAK(string)) 2214 { 2215 indent_hint[0] = '0' + (char)emitter->best_indent; 2216 indent_hint[1] = '\0'; 2217 if (!yaml_emitter_write_indicator(emitter, indent_hint, 0, 0, 0)) 2218 return 0; 2219 } 2220 2221 emitter->open_ended = 0; 2222 2223 string.pointer = string.end; 2224 if (string.start == string.pointer) 2225 { 2226 chomp_hint = "-"; 2227 } 2228 else 2229 { 2230 do { 2231 string.pointer --; 2232 } while ((*string.pointer & 0xC0) == 0x80); 2233 if (!IS_BREAK(string)) 2234 { 2235 chomp_hint = "-"; 2236 } 2237 else if (string.start == string.pointer) 2238 { 2239 chomp_hint = "+"; 2240 emitter->open_ended = 2; 2241 } 2242 else 2243 { 2244 do { 2245 string.pointer --; 2246 } while ((*string.pointer & 0xC0) == 0x80); 2247 if (IS_BREAK(string)) 2248 { 2249 chomp_hint = "+"; 2250 emitter->open_ended = 2; 2251 } 2252 } 2253 } 2254 2255 if (chomp_hint) 2256 { 2257 if (!yaml_emitter_write_indicator(emitter, chomp_hint, 0, 0, 0)) 2258 return 0; 2259 } 2260 2261 return 1; 2262 } 2263 2264 static int 2265 yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter, 2266 yaml_char_t *value, size_t length) 2267 { 2268 yaml_string_t string; 2269 int breaks = 1; 2270 2271 STRING_ASSIGN(string, value, length); 2272 2273 if (!yaml_emitter_write_indicator(emitter, "|", 1, 0, 0)) 2274 return 0; 2275 if (!yaml_emitter_write_block_scalar_hints(emitter, string)) 2276 return 0; 2277 if (!PUT_BREAK(emitter)) return 0; 2278 emitter->indention = 1; 2279 emitter->whitespace = 1; 2280 2281 while (string.pointer != string.end) 2282 { 2283 if (IS_BREAK(string)) 2284 { 2285 if (!WRITE_BREAK(emitter, string)) return 0; 2286 emitter->indention = 1; 2287 breaks = 1; 2288 } 2289 else 2290 { 2291 if (breaks) { 2292 if (!yaml_emitter_write_indent(emitter)) return 0; 2293 } 2294 if (!WRITE(emitter, string)) return 0; 2295 emitter->indention = 0; 2296 breaks = 0; 2297 } 2298 } 2299 2300 return 1; 2301 } 2302 2303 static int 2304 yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter, 2305 yaml_char_t *value, size_t length) 2306 { 2307 yaml_string_t string; 2308 int breaks = 1; 2309 int leading_spaces = 1; 2310 2311 STRING_ASSIGN(string, value, length); 2312 2313 if (!yaml_emitter_write_indicator(emitter, ">", 1, 0, 0)) 2314 return 0; 2315 if (!yaml_emitter_write_block_scalar_hints(emitter, string)) 2316 return 0; 2317 if (!PUT_BREAK(emitter)) return 0; 2318 emitter->indention = 1; 2319 emitter->whitespace = 1; 2320 2321 while (string.pointer != string.end) 2322 { 2323 if (IS_BREAK(string)) 2324 { 2325 if (!breaks && !leading_spaces && CHECK(string, '\n')) { 2326 int k = 0; 2327 while (IS_BREAK_AT(string, k)) { 2328 k += WIDTH_AT(string, k); 2329 } 2330 if (!IS_BLANKZ_AT(string, k)) { 2331 if (!PUT_BREAK(emitter)) return 0; 2332 } 2333 } 2334 if (!WRITE_BREAK(emitter, string)) return 0; 2335 emitter->indention = 1; 2336 breaks = 1; 2337 } 2338 else 2339 { 2340 if (breaks) { 2341 if (!yaml_emitter_write_indent(emitter)) return 0; 2342 leading_spaces = IS_BLANK(string); 2343 } 2344 if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1) 2345 && emitter->column > emitter->best_width) { 2346 if (!yaml_emitter_write_indent(emitter)) return 0; 2347 MOVE(string); 2348 } 2349 else { 2350 if (!WRITE(emitter, string)) return 0; 2351 } 2352 emitter->indention = 0; 2353 breaks = 0; 2354 } 2355 } 2356 2357 return 1; 2358 } 2359