source: libyaml/tags/0.1.4/src/emitter.c @ 375

Revision 375, 64.2 KB checked in by xi, 3 years ago (diff)

Tagged LibYAML 0.1.4

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