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

Revision 267, 65.4 KB checked in by xi, 7 years ago (diff)

Minor API updates.

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