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

Revision 263, 63.0 KB checked in by xi, 6 years ago (diff)

Completed the first phase of API refactoring.

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