Ruby 2.0.0p353(2013-11-22revision43784)

- Main Page
- Modules
- Data Structures
- Files

- File List
- Globals

emitter.c
Go to the documentation of this file.
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
68 YAML_DECLARE(int)
69 yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
70
71 /*
72 * Utility functions.
73 */
74
75 static int
76 yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem);
77
78 static int
79 yaml_emitter_need_more_events(yaml_emitter_t *emitter);
80
81 static int
82 yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
83 yaml_tag_directive_t value, int allow_duplicates);
84
85 static int
86 yaml_emitter_increase_indent(yaml_emitter_t *emitter,
87 int flow, int indentless);
88
89 /*
90 * State functions.
91 */
92
93 static int
94 yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event);
95
96 static int
97 yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
98 yaml_event_t *event);
99
100 static int
101 yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
102 yaml_event_t *event, int first);
103
104 static int
105 yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
106 yaml_event_t *event);
107
108 static int
109 yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
110 yaml_event_t *event);
111
112 static int
113 yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
114 yaml_event_t *event, int first);
115
116 static int
117 yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
118 yaml_event_t *event, int first);
119
120 static int
121 yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
122 yaml_event_t *event, int simple);
123
124 static int
125 yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
126 yaml_event_t *event, int first);
127
128 static int
129 yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
130 yaml_event_t *event, int first);
131
132 static int
133 yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
134 yaml_event_t *event, int simple);
135
136 static int
137 yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
138 int root, int sequence, int mapping, int simple_key);
139
140 static int
141 yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event);
142
143 static int
144 yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event);
145
146 static int
147 yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event);
148
149 static int
150 yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event);
151
152 /*
153 * Checkers.
154 */
155
156 static int
157 yaml_emitter_check_empty_document(yaml_emitter_t *emitter);
158
159 static int
160 yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter);
161
162 static int
163 yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter);
164
165 static int
166 yaml_emitter_check_simple_key(yaml_emitter_t *emitter);
167
168 static int
169 yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event);
170
171 /*
172 * Processors.
173 */
174
175 static int
176 yaml_emitter_process_anchor(yaml_emitter_t *emitter);
177
178 static int
179 yaml_emitter_process_tag(yaml_emitter_t *emitter);
180
181 static int
182 yaml_emitter_process_scalar(yaml_emitter_t *emitter);
183
184 /*
185 * Analyzers.
186 */
187
188 static int
189 yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
190 yaml_version_directive_t version_directive);
191
192 static int
193 yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
194 yaml_tag_directive_t tag_directive);
195
196 static int
197 yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
198 yaml_char_t *anchor, int alias);
199
200 static int
201 yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
202 yaml_char_t *tag);
203
204 static int
205 yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
206 yaml_char_t *value, size_t length);
207
208 static int
209 yaml_emitter_analyze_event(yaml_emitter_t *emitter,
210 yaml_event_t *event);
211
212 /*
213 * Writers.
214 */
215
216 static int
217 yaml_emitter_write_bom(yaml_emitter_t *emitter);
218
219 static int
220 yaml_emitter_write_indent(yaml_emitter_t *emitter);
221
222 static int
223 yaml_emitter_write_indicator(yaml_emitter_t *emitter,
224 const char *indicator, int need_whitespace,
225 int is_whitespace, int is_indention);
226
227 static int
228 yaml_emitter_write_anchor(yaml_emitter_t *emitter,
229 yaml_char_t *value, size_t length);
230
231 static int
232 yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
233 yaml_char_t *value, size_t length);
234
235 static int
236 yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
237 yaml_char_t *value, size_t length, int need_whitespace);
238
239 static int
240 yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
241 yaml_char_t *value, size_t length, int allow_breaks);
242
243 static int
244 yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
245 yaml_char_t *value, size_t length, int allow_breaks);
246
247 static int
248 yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
249 yaml_char_t *value, size_t length, int allow_breaks);
250
251 static int
252 yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
253 yaml_string_t string);
254
255 static int
256 yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
257 yaml_char_t *value, size_t length);
258
259 static int
260 yaml_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
267 static int
268 yaml_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
280 YAML_DECLARE(int)
281 yaml_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
308 static int
309 yaml_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
363 static int
364 yaml_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
392 error:
393 yaml_free(copy.handle);
394 yaml_free(copy.prefix);
395 return 0;
396 }
397
398 /*
399 * Increase the indentation level.
400 */
401
402 static int
403 yaml_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
423 static int
424 yaml_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
494 static int
495 yaml_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
550 static int
551 yaml_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
676 static int
677 yaml_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
690 static int
691 yaml_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
728 static int
729 yaml_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
777 static int
778 yaml_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
840 static int
841 yaml_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
865 static int
866 yaml_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
899 static int
900 yaml_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
944 static int
945 yaml_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
969 static int
970 yaml_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
1004 static int
1005 yaml_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
1018 static int
1019 yaml_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
1041 static int
1042 yaml_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
1065 static int
1066 yaml_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
1089 static int
1090 yaml_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
1099 static int
1100 yaml_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
1113 static int
1114 yaml_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
1127 static int
1128 yaml_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
1178 static int
1179 yaml_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
1240 static int
1241 yaml_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
1258 static int
1259 yaml_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
1293 static int
1294 yaml_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
1332 static int
1333 yaml_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
1348 static int
1349 yaml_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
1399 static int
1400 yaml_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
1435 static int
1436 yaml_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
1478 static int
1479 yaml_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
1678 static int
1679 yaml_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
1753 static int
1754 yaml_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
1765 static int
1766 yaml_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
1785 static int
1786 yaml_emitter_write_indicator(yaml_emitter_t *emitter,
1787 const 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
1811 static int
1812 yaml_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
1828 static int
1829 yaml_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
1849 static int
1850 yaml_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
1897 static int
1898 yaml_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
1957 static int
1958 yaml_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
2020 static int
2021 yaml_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
2176 static int
2177 yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
2178 yaml_string_t string)
2179 {
2180 char indent_hint[2];
2181 const 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
2234 static int
2235 yaml_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
2273 static int
2274 yaml_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
yaml_emitter_set_emitter_error
static int yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem)
Definition: emitter.c:268
YAML_DOUBLE_QUOTED_SCALAR_STYLE
The double-quoted scalar style.
Definition: yaml.h:174
yaml_strdup
yaml_strdup(const yaml_char_t *str)
Definition: api.c:61
YAML_LN_BREAK
Use LN for line breaks (Unix style).
Definition: yaml.h:116
yaml_emitter_s::buffer
unsigned char * buffer
The buffer pointer.
Definition: yaml.h:1557
yaml_emitter_s::anchor_length
size_t anchor_length
The anchor length.
Definition: yaml.h:1691
yaml_emitter_write_tag_handle
static int yaml_emitter_write_tag_handle(yaml_emitter_t *emitter, yaml_char_t *value, size_t length)
Definition: emitter.c:1829
YAML_EMIT_STREAM_START_STATE
Expect STREAM-START.
Definition: yaml.h:1481
yaml_emitter_write_bom
static int yaml_emitter_write_bom(yaml_emitter_t *emitter)
Definition: emitter.c:1754
yaml_emitter_emit_mapping_start
static int yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event)
Definition: emitter.c:1066
PUSH
#define PUSH(x)
Definition: bigdecimal.c:64
int
VP_EXPORT int
Definition: bigdecimal.c:5050
yaml_event_s
The event structure.
Definition: yaml.h:384
yaml_event_delete
yaml_event_delete(yaml_event_t *event)
Free any memory allocated for an event object.
Definition: api.c:979
strlen
size_t strlen(const char *)
yaml_emitter_analyze_version_directive
static int yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter, yaml_version_directive_t version_directive)
Definition: emitter.c:1333
YAML_EMIT_DOCUMENT_START_STATE
Expect DOCUMENT-START or STREAM-END.
Definition: yaml.h:1485
yaml_emitter_s::canonical
int canonical
If the output is in the canonical style?
Definition: yaml.h:1605
yaml_emitter_emit_document_content
static int yaml_emitter_emit_document_content(yaml_emitter_t *emitter, yaml_event_t *event)
Definition: emitter.c:677
yaml_emitter_s::root_context
int root_context
Is it the document root context?
Definition: yaml.h:1667
FLUSH
#define FLUSH(emitter)
Definition: emitter.c:8
yaml_emitter_s::anchor_data
struct yaml_emitter_s::@55 anchor_data
Anchor analysis.
YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE
Expect an item of a block sequence.
Definition: yaml.h:1505
yaml_emitter_s::sequence_context
int sequence_context
Is it a sequence context?
Definition: yaml.h:1669
IS_BOM
#define IS_BOM(string)
Definition: yaml_private.h:287
YAML_SEQUENCE_START_EVENT
A SEQUENCE-START event.
Definition: yaml.h:373
YAML_EMIT_BLOCK_MAPPING_VALUE_STATE
Expect a value of a block mapping.
Definition: yaml.h:1513
yaml_event_s::document_start
struct yaml_event_s::@20::@22 document_start
The document parameters (for YAML_DOCUMENT_START_EVENT).
YAML_MEMORY_ERROR
Cannot allocate or reallocate a block of memory.
Definition: yaml.h:127
YAML_EMIT_DOCUMENT_CONTENT_STATE
Expect the content of a document.
Definition: yaml.h:1487
yaml_string_t::end
yaml_char_t * end
Definition: yaml_private.h:102
YAML_MAPPING_START_EVENT
A MAPPING-START event.
Definition: yaml.h:378
yaml_emitter_s::handle_length
size_t handle_length
The tag handle length.
Definition: yaml.h:1701
yaml_emitter_emit_flow_sequence_item
static int yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter, yaml_event_t *event, int first)
Definition: emitter.c:729
YAML_EMIT_FLOW_MAPPING_KEY_STATE
Expect a key of a flow mapping.
Definition: yaml.h:1497
WRITE
#define WRITE(emitter, string)
Definition: emitter.c:43
yaml_emitter_check_simple_key
static int yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
Definition: emitter.c:1128
MOVE
#define MOVE(string)
Definition: yaml_private.h:380
yaml_emitter_write_double_quoted_scalar
static int yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int allow_breaks)
Definition: emitter.c:2021
yaml_emitter_s::suffix
yaml_char_t * suffix
The tag suffix.
Definition: yaml.h:1703
yaml_emitter_emit_node
static int yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event, int root, int sequence, int mapping, int simple_key)
Definition: emitter.c:970
yaml_emitter_process_scalar
static int yaml_emitter_process_scalar(yaml_emitter_t *emitter)
Definition: emitter.c:1294
YAML_EMIT_BLOCK_MAPPING_KEY_STATE
Expect the key of a block mapping.
Definition: yaml.h:1509
yaml_char_t
unsigned char yaml_char_t
The character type (UTF-8 octet).
Definition: yaml.h:78
yaml_emitter_s::flow_level
int flow_level
The current flow level.
Definition: yaml.h:1664
yaml_emitter_emit_document_start
static int yaml_emitter_emit_document_start(yaml_emitter_t *emitter, yaml_event_t *event, int first)
Definition: emitter.c:551
yaml_emitter_s::scalar_data
struct yaml_emitter_s::@57 scalar_data
Scalar analysis.
yaml_version_directive_s
The version directive data.
Definition: yaml.h:81
yaml_emitter_s::start
yaml_char_t * start
The beginning of the buffer.
Definition: yaml.h:1571
yaml_emitter_emit_flow_mapping_value
static int yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter, yaml_event_t *event, int simple)
Definition: emitter.c:841
yaml_emitter_s::whitespace
int whitespace
If the last character was a whitespace?
Definition: yaml.h:1680
IS_BREAK_AT
#define IS_BREAK_AT(string, offset)
Definition: yaml_private.h:318
alias
const char * alias
Definition: nkf.c:1151
PUT
#define PUT(emitter, value)
Definition: emitter.c:16
YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE
Expect a value for a simple key of a block mapping.
Definition: yaml.h:1511
yaml_emitter_s::open_ended
int open_ended
If an explicit document end is required?
Definition: yaml.h:1684
yaml_string_t::pointer
yaml_char_t * pointer
Definition: yaml_private.h:103
yaml_tag_directive_s::prefix
yaml_char_t * prefix
The tag prefix.
Definition: yaml.h:93
yaml_emitter_s::length
size_t length
The scalar length.
Definition: yaml.h:1713
IS_PRINTABLE
#define IS_PRINTABLE(string)
Definition: yaml_private.h:268
IS_SPACE_AT
#define IS_SPACE_AT(string, offset)
Definition: yaml_private.h:293
yaml_emitter_process_anchor
static int yaml_emitter_process_anchor(yaml_emitter_t *emitter)
Definition: emitter.c:1241
IS_BLANK
#define IS_BLANK(string)
Definition: yaml_private.h:312
YAML_EMIT_DOCUMENT_END_STATE
Expect DOCUMENT-END.
Definition: yaml.h:1489
YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE
Expect the first key of a flow mapping.
Definition: yaml.h:1495
yaml_emitter_write_indent
static int yaml_emitter_write_indent(yaml_emitter_t *emitter)
Definition: emitter.c:1766
yaml_emitter_check_empty_sequence
static int yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter)
Definition: emitter.c:1100
yaml_emitter_analyze_anchor
static int yaml_emitter_analyze_anchor(yaml_emitter_t *emitter, yaml_char_t *anchor, int alias)
Definition: emitter.c:1400
yaml_emitter_s::head
yaml_event_t * head
The head of the event queue.
Definition: yaml.h:1635
yaml_emitter_write_folded_scalar
static int yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length)
Definition: emitter.c:2274
yaml_emitter_s::column
int column
The current column.
Definition: yaml.h:1678
yaml_emitter_s::error
yaml_error_type_t error
Error type.
Definition: yaml.h:1533
yaml_emitter_emit
yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
Emit an event.
Definition: emitter.c:281
yaml_emitter_emit_block_mapping_key
static int yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter, yaml_event_t *event, int first)
Definition: emitter.c:900
yaml_string_t::start
yaml_char_t * start
Definition: yaml_private.h:101
WIDTH
#define WIDTH(string)
Definition: yaml_private.h:374
DEQUEUE
#define DEQUEUE(context, queue)
Definition: yaml_private.h:463
yaml_emitter_s::top
yaml_emitter_state_t * top
The top of the stack.
Definition: yaml.h:1622
STACK_EMPTY
#define STACK_EMPTY(context, stack)
Definition: yaml_private.h:424
yaml_emitter_s::indent
int indent
The current indentation level.
Definition: yaml.h:1661
yaml_emitter_s::alias
int alias
Is it an alias?
Definition: yaml.h:1693
yaml_emitter_emit_document_end
static int yaml_emitter_emit_document_end(yaml_emitter_t *emitter, yaml_event_t *event)
Definition: emitter.c:691
IS_SPACE
#define IS_SPACE(string)
Definition: yaml_private.h:295
yaml_free
yaml_free(void *ptr)
Definition: api.c:51
YAML_FOLDED_SCALAR_STYLE
The folded scalar style.
Definition: yaml.h:179
yaml_emitter_write_literal_scalar
static int yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length)
Definition: emitter.c:2235
yaml_emitter_s::indention
int indention
If the last character was an indentation character (&#39; &#39;, &#39;-&#39;, &#39;?&#39;, &#39;:&#39;)?
Definition: yaml.h:1682
yaml_emitter_s::state
yaml_emitter_state_t state
The current emitter state.
Definition: yaml.h:1626
QUEUE_EMPTY
#define QUEUE_EMPTY(context, queue)
Definition: yaml_private.h:451
yaml_emitter_emit_block_sequence_item
static int yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter, yaml_event_t *event, int first)
Definition: emitter.c:866
yaml_emitter_s::flow_plain_allowed
int flow_plain_allowed
Can the scalar be expessed in the flow plain style?
Definition: yaml.h:1717
yaml_emitter_s
The emitter structure.
Definition: yaml.h:1525
yaml_version_directive_s::major
int major
The major version number.
Definition: yaml.h:83
yaml_scalar_style_t
enum yaml_scalar_style_e yaml_scalar_style_t
Scalar styles.
YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE
Expect a value for a simple key of a flow mapping.
Definition: yaml.h:1499
CHECK
#define CHECK(string, octet)
Definition: yaml_private.h:170
YAML_DOCUMENT_START_EVENT
A DOCUMENT-START event.
Definition: yaml.h:363
yaml_emitter_s::encoding
yaml_encoding_t encoding
The stream encoding.
Definition: yaml.h:1593
IS_ALPHA
#define IS_ALPHA(string)
Definition: yaml_private.h:187
yaml_emitter_s::line
int line
The current line.
Definition: yaml.h:1676
yaml_emitter_append_tag_directive
static int yaml_emitter_append_tag_directive(yaml_emitter_t *emitter, yaml_tag_directive_t value, int allow_duplicates)
Definition: emitter.c:364
YAML_EMITTER_ERROR
Cannot emit a YAML stream.
Definition: yaml.h:141
yaml_emitter_process_tag
static int yaml_emitter_process_tag(yaml_emitter_t *emitter)
Definition: emitter.c:1259
YAML_DECLARE
#define YAML_DECLARE(type)
The public API declaration.
Definition: yaml.h:38
YAML_MAPPING_END_EVENT
A MAPPING-END event.
Definition: yaml.h:380
yaml_emitter_emit_stream_start
static int yaml_emitter_emit_stream_start(yaml_emitter_t *emitter, yaml_event_t *event)
Definition: emitter.c:495
yaml_emitter_s::simple_key_context
int simple_key_context
Is it a simple mapping key context?
Definition: yaml.h:1673
level
gz level
Definition: zlib.c:2264
YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE
Expect an item of a flow sequence.
Definition: yaml.h:1493
yaml_emitter_emit_block_mapping_value
static int yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter, yaml_event_t *event, int simple)
Definition: emitter.c:945
PUT_BREAK
#define PUT_BREAK(emitter)
Definition: emitter.c:26
yaml_emitter_s::style
yaml_scalar_style_t style
The output style.
Definition: yaml.h:1725
YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE
Expect the first item of a block sequence.
Definition: yaml.h:1503
yaml_emitter_s::events
struct yaml_emitter_s::@52 events
The event queue.
yaml_emitter_emit_alias
static int yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event)
Definition: emitter.c:1005
value
volatile VALUE value
Definition: tcltklib.c:9442
CHECK_AT
#define CHECK_AT(string, octet, offset)
Definition: yaml_private.h:163
yaml_tag_directive_s::handle
yaml_char_t * handle
The tag handle.
Definition: yaml.h:91
yaml_emitter_write_single_quoted_scalar
static int yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int allow_breaks)
Definition: emitter.c:1958
const
#define const
Definition: strftime.c:102
yaml_event_s::document_end
struct yaml_event_s::@20::@23 document_end
The document end parameters (for YAML_DOCUMENT_END_EVENT).
YAML_SEQUENCE_END_EVENT
A SEQUENCE-END event.
Definition: yaml.h:375
yaml_emitter_s::anchor
yaml_char_t * anchor
The anchor value.
Definition: yaml.h:1689
length
size_t length
Definition: tcltklib.c:4559
YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE
Expect the first item of a flow sequence.
Definition: yaml.h:1491
yaml_emitter_write_indicator
static int yaml_emitter_write_indicator(yaml_emitter_t *emitter, const char *indicator, int need_whitespace, int is_whitespace, int is_indention)
Definition: emitter.c:1786
yaml_event_s::mapping_start
struct yaml_event_s::@20::@27 mapping_start
The mapping parameters (for YAML_MAPPING_START_EVENT).
yaml_tag_directive_s
The tag directive data.
Definition: yaml.h:89
ENQUEUE
#define ENQUEUE(context, queue, value)
Definition: yaml_private.h:454
yaml_string_t
Definition: yaml_private.h:100
yaml_emitter_flush
yaml_emitter_flush(yaml_emitter_t *emitter)
Flush the accumulated characters to the output.
Definition: writer.c:32
yaml_emitter_s::suffix_length
size_t suffix_length
The tag suffix length.
Definition: yaml.h:1705
yaml_emitter_check_empty_document
static int yaml_emitter_check_empty_document(yaml_emitter_t *emitter)
Definition: emitter.c:1090
YAML_UTF8_ENCODING
The default UTF-8 encoding.
Definition: yaml.h:101
yaml_emitter_s::single_quoted_allowed
int single_quoted_allowed
Can the scalar be expressed in the single quoted style?
Definition: yaml.h:1721
yaml_emitter_s::handle
yaml_char_t * handle
The tag handle.
Definition: yaml.h:1699
yaml_emitter_s::block_plain_allowed
int block_plain_allowed
Can the scalar be expressed in the block plain style?
Definition: yaml.h:1719
end
gz end
Definition: zlib.c:2272
yaml_event_s::alias
struct yaml_event_s::@20::@24 alias
The alias parameters (for YAML_ALIAS_EVENT).
yaml_emitter_s::value
yaml_char_t * value
The scalar value.
Definition: yaml.h:1711
yaml_emitter_analyze_event
static int yaml_emitter_analyze_event(yaml_emitter_t *emitter, yaml_event_t *event)
Definition: emitter.c:1679
yaml_emitter_check_empty_mapping
static int yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter)
Definition: emitter.c:1114
IS_BLANKZ_AT
#define IS_BLANKZ_AT(string, offset)
Definition: yaml_private.h:359
YAML_DOCUMENT_END_EVENT
A DOCUMENT-END event.
Definition: yaml.h:365
yaml_emitter_emit_scalar
static int yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event)
Definition: emitter.c:1019
yaml_emitter_write_tag_content
static int yaml_emitter_write_tag_content(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int need_whitespace)
Definition: emitter.c:1850
YAML_EMIT_FLOW_MAPPING_VALUE_STATE
Expect a value of a flow mapping.
Definition: yaml.h:1501
yaml_emitter_emit_flow_mapping_key
static int yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter, yaml_event_t *event, int first)
Definition: emitter.c:778
yaml_emitter_s::mapping_context
int mapping_context
Is it a mapping context?
Definition: yaml.h:1671
yaml_emitter_s::indents
struct yaml_emitter_s::@53 indents
The stack of indentation levels.
WIDTH_AT
#define WIDTH_AT(string, offset)
Definition: yaml_private.h:368
yaml_emitter_write_anchor
static int yaml_emitter_write_anchor(yaml_emitter_t *emitter, yaml_char_t *value, size_t length)
Definition: emitter.c:1812
if
if(RB_TYPE_P(r, T_FLOAT))
Definition: bigdecimal.c:1186
YAML_SCALAR_EVENT
A SCALAR event.
Definition: yaml.h:370
yaml_emitter_s::best_indent
int best_indent
The number of indentation spaces.
Definition: yaml.h:1607
yaml_emitter_analyze_scalar
static int yaml_emitter_analyze_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length)
Definition: emitter.c:1479
YAML_PLAIN_SCALAR_STYLE
The plain scalar style.
Definition: yaml.h:169
yaml_emitter_s::multiline
int multiline
Does the scalar contain line breaks?
Definition: yaml.h:1715
YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE
Expect the first key of a block mapping.
Definition: yaml.h:1507
YAML_LITERAL_SCALAR_STYLE
The literal scalar style.
Definition: yaml.h:177
yaml_version_directive_s::minor
int minor
The minor version number.
Definition: yaml.h:85
YAML_STREAM_END_EVENT
A STREAM-END event.
Definition: yaml.h:360
yaml_event_s::data
union yaml_event_s::@20 data
The event data.
POP
#define POP(context, stack)
Definition: yaml_private.h:436
YAML_EMIT_FIRST_DOCUMENT_START_STATE
Expect the first DOCUMENT-START or STREAM-END.
Definition: yaml.h:1483
yaml_emitter_s::line_break
yaml_break_t line_break
The preferred line break.
Definition: yaml.h:1613
yaml_emitter_need_more_events
static int yaml_emitter_need_more_events(yaml_emitter_t *emitter)
Definition: emitter.c:309
YAML_EMIT_END_STATE
Expect nothing.
Definition: yaml.h:1515
yaml_emitter_s::block_allowed
int block_allowed
Can the scalar be expressed in the literal or folded styles?
Definition: yaml.h:1723
yaml_emitter_increase_indent
static int yaml_emitter_increase_indent(yaml_emitter_t *emitter, int flow, int indentless)
Definition: emitter.c:403
yaml_emitter_write_plain_scalar
static int yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter, yaml_char_t *value, size_t length, int allow_breaks)
Definition: emitter.c:1898
IS_ASCII
#define IS_ASCII(string)
Definition: yaml_private.h:244
IS_BLANKZ
#define IS_BLANKZ(string)
Definition: yaml_private.h:362
assert
#define assert(condition)
Definition: ossl.h:45
YAML_STREAM_START_EVENT
A STREAM-START event.
Definition: yaml.h:358
yaml_emitter_s::unicode
int unicode
Allow unescaped non-ASCII characters?
Definition: yaml.h:1611
digit
#define digit(x)
Definition: langinfo.c:58
yaml_emitter_s::best_width
int best_width
The preferred width of the output lines.
Definition: yaml.h:1609
yaml_emitter_s::tail
yaml_event_t * tail
The tail of the event queue.
Definition: yaml.h:1637
yaml_emitter_s::tag_directives
struct yaml_emitter_s::@54 tag_directives
The list of tag directives.
yaml_emitter_select_scalar_style
static int yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event)
Definition: emitter.c:1179
YAML_FLOW_MAPPING_STYLE
The flow mapping style.
Definition: yaml.h:201
STRING_ASSIGN
#define STRING_ASSIGN(value, string, length)
Definition: yaml_private.h:119
yaml_emitter_emit_sequence_start
static int yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event)
Definition: emitter.c:1042
yaml_private.h
yaml_emitter_s::states
struct yaml_emitter_s::@51 states
The stack of states.
YAML_ANY_SCALAR_STYLE
Let the emitter choose the style.
Definition: yaml.h:166
yaml_event_s::sequence_start
struct yaml_event_s::@20::@26 sequence_start
The sequence parameters (for YAML_SEQUENCE_START_EVENT).
yaml_emitter_write_block_scalar_hints
static int yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter, yaml_string_t string)
Definition: emitter.c:2177
IS_BREAK
#define IS_BREAK(string)
Definition: yaml_private.h:330
NULL
#define NULL
Definition: _sdbm.c:103
yaml_emitter_s::tag_data
struct yaml_emitter_s::@56 tag_data
Tag analysis.
yaml_event_s::type
yaml_event_type_t type
The event type.
Definition: yaml.h:387
yaml_emitter_state_machine
static int yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event)
Definition: emitter.c:424
yaml_event_s::scalar
struct yaml_event_s::@20::@25 scalar
The scalar parameters (for YAML_SCALAR_EVENT).
WRITE_BREAK
#define WRITE_BREAK(emitter, string)
Definition: emitter.c:53
YAML_ALIAS_EVENT
An ALIAS event.
Definition: yaml.h:368
yaml_emitter_analyze_tag_directive
static int yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter, yaml_tag_directive_t tag_directive)
Definition: emitter.c:1349
YAML_FLOW_SEQUENCE_STYLE
The flow sequence style.
Definition: yaml.h:190
yaml_emitter_analyze_tag
static int yaml_emitter_analyze_tag(yaml_emitter_t *emitter, yaml_char_t *tag)
Definition: emitter.c:1436
YAML_SINGLE_QUOTED_SCALAR_STYLE
The single-quoted scalar style.
Definition: yaml.h:172