source: libyaml/trunk/src/emitter.c @ 215

Revision 215, 62.1 KB checked in by xi, 8 years ago (diff)

Scalar writers are completed.

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