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