source: libyaml/branches/stable/src/emitter.c @ 315

Revision 315, 63.7 KB checked in by xi, 5 years ago (diff)

Fixed emitting folded scalars with trailing breaks; Forced emitting of a document end indicator when there is a possibility of ambiguous parsing.

RevLine 
[212]1
2#include "yaml_private.h"
3
4/*
[214]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)                                                             \
[215]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)))
[214]63
64/*
[212]65 * API functions.
66 */
67
68YAML_DECLARE(int)
69yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
70
[213]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
[212]97yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
[213]98        yaml_event_t *event);
[212]99
[213]100static int
[212]101yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
[213]102        yaml_event_t *event, int first);
[212]103
[213]104static int
105yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
106        yaml_event_t *event);
[212]107
[213]108static int
109yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
110        yaml_event_t *event);
[212]111
[213]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
[214]168static int
169yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event);
170
[213]171/*
172 * Processors.
173 */
174
175static int
[214]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,
[213]198        yaml_char_t *anchor, int alias);
199
200static int
[214]201yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
[213]202        yaml_char_t *tag);
203
204static int
[214]205yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
206        yaml_char_t *value, size_t length);
[212]207
[214]208static int
209yaml_emitter_analyze_event(yaml_emitter_t *emitter,
210        yaml_event_t *event);
211
[213]212/*
213 * Writers.
214 */
[212]215
[213]216static int
217yaml_emitter_write_bom(yaml_emitter_t *emitter);
[212]218
[213]219static int
220yaml_emitter_write_indent(yaml_emitter_t *emitter);
221
222static int
223yaml_emitter_write_indicator(yaml_emitter_t *emitter,
224        char *indicator, int need_whitespace,
225        int is_whitespace, int is_indention);
226
[214]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,
[215]237        yaml_char_t *value, size_t length, int need_whitespace);
[214]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
[309]252yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
[215]253        yaml_string_t string);
254
255static int
[214]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
[212]263/*
[213]264 * Set an emitter error and return 0.
[212]265 */
266
[213]267static int
268yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem)
[212]269{
[213]270    emitter->error = YAML_EMITTER_ERROR;
271    emitter->problem = problem;
[212]272
[213]273    return 0;
[212]274}
275
276/*
[213]277 * Emit an event.
[212]278 */
279
280YAML_DECLARE(int)
[213]281yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
[212]282{
[213]283    if (!ENQUEUE(emitter, emitter->events, *event)) {
284        yaml_event_delete(event);
285        return 0;
286    }
[212]287
[213]288    while (!yaml_emitter_need_more_events(emitter)) {
[214]289        if (!yaml_emitter_analyze_event(emitter, emitter->events.head))
[213]290            return 0;
[214]291        if (!yaml_emitter_state_machine(emitter, emitter->events.head))
292            return 0;
[216]293        yaml_event_delete(&DEQUEUE(emitter, emitter->events));
[213]294    }
[212]295
[213]296    return 1;
[212]297}
298
299/*
[213]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
[212]306 */
307
[213]308static int
309yaml_emitter_need_more_events(yaml_emitter_t *emitter)
[212]310{
[213]311    int level = 0;
312    int accumulate = 0;
313    yaml_event_t *event;
[212]314
[213]315    if (QUEUE_EMPTY(emitter, emitter->events))
316        return 1;
[212]317
[213]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;
[212]330    }
331
[213]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;
[212]351        }
[213]352        if (!level)
353            return 0;
[212]354    }
355
[213]356    return 1;
357}
[212]358
[213]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        }
[212]378    }
379
[213]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;
[212]385    }
386
[213]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);
[212]395    return 0;
396}
397
398/*
[213]399 * Increase the indentation level.
[212]400 */
401
[213]402static int
403yaml_emitter_increase_indent(yaml_emitter_t *emitter,
404        int flow, int indentless)
[212]405{
[213]406    if (!PUSH(emitter, emitter->indents, emitter->indent))
407        return 0;
[212]408
[213]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    }
[212]415
[213]416    return 1;
[212]417}
418
419/*
[213]420 * State dispatcher.
[212]421 */
422
[213]423static int
424yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event)
[212]425{
[213]426    switch (emitter->state)
427    {
428        case YAML_EMIT_STREAM_START_STATE:
429            return yaml_emitter_emit_stream_start(emitter, event);
[212]430
[213]431        case YAML_EMIT_FIRST_DOCUMENT_START_STATE:
432            return yaml_emitter_emit_document_start(emitter, event, 1);
[212]433
[213]434        case YAML_EMIT_DOCUMENT_START_STATE:
435            return yaml_emitter_emit_document_start(emitter, event, 0);
[212]436
[213]437        case YAML_EMIT_DOCUMENT_CONTENT_STATE:
438            return yaml_emitter_emit_document_content(emitter, event);
[212]439
[213]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. */
[212]485    }
486
487    return 0;
488}
489
490/*
[213]491 * Expect STREAM-START.
[212]492 */
493
[213]494static int
495yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
496        yaml_event_t *event)
[212]497{
[213]498    if (event->type == YAML_STREAM_START_EVENT)
499    {
500        if (!emitter->encoding) {
501            emitter->encoding = event->data.stream_start.encoding;
502        }
[212]503
[213]504        if (!emitter->encoding) {
505            emitter->encoding = YAML_UTF8_ENCODING;
506        }
[212]507
[213]508        if (emitter->best_indent < 2 || emitter->best_indent > 9) {
509            emitter->best_indent  = 2;
[212]510        }
511
[213]512        if (emitter->best_width >= 0
513                && emitter->best_width <= emitter->best_indent*2) {
514            emitter->best_width = 80;
[212]515        }
[213]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;
[212]540    }
541
[213]542    return yaml_emitter_set_emitter_error(emitter,
543            "expected STREAM-START");
544}
545
[214]546/*
547 * Expect DOCUMENT-START or STREAM-END.
548 */
549
[213]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) {
[214]565            if (!yaml_emitter_analyze_version_directive(emitter,
566                        *event->data.document_start.version_directive))
567                return 0;
[213]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 ++) {
[214]573            if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive))
574                return 0;
[213]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
[315]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
[213]601        if (event->data.document_start.version_directive) {
602            implicit = 0;
[214]603            if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0))
[213]604                return 0;
[214]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;
[213]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 ++) {
[214]617                if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0))
[213]618                    return 0;
[214]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,
[215]623                            strlen((char *)tag_directive->prefix), 1))
[214]624                    return 0;
625                if (!yaml_emitter_write_indent(emitter))
626                    return 0;
[213]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;
[212]648    }
649
[213]650    else if (event->type == YAML_STREAM_END_EVENT)
651    {
[315]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
[213]660        if (!yaml_emitter_flush(emitter))
661            return 0;
[212]662
[213]663        emitter->state = YAML_EMIT_END_STATE;
664
[212]665        return 1;
666    }
667
[213]668    return yaml_emitter_set_emitter_error(emitter,
669            "expected DOCUMENT-START or STREAM-END");
670}
[212]671
[214]672/*
673 * Expect the root node.
674 */
675
[213]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);
[212]684}
685
[214]686/*
687 * Expect DOCUMENT-END.
688 */
689
[213]690static int
691yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
692        yaml_event_t *event)
[212]693{
[213]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;
[212]706
[213]707        emitter->state = YAML_EMIT_DOCUMENT_START_STATE;
[212]708
[216]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
[213]716        return 1;
[212]717    }
718
[213]719    return yaml_emitter_set_emitter_error(emitter,
720            "expected DOCUMENT-END");
721}
722
[214]723/*
[216]724 *
[214]725 * Expect a flow item node.
726 */
727
[213]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 ++;
[212]739    }
740
[213]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);
[212]754
755        return 1;
756    }
757
[216]758    if (!first) {
759        if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
760            return 0;
761    }
762
[213]763    if (emitter->canonical || emitter->column > emitter->best_width) {
764        if (!yaml_emitter_write_indent(emitter))
765            return 0;
766    }
[216]767    if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE))
[213]768        return 0;
[212]769
[213]770    return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
[212]771}
772
[214]773/*
774 * Expect a flow key node.
775 */
776
[213]777static int
778yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
779        yaml_event_t *event, int first)
[212]780{
[213]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    }
[212]789
[213]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);
[212]803
[213]804        return 1;
805    }
[212]806
[213]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    }
[212]834}
835
[214]836/*
837 * Expect a flow value node.
838 */
839
[213]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}
[212]860
[214]861/*
862 * Expect a block item node.
863 */
864
[213]865static int
866yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
867        yaml_event_t *event, int first)
[212]868{
[213]869    if (first)
870    {
871        if (!yaml_emitter_increase_indent(emitter, 0,
872                    (emitter->mapping_context && !emitter->indention)))
873            return 0;
874    }
[212]875
[213]876    if (event->type == YAML_SEQUENCE_END_EVENT)
877    {
878        emitter->indent = POP(emitter, emitter->indents);
879        emitter->state = POP(emitter, emitter->states);
[212]880
[213]881        return 1;
[212]882    }
883
[213]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
[214]895/*
896 * Expect a block key node.
897 */
898
[213]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;
[212]907    }
908
[213]909    if (event->type == YAML_MAPPING_END_EVENT)
910    {
911        emitter->indent = POP(emitter, emitter->indents);
912        emitter->state = POP(emitter, emitter->states);
[212]913
914        return 1;
915    }
916
[213]917    if (!yaml_emitter_write_indent(emitter))
918        return 0;
[212]919
[213]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    }
[212]938}
939
[214]940/*
941 * Expect a block value node.
942 */
943
[213]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;
[212]961
[213]962    return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
963}
964
[214]965/*
966 * Expect a node.
967 */
968
[213]969static int
970yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
971        int root, int sequence, int mapping, int simple_key)
[212]972{
[213]973    emitter->root_context = root;
974    emitter->sequence_context = sequence;
975    emitter->mapping_context = mapping;
976    emitter->simple_key_context = simple_key;
[212]977
[213]978    switch (event->type)
979    {
980        case YAML_ALIAS_EVENT:
981            return yaml_emitter_emit_alias(emitter, event);
[212]982
[213]983        case YAML_SCALAR_EVENT:
984            return yaml_emitter_emit_scalar(emitter, event);
[212]985
[213]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;
[212]998}
999
[214]1000/*
1001 * Expect ALIAS.
1002 */
1003
[213]1004static int
1005yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event)
1006{
[214]1007    if (!yaml_emitter_process_anchor(emitter))
[213]1008        return 0;
1009    emitter->state = POP(emitter, emitter->states);
[212]1010
[213]1011    return 1;
1012}
1013
[214]1014/*
1015 * Expect SCALAR.
1016 */
1017
[213]1018static int
1019yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event)
[212]1020{
[214]1021    if (!yaml_emitter_select_scalar_style(emitter, event))
[213]1022        return 0;
[214]1023    if (!yaml_emitter_process_anchor(emitter))
[213]1024        return 0;
[214]1025    if (!yaml_emitter_process_tag(emitter))
1026        return 0;
[213]1027    if (!yaml_emitter_increase_indent(emitter, 1, 0))
1028        return 0;
[214]1029    if (!yaml_emitter_process_scalar(emitter))
[213]1030        return 0;
1031    emitter->indent = POP(emitter, emitter->indents);
1032    emitter->state = POP(emitter, emitter->states);
1033
1034    return 1;
[212]1035}
1036
[214]1037/*
1038 * Expect SEQUENCE-START.
1039 */
1040
[213]1041static int
1042yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event)
1043{
[214]1044    if (!yaml_emitter_process_anchor(emitter))
[213]1045        return 0;
[214]1046    if (!yaml_emitter_process_tag(emitter))
[213]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
[214]1061/*
1062 * Expect MAPPING-START.
1063 */
1064
[213]1065static int
1066yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event)
1067{
[214]1068    if (!yaml_emitter_process_anchor(emitter))
[213]1069        return 0;
[214]1070    if (!yaml_emitter_process_tag(emitter))
[213]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
[214]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_sequence(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;
[238]1182    int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix);
[214]1183
[238]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
[214]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;
[238]1207        if (no_tag && !event->data.scalar.plain_implicit)
[214]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    {
[216]1219        if (!emitter->scalar_data.block_allowed
1220                || emitter->flow_level || emitter->simple_key_context)
[214]1221            style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1222    }
1223
[238]1224    if (no_tag && !event->data.scalar.quoted_implicit
1225            && style != YAML_PLAIN_SCALAR_STYLE)
[214]1226    {
[238]1227        emitter->tag_data.handle = (yaml_char_t *)"!";
1228        emitter->tag_data.handle_length = 1;
[214]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,
[215]1271                        emitter->tag_data.suffix_length, 0))
[214]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,
[215]1280                    emitter->tag_data.suffix_length, 0))
[214]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 = STRING(tag_directive.handle,
1353            strlen((char *)tag_directive.handle));
1354    yaml_string_t prefix = STRING(tag_directive.prefix,
1355            strlen((char *)tag_directive.prefix));
1356
1357    if (handle.start == handle.end) {
1358        return yaml_emitter_set_emitter_error(emitter,
1359                "tag handle must not be empty");
1360    }
1361
1362    if (handle.start[0] != '!') {
1363        return yaml_emitter_set_emitter_error(emitter,
1364                "tag handle must start with '!'");
1365    }
1366
1367    if (handle.end[-1] != '!') {
1368        return yaml_emitter_set_emitter_error(emitter,
1369                "tag handle must end with '!'");
1370    }
1371
1372    handle.pointer ++;
1373
[216]1374    while (handle.pointer < handle.end-1) {
[214]1375        if (!IS_ALPHA(handle)) {
1376            return yaml_emitter_set_emitter_error(emitter,
1377                    "tag handle must contain alphanumerical characters only");
1378        }
1379        MOVE(handle);
1380    }
1381
1382    if (prefix.start == prefix.end) {
1383        return yaml_emitter_set_emitter_error(emitter,
1384                "tag prefix must not be empty");
1385    }
1386
1387    return 1;
1388}
1389
1390/*
1391 * Check if an anchor is valid.
1392 */
1393
1394static int
1395yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
1396        yaml_char_t *anchor, int alias)
1397{
1398    yaml_string_t string = STRING(anchor, strlen((char *)anchor));
1399
1400    if (string.start == string.end) {
1401        return yaml_emitter_set_emitter_error(emitter, alias ?
1402                "alias value must not be empty" :
1403                "anchor value must not be empty");
1404    }
1405
1406    while (string.pointer != string.end) {
1407        if (!IS_ALPHA(string)) {
1408            return yaml_emitter_set_emitter_error(emitter, alias ?
1409                    "alias value must contain alphanumerical characters only" :
1410                    "anchor value must contain alphanumerical characters only");
1411        }
1412        MOVE(string);
1413    }
[216]1414
1415    emitter->anchor_data.anchor = string.start;
1416    emitter->anchor_data.anchor_length = string.end - string.start;
1417    emitter->anchor_data.alias = alias;
1418
1419    return 1;
[214]1420}
1421
1422/*
1423 * Check if a tag is valid.
1424 */
1425
1426static int
1427yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
1428        yaml_char_t *tag)
1429{
1430    yaml_string_t string = STRING(tag, strlen((char *)tag));
1431    yaml_tag_directive_t *tag_directive;
1432
1433    if (string.start == string.end) {
1434        return yaml_emitter_set_emitter_error(emitter,
1435                "tag value must not be empty");
1436    }
1437
1438    for (tag_directive = emitter->tag_directives.start;
[216]1439            tag_directive != emitter->tag_directives.top; tag_directive ++) {
[214]1440        size_t prefix_length = strlen((char *)tag_directive->prefix);
[239]1441        if (prefix_length < (size_t)(string.end - string.start)
[214]1442                && strncmp((char *)tag_directive->prefix, (char *)string.start,
1443                    prefix_length) == 0)
1444        {
1445            emitter->tag_data.handle = tag_directive->handle;
1446            emitter->tag_data.handle_length =
1447                strlen((char *)tag_directive->handle);
1448            emitter->tag_data.suffix = string.start + prefix_length;
1449            emitter->tag_data.suffix_length =
1450                (string.end - string.start) - prefix_length;
1451            return 1;
1452        }
1453    }
1454
1455    emitter->tag_data.suffix = string.start;
1456    emitter->tag_data.suffix_length = string.end - string.start;
1457
1458    return 1;
1459}
1460
1461/*
1462 * Check if a scalar is valid.
1463 */
1464
1465static int
1466yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
1467        yaml_char_t *value, size_t length)
1468{
1469    yaml_string_t string = STRING(value, length);
1470
1471    int block_indicators = 0;
1472    int flow_indicators = 0;
1473    int line_breaks = 0;
1474    int special_characters = 0;
1475
[309]1476    int leading_space = 0;
1477    int leading_break = 0;
1478    int trailing_space = 0;
1479    int trailing_break = 0;
1480    int break_space = 0;
1481    int space_break = 0;
[214]1482
[309]1483    int preceeded_by_whitespace = 0;
1484    int followed_by_whitespace = 0;
1485    int previous_space = 0;
1486    int previous_break = 0;
[214]1487
1488    emitter->scalar_data.value = value;
1489    emitter->scalar_data.length = length;
1490
1491    if (string.start == string.end)
1492    {
1493        emitter->scalar_data.multiline = 0;
1494        emitter->scalar_data.flow_plain_allowed = 0;
1495        emitter->scalar_data.block_plain_allowed = 1;
1496        emitter->scalar_data.single_quoted_allowed = 1;
1497        emitter->scalar_data.block_allowed = 0;
1498
1499        return 1;
1500    }
1501
1502    if ((CHECK_AT(string, '-', 0)
1503                && CHECK_AT(string, '-', 1)
1504                && CHECK_AT(string, '-', 2))
1505            || (CHECK_AT(string, '.', 0)
1506                && CHECK_AT(string, '.', 1)
1507                && CHECK_AT(string, '.', 2))) {
1508        block_indicators = 1;
1509        flow_indicators = 1;
1510    }
1511
[309]1512    preceeded_by_whitespace = 1;
1513    followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
[214]1514
1515    while (string.pointer != string.end)
1516    {
1517        if (string.start == string.pointer)
1518        {
1519            if (CHECK(string, '#') || CHECK(string, ',')
1520                    || CHECK(string, '[') || CHECK(string, ']')
1521                    || CHECK(string, '{') || CHECK(string, '}')
1522                    || CHECK(string, '&') || CHECK(string, '*')
1523                    || CHECK(string, '!') || CHECK(string, '|')
1524                    || CHECK(string, '>') || CHECK(string, '\'')
1525                    || CHECK(string, '"') || CHECK(string, '%')
1526                    || CHECK(string, '@') || CHECK(string, '`')) {
1527                flow_indicators = 1;
1528                block_indicators = 1;
1529            }
1530
1531            if (CHECK(string, '?') || CHECK(string, ':')) {
1532                flow_indicators = 1;
[309]1533                if (followed_by_whitespace) {
[214]1534                    block_indicators = 1;
1535                }
1536            }
1537
[309]1538            if (CHECK(string, '-') && followed_by_whitespace) {
[214]1539                flow_indicators = 1;
1540                block_indicators = 1;
1541            }
1542        }
1543        else
1544        {
1545            if (CHECK(string, ',') || CHECK(string, '?')
1546                    || CHECK(string, '[') || CHECK(string, ']')
1547                    || CHECK(string, '{') || CHECK(string, '}')) {
1548                flow_indicators = 1;
1549            }
1550
1551            if (CHECK(string, ':')) {
1552                flow_indicators = 1;
[309]1553                if (followed_by_whitespace) {
[214]1554                    block_indicators = 1;
1555                }
1556            }
1557
[309]1558            if (CHECK(string, '#') && preceeded_by_whitespace) {
[214]1559                flow_indicators = 1;
1560                block_indicators = 1;
1561            }
1562        }
1563
1564        if (!IS_PRINTABLE(string)
1565                || (!IS_ASCII(string) && !emitter->unicode)) {
1566            special_characters = 1;
1567        }
1568
1569        if (IS_BREAK(string)) {
1570            line_breaks = 1;
1571        }
1572
1573        if (IS_SPACE(string))
1574        {
1575            if (string.start == string.pointer) {
[309]1576                leading_space = 1;
[214]1577            }
[309]1578            if (string.pointer+WIDTH(string) == string.end) {
1579                trailing_space = 1;
1580            }
1581            if (previous_break) {
1582                break_space = 1;
1583            }
1584            previous_space = 1;
1585            previous_break = 0;
[214]1586        }
1587        else if (IS_BREAK(string))
1588        {
1589            if (string.start == string.pointer) {
[309]1590                leading_break = 1;
[214]1591            }
[309]1592            if (string.pointer+WIDTH(string) == string.end) {
1593                trailing_break = 1;
[214]1594            }
[309]1595            if (previous_space) {
1596                space_break = 1;
[214]1597            }
[309]1598            previous_space = 0;
1599            previous_break = 1;
[214]1600        }
[309]1601        else
[216]1602        {
[309]1603            previous_space = 0;
1604            previous_break = 0;
[216]1605        }
1606
[309]1607        preceeded_by_whitespace = IS_BLANKZ(string);
[214]1608        MOVE(string);
1609        if (string.pointer != string.end) {
[309]1610            followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
[214]1611        }
1612    }
1613
1614    emitter->scalar_data.multiline = line_breaks;
1615
1616    emitter->scalar_data.flow_plain_allowed = 1;
1617    emitter->scalar_data.block_plain_allowed = 1;
1618    emitter->scalar_data.single_quoted_allowed = 1;
1619    emitter->scalar_data.block_allowed = 1;
1620
[309]1621    if (leading_space || leading_break || trailing_space || trailing_break) {
[214]1622        emitter->scalar_data.flow_plain_allowed = 0;
1623        emitter->scalar_data.block_plain_allowed = 0;
1624    }
1625
[309]1626    if (trailing_space) {
1627        emitter->scalar_data.block_allowed = 0;
[214]1628    }
1629
[309]1630    if (break_space) {
[214]1631        emitter->scalar_data.flow_plain_allowed = 0;
1632        emitter->scalar_data.block_plain_allowed = 0;
1633        emitter->scalar_data.single_quoted_allowed = 0;
1634    }
1635
[309]1636    if (space_break || special_characters) {
[214]1637        emitter->scalar_data.flow_plain_allowed = 0;
1638        emitter->scalar_data.block_plain_allowed = 0;
1639        emitter->scalar_data.single_quoted_allowed = 0;
1640        emitter->scalar_data.block_allowed = 0;
1641    }
1642
1643    if (line_breaks) {
1644        emitter->scalar_data.flow_plain_allowed = 0;
1645        emitter->scalar_data.block_plain_allowed = 0;
1646    }
1647
1648    if (flow_indicators) {
1649        emitter->scalar_data.flow_plain_allowed = 0;
1650    }
1651
1652    if (block_indicators) {
1653        emitter->scalar_data.block_plain_allowed = 0;
1654    }
1655
1656    return 1;
1657}
1658
1659/*
1660 * Check if the event data is valid.
1661 */
1662
1663static int
1664yaml_emitter_analyze_event(yaml_emitter_t *emitter,
1665        yaml_event_t *event)
1666{
1667    emitter->anchor_data.anchor = NULL;
1668    emitter->anchor_data.anchor_length = 0;
1669    emitter->tag_data.handle = NULL;
1670    emitter->tag_data.handle_length = 0;
1671    emitter->tag_data.suffix = NULL;
1672    emitter->tag_data.suffix_length = 0;
1673    emitter->scalar_data.value = NULL;
1674    emitter->scalar_data.length = 0;
1675
1676    switch (event->type)
1677    {
1678        case YAML_ALIAS_EVENT:
1679            if (!yaml_emitter_analyze_anchor(emitter,
1680                        event->data.alias.anchor, 1))
1681                return 0;
1682            return 1;
1683
1684        case YAML_SCALAR_EVENT:
1685            if (event->data.scalar.anchor) {
1686                if (!yaml_emitter_analyze_anchor(emitter,
1687                            event->data.scalar.anchor, 0))
1688                    return 0;
1689            }
1690            if (event->data.scalar.tag && (emitter->canonical ||
1691                        (!event->data.scalar.plain_implicit
1692                         && !event->data.scalar.quoted_implicit))) {
1693                if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag))
1694                    return 0;
1695            }
1696            if (!yaml_emitter_analyze_scalar(emitter,
1697                        event->data.scalar.value, event->data.scalar.length))
1698                return 0;
1699            return 1;
1700
1701        case YAML_SEQUENCE_START_EVENT:
1702            if (event->data.sequence_start.anchor) {
1703                if (!yaml_emitter_analyze_anchor(emitter,
1704                            event->data.sequence_start.anchor, 0))
1705                    return 0;
1706            }
1707            if (event->data.sequence_start.tag && (emitter->canonical ||
1708                        !event->data.sequence_start.implicit)) {
1709                if (!yaml_emitter_analyze_tag(emitter,
1710                            event->data.sequence_start.tag))
1711                    return 0;
1712            }
1713            return 1;
1714
1715        case YAML_MAPPING_START_EVENT:
1716            if (event->data.mapping_start.anchor) {
1717                if (!yaml_emitter_analyze_anchor(emitter,
1718                            event->data.mapping_start.anchor, 0))
1719                    return 0;
1720            }
1721            if (event->data.mapping_start.tag && (emitter->canonical ||
1722                        !event->data.mapping_start.implicit)) {
1723                if (!yaml_emitter_analyze_tag(emitter,
1724                            event->data.mapping_start.tag))
1725                    return 0;
1726            }
1727            return 1;
1728
1729        default:
1730            return 1;
1731    }
1732}
1733
1734/*
1735 * Write the BOM character.
1736 */
1737
1738static int
1739yaml_emitter_write_bom(yaml_emitter_t *emitter)
1740{
1741    if (!FLUSH(emitter)) return 0;
1742
1743    *(emitter->buffer.pointer++) = (yaml_char_t) '\xEF';
1744    *(emitter->buffer.pointer++) = (yaml_char_t) '\xBB';
1745    *(emitter->buffer.pointer++) = (yaml_char_t) '\xBF';
1746
1747    return 1;
1748}
1749
1750static int
1751yaml_emitter_write_indent(yaml_emitter_t *emitter)
1752{
1753    int indent = (emitter->indent >= 0) ? emitter->indent : 0;
1754
1755    if (!emitter->indention || emitter->column > indent
1756            || (emitter->column == indent && !emitter->whitespace)) {
1757        if (!PUT_BREAK(emitter)) return 0;
1758    }
1759
1760    while (emitter->column < indent) {
1761        if (!PUT(emitter, ' ')) return 0;
1762    }
1763
1764    emitter->whitespace = 1;
1765    emitter->indention = 1;
1766
1767    return 1;
1768}
1769
1770static int
1771yaml_emitter_write_indicator(yaml_emitter_t *emitter,
1772        char *indicator, int need_whitespace,
1773        int is_whitespace, int is_indention)
1774{
1775    yaml_string_t string = STRING((yaml_char_t *)indicator, strlen(indicator));
1776
1777    if (need_whitespace && !emitter->whitespace) {
1778        if (!PUT(emitter, ' ')) return 0;
1779    }
1780
1781    while (string.pointer != string.end) {
1782        if (!WRITE(emitter, string)) return 0;
1783    }
1784
1785    emitter->whitespace = is_whitespace;
1786    emitter->indention = (emitter->indention && is_indention);
[315]1787    emitter->open_ended = 0;
[214]1788
1789    return 1;
1790}
1791
1792static int
1793yaml_emitter_write_anchor(yaml_emitter_t *emitter,
1794        yaml_char_t *value, size_t length)
1795{
1796    yaml_string_t string = STRING(value, length);
1797
1798    while (string.pointer != string.end) {
1799        if (!WRITE(emitter, string)) return 0;
1800    }
1801
1802    emitter->whitespace = 0;
1803    emitter->indention = 0;
1804
1805    return 1;
1806}
1807
1808static int
1809yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
1810        yaml_char_t *value, size_t length)
1811{
1812    yaml_string_t string = STRING(value, length);
1813
[215]1814    if (!emitter->whitespace) {
1815        if (!PUT(emitter, ' ')) return 0;
1816    }
1817
[214]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_content(yaml_emitter_t *emitter,
[215]1830        yaml_char_t *value, size_t length,
1831        int need_whitespace)
[214]1832{
[215]1833    yaml_string_t string = STRING(value, length);
1834
1835    if (need_whitespace && !emitter->whitespace) {
1836        if (!PUT(emitter, ' ')) return 0;
1837    }
1838
1839    while (string.pointer != string.end) {
1840        if (IS_ALPHA(string)
1841                || CHECK(string, ';') || CHECK(string, '/')
1842                || CHECK(string, '?') || CHECK(string, ':')
1843                || CHECK(string, '@') || CHECK(string, '&')
1844                || CHECK(string, '=') || CHECK(string, '+')
1845                || CHECK(string, '$') || CHECK(string, ',')
1846                || CHECK(string, '_') || CHECK(string, '.')
1847                || CHECK(string, '~') || CHECK(string, '*')
1848                || CHECK(string, '\'') || CHECK(string, '(')
1849                || CHECK(string, ')') || CHECK(string, '[')
1850                || CHECK(string, ']')) {
1851            if (!WRITE(emitter, string)) return 0;
1852        }
1853        else {
1854            int width = WIDTH(string);
1855            unsigned int value;
1856            while (width --) {
1857                value = *(string.pointer++);
1858                if (!PUT(emitter, '%')) return 0;
[216]1859                if (!PUT(emitter, (value >> 4)
1860                            + ((value >> 4) < 10 ? '0' : 'A' - 10)))
[215]1861                    return 0;
1862                if (!PUT(emitter, (value & 0x0F)
1863                            + ((value & 0x0F) < 10 ? '0' : 'A' - 10)))
1864                    return 0;
1865            }
1866        }
1867    }
1868
1869    emitter->whitespace = 0;
1870    emitter->indention = 0;
1871
1872    return 1;
[214]1873}
1874
1875static int
1876yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
1877        yaml_char_t *value, size_t length, int allow_breaks)
1878{
[215]1879    yaml_string_t string = STRING(value, length);
1880    int spaces = 0;
1881    int breaks = 0;
1882
1883    if (!emitter->whitespace) {
1884        if (!PUT(emitter, ' ')) return 0;
1885    }
1886
1887    while (string.pointer != string.end)
1888    {
1889        if (IS_SPACE(string))
1890        {
1891            if (allow_breaks && !spaces
1892                    && emitter->column > emitter->best_width
1893                    && !IS_SPACE_AT(string, 1)) {
1894                if (!yaml_emitter_write_indent(emitter)) return 0;
1895                MOVE(string);
1896            }
1897            else {
1898                if (!WRITE(emitter, string)) return 0;
1899            }
1900            spaces = 1;
1901        }
1902        else if (IS_BREAK(string))
1903        {
1904            if (!breaks && CHECK(string, '\n')) {
1905                if (!PUT_BREAK(emitter)) return 0;
1906            }
1907            if (!WRITE_BREAK(emitter, string)) return 0;
1908            emitter->indention = 1;
1909            breaks = 1;
1910        }
1911        else
1912        {
1913            if (breaks) {
1914                if (!yaml_emitter_write_indent(emitter)) return 0;
1915            }
1916            if (!WRITE(emitter, string)) return 0;
1917            emitter->indention = 0;
1918            spaces = 0;
1919            breaks = 0;
1920        }
1921    }
1922
1923    emitter->whitespace = 0;
1924    emitter->indention = 0;
[315]1925    if (emitter->root_context)
1926    {
1927        emitter->open_ended = 1;
1928    }
[215]1929
1930    return 1;
[214]1931}
1932
1933static int
1934yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
1935        yaml_char_t *value, size_t length, int allow_breaks)
1936{
[215]1937    yaml_string_t string = STRING(value, length);
1938    int spaces = 0;
1939    int breaks = 0;
1940
1941    if (!yaml_emitter_write_indicator(emitter, "'", 1, 0, 0))
1942        return 0;
1943
1944    while (string.pointer != string.end)
1945    {
1946        if (IS_SPACE(string))
1947        {
1948            if (allow_breaks && !spaces
1949                    && emitter->column > emitter->best_width
1950                    && string.pointer != string.start
1951                    && string.pointer != string.end - 1
1952                    && !IS_SPACE_AT(string, 1)) {
1953                if (!yaml_emitter_write_indent(emitter)) return 0;
1954                MOVE(string);
1955            }
1956            else {
1957                if (!WRITE(emitter, string)) return 0;
1958            }
1959            spaces = 1;
1960        }
1961        else if (IS_BREAK(string))
1962        {
1963            if (!breaks && CHECK(string, '\n')) {
1964                if (!PUT_BREAK(emitter)) return 0;
1965            }
1966            if (!WRITE_BREAK(emitter, string)) return 0;
1967            emitter->indention = 1;
1968            breaks = 1;
1969        }
1970        else
1971        {
1972            if (breaks) {
1973                if (!yaml_emitter_write_indent(emitter)) return 0;
1974            }
1975            if (CHECK(string, '\'')) {
1976                if (!PUT(emitter, '\'')) return 0;
1977            }
1978            if (!WRITE(emitter, string)) return 0;
1979            emitter->indention = 0;
1980            spaces = 0;
1981            breaks = 0;
1982        }
1983    }
1984
1985    if (!yaml_emitter_write_indicator(emitter, "'", 0, 0, 0))
1986        return 0;
1987
1988    emitter->whitespace = 0;
1989    emitter->indention = 0;
1990
1991    return 1;
[214]1992}
1993
1994static int
1995yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
1996        yaml_char_t *value, size_t length, int allow_breaks)
1997{
[215]1998    yaml_string_t string = STRING(value, length);
1999    int spaces = 0;
2000
2001    if (!yaml_emitter_write_indicator(emitter, "\"", 1, 0, 0))
2002        return 0;
2003
2004    while (string.pointer != string.end)
2005    {
2006        if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string))
2007                || IS_BOM(string) || IS_BREAK(string)
2008                || CHECK(string, '"') || CHECK(string, '\\'))
2009        {
2010            unsigned char octet;
2011            unsigned int width;
2012            unsigned int value;
[241]2013            int k;
[215]2014
2015            octet = string.pointer[0];
2016            width = (octet & 0x80) == 0x00 ? 1 :
2017                    (octet & 0xE0) == 0xC0 ? 2 :
2018                    (octet & 0xF0) == 0xE0 ? 3 :
2019                    (octet & 0xF8) == 0xF0 ? 4 : 0;
2020            value = (octet & 0x80) == 0x00 ? octet & 0x7F :
2021                    (octet & 0xE0) == 0xC0 ? octet & 0x1F :
2022                    (octet & 0xF0) == 0xE0 ? octet & 0x0F :
2023                    (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
[241]2024            for (k = 1; k < (int)width; k ++) {
[215]2025                octet = string.pointer[k];
2026                value = (value << 6) + (octet & 0x3F);
2027            }
2028            string.pointer += width;
2029
2030            if (!PUT(emitter, '\\')) return 0;
2031
2032            switch (value)
2033            {
2034                case 0x00:
2035                    if (!PUT(emitter, '0')) return 0;
2036                    break;
2037
2038                case 0x07:
2039                    if (!PUT(emitter, 'a')) return 0;
2040                    break;
2041
2042                case 0x08:
2043                    if (!PUT(emitter, 'b')) return 0;
2044                    break;
2045
2046                case 0x09:
2047                    if (!PUT(emitter, 't')) return 0;
2048                    break;
2049
2050                case 0x0A:
2051                    if (!PUT(emitter, 'n')) return 0;
2052                    break;
2053
2054                case 0x0B:
2055                    if (!PUT(emitter, 'v')) return 0;
2056                    break;
2057
2058                case 0x0C:
2059                    if (!PUT(emitter, 'f')) return 0;
2060                    break;
2061
2062                case 0x0D:
2063                    if (!PUT(emitter, 'r')) return 0;
2064                    break;
2065
2066                case 0x1B:
2067                    if (!PUT(emitter, 'e')) return 0;
2068                    break;
2069
2070                case 0x22:
2071                    if (!PUT(emitter, '\"')) return 0;
2072                    break;
2073
2074                case 0x5C:
2075                    if (!PUT(emitter, '\\')) return 0;
2076                    break;
2077
2078                case 0x85:
2079                    if (!PUT(emitter, 'N')) return 0;
2080                    break;
2081
2082                case 0xA0:
2083                    if (!PUT(emitter, '_')) return 0;
2084                    break;
2085
2086                case 0x2028:
2087                    if (!PUT(emitter, 'L')) return 0;
2088                    break;
2089
2090                case 0x2029:
2091                    if (!PUT(emitter, 'P')) return 0;
2092                    break;
2093
2094                default:
2095                    if (value <= 0xFF) {
2096                        if (!PUT(emitter, 'x')) return 0;
2097                        width = 2;
2098                    }
2099                    else if (value <= 0xFFFF) {
2100                        if (!PUT(emitter, 'u')) return 0;
2101                        width = 4;
2102                    }
2103                    else {
2104                        if (!PUT(emitter, 'U')) return 0;
2105                        width = 8;
2106                    }
[216]2107                    for (k = (width-1)*4; k >= 0; k -= 4) {
2108                        int digit = (value >> k) & 0x0F;
2109                        if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10)))
2110                            return 0;
[215]2111                    }
2112            }
2113            spaces = 0;
2114        }
2115        else if (IS_SPACE(string))
2116        {
2117            if (allow_breaks && !spaces
2118                    && emitter->column > emitter->best_width
2119                    && string.pointer != string.start
2120                    && string.pointer != string.end - 1) {
2121                if (!yaml_emitter_write_indent(emitter)) return 0;
2122                if (IS_SPACE_AT(string, 1)) {
2123                    if (!PUT(emitter, '\\')) return 0;
2124                }
2125                MOVE(string);
2126            }
2127            else {
2128                if (!WRITE(emitter, string)) return 0;
2129            }
2130            spaces = 1;
2131        }
2132        else
2133        {
2134            if (!WRITE(emitter, string)) return 0;
2135            spaces = 0;
2136        }
2137    }
2138
2139    if (!yaml_emitter_write_indicator(emitter, "\"", 0, 0, 0))
2140        return 0;
2141
2142    emitter->whitespace = 0;
2143    emitter->indention = 0;
2144
2145    return 1;
[214]2146}
2147
2148static int
[309]2149yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
[215]2150        yaml_string_t string)
2151{
[309]2152    char indent_hint[2];
2153    char *chomp_hint = NULL;
2154
2155    if (IS_SPACE(string) || IS_BREAK(string))
2156    {
2157        indent_hint[0] = '0' + (char)emitter->best_indent;
2158        indent_hint[1] = '\0';
2159        if (!yaml_emitter_write_indicator(emitter, indent_hint, 0, 0, 0))
2160            return 0;
2161    }
2162
[315]2163    emitter->open_ended = 0;
2164
[215]2165    string.pointer = string.end;
2166    if (string.start == string.pointer)
[309]2167    {
2168        chomp_hint = "-";
2169    }
2170    else
2171    {
2172        do {
2173            string.pointer --;
2174        } while ((*string.pointer & 0xC0) == 0x80);
2175        if (!IS_BREAK(string))
2176        {
2177            chomp_hint = "-";
2178        }
2179        else if (string.start == string.pointer)
2180        {
2181            chomp_hint = "+";
[315]2182            emitter->open_ended = 1;
[309]2183        }
2184        else
2185        {
2186            do {
2187                string.pointer --;
2188            } while ((*string.pointer & 0xC0) == 0x80);
2189            if (IS_BREAK(string))
2190            {
2191                chomp_hint = "+";
[315]2192                emitter->open_ended = 1;
[309]2193            }
2194        }
2195    }
2196
2197    if (chomp_hint)
2198    {
2199        if (!yaml_emitter_write_indicator(emitter, chomp_hint, 0, 0, 0))
2200            return 0;
2201    }
2202
2203    return 1;
[215]2204}
2205
2206static int
[214]2207yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
2208        yaml_char_t *value, size_t length)
2209{
[215]2210    yaml_string_t string = STRING(value, length);
[309]2211    int breaks = 1;
[215]2212
[309]2213    if (!yaml_emitter_write_indicator(emitter, "|", 1, 0, 0))
[215]2214        return 0;
[309]2215    if (!yaml_emitter_write_block_scalar_hints(emitter, string))
[215]2216        return 0;
[309]2217    if (!PUT_BREAK(emitter)) return 0;
2218    emitter->indention = 1;
2219    emitter->whitespace = 1;
[215]2220
2221    while (string.pointer != string.end)
2222    {
2223        if (IS_BREAK(string))
2224        {
2225            if (!WRITE_BREAK(emitter, string)) return 0;
2226            emitter->indention = 1;
2227            breaks = 1;
2228        }
2229        else
2230        {
2231            if (breaks) {
2232                if (!yaml_emitter_write_indent(emitter)) return 0;
2233            }
2234            if (!WRITE(emitter, string)) return 0;
2235            emitter->indention = 0;
2236            breaks = 0;
2237        }
2238    }
2239
2240    return 1;
[214]2241}
2242
2243static int
2244yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
2245        yaml_char_t *value, size_t length)
2246{
[215]2247    yaml_string_t string = STRING(value, length);
[216]2248    int breaks = 1;
[309]2249    int leading_spaces = 1;
[215]2250
[309]2251    if (!yaml_emitter_write_indicator(emitter, ">", 1, 0, 0))
[215]2252        return 0;
[309]2253    if (!yaml_emitter_write_block_scalar_hints(emitter, string))
[215]2254        return 0;
[309]2255    if (!PUT_BREAK(emitter)) return 0;
2256    emitter->indention = 1;
2257    emitter->whitespace = 1;
[215]2258
2259    while (string.pointer != string.end)
2260    {
2261        if (IS_BREAK(string))
2262        {
2263            if (!breaks && !leading_spaces && CHECK(string, '\n')) {
2264                int k = 0;
2265                while (IS_BREAK_AT(string, k)) {
2266                    k += WIDTH_AT(string, k);
2267                }
[315]2268                if (!IS_BLANKZ_AT(string, k)) {
[215]2269                    if (!PUT_BREAK(emitter)) return 0;
2270                }
2271            }
2272            if (!WRITE_BREAK(emitter, string)) return 0;
2273            emitter->indention = 1;
2274            breaks = 1;
2275        }
2276        else
2277        {
2278            if (breaks) {
2279                if (!yaml_emitter_write_indent(emitter)) return 0;
2280                leading_spaces = IS_BLANK(string);
2281            }
2282            if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1)
2283                    && emitter->column > emitter->best_width) {
2284                if (!yaml_emitter_write_indent(emitter)) return 0;
2285                MOVE(string);
2286            }
2287            else {
2288                if (!WRITE(emitter, string)) return 0;
2289            }
2290            emitter->indention = 0;
2291            breaks = 0;
2292        }
2293    }
2294
2295    return 1;
[214]2296}
2297
Note: See TracBrowser for help on using the repository browser.