Context Navigation

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

Revision 214, 50.1 KB checked in by xi, 7 years ago (diff)
Implement everything except tag and scalar writers.

Line
1
2	#include "yaml_private.h"
3
4	/*
5	* Flush the buffer if needed.
6	*/
7
8	#define FLUSH(emitter) \
9	((emitter->buffer.pointer+5 < emitter->buffer.end) \
10	\|\| yaml_emitter_flush(emitter))
11
12	/*
13	* Put a character to the output buffer.
14	*/
15
16	#define PUT(emitter,value) \
17	(FLUSH(emitter) \
18	&& (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \
19	emitter->column ++, \
20	1))
21
22	/*
23	* Put a line break to the output buffer.
24	*/
25
26	#define PUT_BREAK(emitter) \
27	(FLUSH(emitter) \
28	&& ((emitter->line_break == YAML_CR_BREAK ? \
29	(*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \
30	emitter->line_break == YAML_LN_BREAK ? \
31	(*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \
32	emitter->line_break == YAML_CRLN_BREAK ? \
33	(*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \
34	*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \
35	emitter->column = 0, \
36	emitter->line ++, \
37	1))
38
39	/*
40	* Copy a character from a string into buffer.
41	*/
42
43	#define WRITE(emitter,string) \
44	(FLUSH(emitter) \
45	&& (COPY(emitter->buffer,string), \
46	emitter->column ++, \
47	1))
48
49	/*
50	* Copy a line break character from a string into buffer.
51	*/
52
53	#define WRITE_BREAK(emitter,string) \
54	(FLUSH(emitter) \
55	&& (COPY(emitter->buffer,string), \
56	emitter->column = 0, \
57	emitter->line ++, \
58	1))
59
60	/*
61	* API functions.
62	*/
63
64	YAML_DECLARE(int)
65	yaml_emitter_emit(yaml_emitter_t emitter, yaml_event_t event);
66
67	/*
68	* Utility functions.
69	*/
70
71	static int
72	yaml_emitter_set_emitter_error(yaml_emitter_t emitter, const char problem);
73
74	static int
75	yaml_emitter_need_more_events(yaml_emitter_t *emitter);
76
77	static int
78	yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
79	yaml_tag_directive_t value, int allow_duplicates);
80
81	static int
82	yaml_emitter_increase_indent(yaml_emitter_t *emitter,
83	int flow, int indentless);
84
85	/*
86	* State functions.
87	*/
88
89	static int
90	yaml_emitter_state_machine(yaml_emitter_t emitter, yaml_event_t event);
91
92	static int
93	yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
94	yaml_event_t *event);
95
96	static int
97	yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
98	yaml_event_t *event, int first);
99
100	static int
101	yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
102	yaml_event_t *event);
103
104	static int
105	yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
106	yaml_event_t *event);
107
108	static int
109	yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
110	yaml_event_t *event, int first);
111
112	static int
113	yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
114	yaml_event_t *event, int first);
115
116	static int
117	yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
118	yaml_event_t *event, int simple);
119
120	static int
121	yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
122	yaml_event_t *event, int first);
123
124	static int
125	yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
126	yaml_event_t *event, int first);
127
128	static int
129	yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
130	yaml_event_t *event, int simple);
131
132	static int
133	yaml_emitter_emit_node(yaml_emitter_t emitter, yaml_event_t event,
134	int root, int sequence, int mapping, int simple_key);
135
136	static int
137	yaml_emitter_emit_alias(yaml_emitter_t emitter, yaml_event_t event);
138
139	static int
140	yaml_emitter_emit_scalar(yaml_emitter_t emitter, yaml_event_t event);
141
142	static int
143	yaml_emitter_emit_sequence_start(yaml_emitter_t emitter, yaml_event_t event);
144
145	static int
146	yaml_emitter_emit_mapping_start(yaml_emitter_t emitter, yaml_event_t event);
147
148	/*
149	* Checkers.
150	*/
151
152	static int
153	yaml_emitter_check_empty_document(yaml_emitter_t *emitter);
154
155	static int
156	yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter);
157
158	static int
159	yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter);
160
161	static int
162	yaml_emitter_check_simple_key(yaml_emitter_t *emitter);
163
164	static int
165	yaml_emitter_select_scalar_style(yaml_emitter_t emitter, yaml_event_t event);
166
167	/*
168	* Processors.
169	*/
170
171	static int
172	yaml_emitter_process_anchor(yaml_emitter_t *emitter);
173
174	static int
175	yaml_emitter_process_tag(yaml_emitter_t *emitter);
176
177	static int
178	yaml_emitter_process_scalar(yaml_emitter_t *emitter);
179
180	/*
181	* Analyzers.
182	*/
183
184	static int
185	yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
186	yaml_version_directive_t version_directive);
187
188	static int
189	yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
190	yaml_tag_directive_t tag_directive);
191
192	static int
193	yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
194	yaml_char_t *anchor, int alias);
195
196	static int
197	yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
198	yaml_char_t *tag);
199
200	static int
201	yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
202	yaml_char_t *value, size_t length);
203
204	static int
205	yaml_emitter_analyze_event(yaml_emitter_t *emitter,
206	yaml_event_t *event);
207
208	/*
209	* Writers.
210	*/
211
212	static int
213	yaml_emitter_write_bom(yaml_emitter_t *emitter);
214
215	static int
216	yaml_emitter_write_indent(yaml_emitter_t *emitter);
217
218	static int
219	yaml_emitter_write_indicator(yaml_emitter_t *emitter,
220	char *indicator, int need_whitespace,
221	int is_whitespace, int is_indention);
222
223	static int
224	yaml_emitter_write_anchor(yaml_emitter_t *emitter,
225	yaml_char_t *value, size_t length);
226
227	static int
228	yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
229	yaml_char_t *value, size_t length);
230
231	static int
232	yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
233	yaml_char_t *value, size_t length);
234
235	static int
236	yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
237	yaml_char_t *value, size_t length, int allow_breaks);
238
239	static int
240	yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
241	yaml_char_t *value, size_t length, int allow_breaks);
242
243	static int
244	yaml_emitter_write_double_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_literal_scalar(yaml_emitter_t *emitter,
249	yaml_char_t *value, size_t length);
250
251	static int
252	yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
253	yaml_char_t *value, size_t length);
254
255	/*
256	* Set an emitter error and return 0.
257	*/
258
259	static int
260	yaml_emitter_set_emitter_error(yaml_emitter_t emitter, const char problem)
261	{
262	emitter->error = YAML_EMITTER_ERROR;
263	emitter->problem = problem;
264
265	return 0;
266	}
267
268	/*
269	* Emit an event.
270	*/
271
272	YAML_DECLARE(int)
273	yaml_emitter_emit(yaml_emitter_t emitter, yaml_event_t event)
274	{
275	if (!ENQUEUE(emitter, emitter->events, *event)) {
276	yaml_event_delete(event);
277	return 0;
278	}
279
280	while (!yaml_emitter_need_more_events(emitter)) {
281	if (!yaml_emitter_analyze_event(emitter, emitter->events.head))
282	return 0;
283	if (!yaml_emitter_state_machine(emitter, emitter->events.head))
284	return 0;
285	DEQUEUE(emitter, emitter->events);
286	}
287
288	return 1;
289	}
290
291	/*
292	* Check if we need to accumulate more events before emitting.
293	*
294	* We accumulate extra
295	* - 1 event for DOCUMENT-START
296	* - 2 events for SEQUENCE-START
297	* - 3 events for MAPPING-START
298	*/
299
300	static int
301	yaml_emitter_need_more_events(yaml_emitter_t *emitter)
302	{
303	int level = 0;
304	int accumulate = 0;
305	yaml_event_t *event;
306
307	if (QUEUE_EMPTY(emitter, emitter->events))
308	return 1;
309
310	switch (emitter->events.head->type) {
311	case YAML_DOCUMENT_START_EVENT:
312	accumulate = 1;
313	break;
314	case YAML_SEQUENCE_START_EVENT:
315	accumulate = 2;
316	break;
317	case YAML_MAPPING_START_EVENT:
318	accumulate = 3;
319	break;
320	default:
321	return 0;
322	}
323
324	if (emitter->events.tail - emitter->events.head > accumulate)
325	return 0;
326
327	for (event = emitter->events.head; event != emitter->events.tail; event ++) {
328	switch (event->type) {
329	case YAML_STREAM_START_EVENT:
330	case YAML_DOCUMENT_START_EVENT:
331	case YAML_SEQUENCE_START_EVENT:
332	case YAML_MAPPING_START_EVENT:
333	level += 1;
334	break;
335	case YAML_STREAM_END_EVENT:
336	case YAML_DOCUMENT_END_EVENT:
337	case YAML_SEQUENCE_END_EVENT:
338	case YAML_MAPPING_END_EVENT:
339	level -= 1;
340	break;
341	default:
342	break;
343	}
344	if (!level)
345	return 0;
346	}
347
348	return 1;
349	}
350
351	/*
352	* Append a directive to the directives stack.
353	*/
354
355	static int
356	yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
357	yaml_tag_directive_t value, int allow_duplicates)
358	{
359	yaml_tag_directive_t *tag_directive;
360	yaml_tag_directive_t copy = { NULL, NULL };
361
362	for (tag_directive = emitter->tag_directives.start;
363	tag_directive != emitter->tag_directives.top; tag_directive ++) {
364	if (strcmp((char )value.handle, (char )tag_directive->handle) == 0) {
365	if (allow_duplicates)
366	return 1;
367	return yaml_emitter_set_emitter_error(emitter,
368	"duplicate %TAG directive");
369	}
370	}
371
372	copy.handle = yaml_strdup(value.handle);
373	copy.prefix = yaml_strdup(value.prefix);
374	if (!copy.handle \|\| !copy.prefix) {
375	emitter->error = YAML_MEMORY_ERROR;
376	goto error;
377	}
378
379	if (!PUSH(emitter, emitter->tag_directives, copy))
380	goto error;
381
382	return 1;
383
384	error:
385	yaml_free(copy.handle);
386	yaml_free(copy.prefix);
387	return 0;
388	}
389
390	/*
391	* Increase the indentation level.
392	*/
393
394	static int
395	yaml_emitter_increase_indent(yaml_emitter_t *emitter,
396	int flow, int indentless)
397	{
398	if (!PUSH(emitter, emitter->indents, emitter->indent))
399	return 0;
400
401	if (emitter->indent < 0) {
402	emitter->indent = flow ? emitter->best_indent : 0;
403	}
404	else if (!indentless) {
405	emitter->indent += emitter->best_indent;
406	}
407
408	return 1;
409	}
410
411	/*
412	* State dispatcher.
413	*/
414
415	static int
416	yaml_emitter_state_machine(yaml_emitter_t emitter, yaml_event_t event)
417	{
418	switch (emitter->state)
419	{
420	case YAML_EMIT_STREAM_START_STATE:
421	return yaml_emitter_emit_stream_start(emitter, event);
422
423	case YAML_EMIT_FIRST_DOCUMENT_START_STATE:
424	return yaml_emitter_emit_document_start(emitter, event, 1);
425
426	case YAML_EMIT_DOCUMENT_START_STATE:
427	return yaml_emitter_emit_document_start(emitter, event, 0);
428
429	case YAML_EMIT_DOCUMENT_CONTENT_STATE:
430	return yaml_emitter_emit_document_content(emitter, event);
431
432	case YAML_EMIT_DOCUMENT_END_STATE:
433	return yaml_emitter_emit_document_end(emitter, event);
434
435	case YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
436	return yaml_emitter_emit_flow_sequence_item(emitter, event, 1);
437
438	case YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE:
439	return yaml_emitter_emit_flow_sequence_item(emitter, event, 0);
440
441	case YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
442	return yaml_emitter_emit_flow_mapping_key(emitter, event, 1);
443
444	case YAML_EMIT_FLOW_MAPPING_KEY_STATE:
445	return yaml_emitter_emit_flow_mapping_key(emitter, event, 0);
446
447	case YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
448	return yaml_emitter_emit_flow_mapping_value(emitter, event, 1);
449
450	case YAML_EMIT_FLOW_MAPPING_VALUE_STATE:
451	return yaml_emitter_emit_flow_mapping_value(emitter, event, 0);
452
453	case YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
454	return yaml_emitter_emit_block_sequence_item(emitter, event, 1);
455
456	case YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
457	return yaml_emitter_emit_block_sequence_item(emitter, event, 0);
458
459	case YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
460	return yaml_emitter_emit_block_mapping_key(emitter, event, 1);
461
462	case YAML_EMIT_BLOCK_MAPPING_KEY_STATE:
463	return yaml_emitter_emit_block_mapping_key(emitter, event, 0);
464
465	case YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
466	return yaml_emitter_emit_block_mapping_value(emitter, event, 1);
467
468	case YAML_EMIT_BLOCK_MAPPING_VALUE_STATE:
469	return yaml_emitter_emit_block_mapping_value(emitter, event, 0);
470
471	case YAML_EMIT_END_STATE:
472	return yaml_emitter_set_emitter_error(emitter,
473	"expected nothing after STREAM-END");
474
475	default:
476	assert(1); /* Invalid state. */
477	}
478
479	return 0;
480	}
481
482	/*
483	* Expect STREAM-START.
484	*/
485
486	static int
487	yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
488	yaml_event_t *event)
489	{
490	if (event->type == YAML_STREAM_START_EVENT)
491	{
492	if (!emitter->encoding) {
493	emitter->encoding = event->data.stream_start.encoding;
494	}
495
496	if (!emitter->encoding) {
497	emitter->encoding = YAML_UTF8_ENCODING;
498	}
499
500	if (emitter->best_indent < 2 \|\| emitter->best_indent > 9) {
501	emitter->best_indent = 2;
502	}
503
504	if (emitter->best_width >= 0
505	&& emitter->best_width <= emitter->best_indent*2) {
506	emitter->best_width = 80;
507	}
508
509	if (emitter->best_width < 0) {
510	emitter->best_width = INT_MAX;
511	}
512
513	if (!emitter->line_break) {
514	emitter->line_break = YAML_LN_BREAK;
515	}
516
517	emitter->indent = -1;
518
519	emitter->line = 0;
520	emitter->column = 0;
521	emitter->whitespace = 1;
522	emitter->indention = 1;
523
524	if (emitter->encoding != YAML_UTF8_ENCODING) {
525	if (!yaml_emitter_write_bom(emitter))
526	return 0;
527	}
528
529	emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE;
530
531	return 1;
532	}
533
534	return yaml_emitter_set_emitter_error(emitter,
535	"expected STREAM-START");
536	}
537
538	/*
539	* Expect DOCUMENT-START or STREAM-END.
540	*/
541
542	static int
543	yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
544	yaml_event_t *event, int first)
545	{
546	if (event->type == YAML_DOCUMENT_START_EVENT)
547	{
548	yaml_tag_directive_t default_tag_directives[] = {
549	{(yaml_char_t )"!", (yaml_char_t )"!"},
550	{(yaml_char_t )"!!", (yaml_char_t )"tag:yaml.org,2002:"},
551	{NULL, NULL}
552	};
553	yaml_tag_directive_t *tag_directive;
554	int implicit;
555
556	if (event->data.document_start.version_directive) {
557	if (!yaml_emitter_analyze_version_directive(emitter,
558	*event->data.document_start.version_directive))
559	return 0;
560	}
561
562	for (tag_directive = event->data.document_start.tag_directives.start;
563	tag_directive != event->data.document_start.tag_directives.end;
564	tag_directive ++) {
565	if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive))
566	return 0;
567	if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 0))
568	return 0;
569	}
570
571	for (tag_directive = default_tag_directives;
572	tag_directive->handle; tag_directive ++) {
573	if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 1))
574	return 0;
575	}
576
577	implicit = event->data.document_start.implicit;
578	if (!first \|\| emitter->canonical) {
579	implicit = 0;
580	}
581
582	if (event->data.document_start.version_directive) {
583	implicit = 0;
584	if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0))
585	return 0;
586	if (!yaml_emitter_write_indicator(emitter, "1.1", 1, 0, 0))
587	return 0;
588	if (!yaml_emitter_write_indent(emitter))
589	return 0;
590	}
591
592	if (event->data.document_start.tag_directives.start
593	!= event->data.document_start.tag_directives.end) {
594	implicit = 0;
595	for (tag_directive = event->data.document_start.tag_directives.start;
596	tag_directive != event->data.document_start.tag_directives.end;
597	tag_directive ++) {
598	if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0))
599	return 0;
600	if (!yaml_emitter_write_tag_handle(emitter, tag_directive->handle,
601	strlen((char *)tag_directive->handle)))
602	return 0;
603	if (!yaml_emitter_write_tag_content(emitter, tag_directive->prefix,
604	strlen((char *)tag_directive->prefix)))
605	return 0;
606	if (!yaml_emitter_write_indent(emitter))
607	return 0;
608	}
609	}
610
611	if (yaml_emitter_check_empty_document(emitter)) {
612	implicit = 0;
613	}
614
615	if (!implicit) {
616	if (!yaml_emitter_write_indent(emitter))
617	return 0;
618	if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0))
619	return 0;
620	if (emitter->canonical) {
621	if (!yaml_emitter_write_indent(emitter))
622	return 0;
623	}
624	}
625
626	emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE;
627
628	return 1;
629	}
630
631	else if (event->type == YAML_STREAM_END_EVENT)
632	{
633	if (!yaml_emitter_flush(emitter))
634	return 0;
635
636	emitter->state = YAML_EMIT_END_STATE;
637
638	return 1;
639	}
640
641	return yaml_emitter_set_emitter_error(emitter,
642	"expected DOCUMENT-START or STREAM-END");
643	}
644
645	/*
646	* Expect the root node.
647	*/
648
649	static int
650	yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
651	yaml_event_t *event)
652	{
653	if (!PUSH(emitter, emitter->states, YAML_EMIT_DOCUMENT_END_STATE))
654	return 0;
655
656	return yaml_emitter_emit_node(emitter, event, 1, 0, 0, 0);
657	}
658
659	/*
660	* Expect DOCUMENT-END.
661	*/
662
663	static int
664	yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
665	yaml_event_t *event)
666	{
667	if (event->type == YAML_DOCUMENT_END_EVENT)
668	{
669	if (!yaml_emitter_write_indent(emitter))
670	return 0;
671	if (!event->data.document_end.implicit) {
672	if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
673	return 0;
674	if (!yaml_emitter_write_indent(emitter))
675	return 0;
676	}
677	if (!yaml_emitter_flush(emitter))
678	return 0;
679
680	emitter->state = YAML_EMIT_DOCUMENT_START_STATE;
681
682	return 1;
683	}
684
685	return yaml_emitter_set_emitter_error(emitter,
686	"expected DOCUMENT-END");
687	}
688
689	/*
690	* Expect a flow item node.
691	*/
692
693	static int
694	yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
695	yaml_event_t *event, int first)
696	{
697	if (first)
698	{
699	if (!yaml_emitter_write_indicator(emitter, "[", 1, 1, 0))
700	return 0;
701	if (!yaml_emitter_increase_indent(emitter, 1, 0))
702	return 0;
703	emitter->flow_level ++;
704	}
705
706	if (event->type == YAML_SEQUENCE_END_EVENT)
707	{
708	emitter->flow_level --;
709	emitter->indent = POP(emitter, emitter->indents);
710	if (emitter->canonical && !first) {
711	if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
712	return 0;
713	if (!yaml_emitter_write_indent(emitter))
714	return 0;
715	}
716	if (!yaml_emitter_write_indicator(emitter, "]", 0, 0, 0))
717	return 0;
718	emitter->state = POP(emitter, emitter->states);
719
720	return 1;
721	}
722
723	if (emitter->canonical \|\| emitter->column > emitter->best_width) {
724	if (!yaml_emitter_write_indent(emitter))
725	return 0;
726	}
727	if (PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE))
728	return 0;
729
730	return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
731	}
732
733	/*
734	* Expect a flow key node.
735	*/
736
737	static int
738	yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
739	yaml_event_t *event, int first)
740	{
741	if (first)
742	{
743	if (!yaml_emitter_write_indicator(emitter, "{", 1, 1, 0))
744	return 0;
745	if (!yaml_emitter_increase_indent(emitter, 1, 0))
746	return 0;
747	emitter->flow_level ++;
748	}
749
750	if (event->type == YAML_MAPPING_END_EVENT)
751	{
752	emitter->flow_level --;
753	emitter->indent = POP(emitter, emitter->indents);
754	if (emitter->canonical && !first) {
755	if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
756	return 0;
757	if (!yaml_emitter_write_indent(emitter))
758	return 0;
759	}
760	if (!yaml_emitter_write_indicator(emitter, "}", 0, 0, 0))
761	return 0;
762	emitter->state = POP(emitter, emitter->states);
763
764	return 1;
765	}
766
767	if (!first) {
768	if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
769	return 0;
770	}
771	if (emitter->canonical \|\| emitter->column > emitter->best_width) {
772	if (!yaml_emitter_write_indent(emitter))
773	return 0;
774	}
775
776	if (!emitter->canonical && yaml_emitter_check_simple_key(emitter))
777	{
778	if (!PUSH(emitter, emitter->states,
779	YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE))
780	return 0;
781
782	return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
783	}
784	else
785	{
786	if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 0))
787	return 0;
788	if (!PUSH(emitter, emitter->states,
789	YAML_EMIT_FLOW_MAPPING_VALUE_STATE))
790	return 0;
791
792	return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
793	}
794	}
795
796	/*
797	* Expect a flow value node.
798	*/
799
800	static int
801	yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
802	yaml_event_t *event, int simple)
803	{
804	if (simple) {
805	if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
806	return 0;
807	}
808	else {
809	if (emitter->canonical \|\| emitter->column > emitter->best_width) {
810	if (!yaml_emitter_write_indent(emitter))
811	return 0;
812	}
813	if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0))
814	return 0;
815	}
816	if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE))
817	return 0;
818	return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
819	}
820
821	/*
822	* Expect a block item node.
823	*/
824
825	static int
826	yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
827	yaml_event_t *event, int first)
828	{
829	if (first)
830	{
831	if (!yaml_emitter_increase_indent(emitter, 0,
832	(emitter->mapping_context && !emitter->indention)))
833	return 0;
834	}
835
836	if (event->type == YAML_SEQUENCE_END_EVENT)
837	{
838	emitter->indent = POP(emitter, emitter->indents);
839	emitter->state = POP(emitter, emitter->states);
840
841	return 1;
842	}
843
844	if (!yaml_emitter_write_indent(emitter))
845	return 0;
846	if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1))
847	return 0;
848	if (!PUSH(emitter, emitter->states,
849	YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE))
850	return 0;
851
852	return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
853	}
854
855	/*
856	* Expect a block key node.
857	*/
858
859	static int
860	yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
861	yaml_event_t *event, int first)
862	{
863	if (first)
864	{
865	if (!yaml_emitter_increase_indent(emitter, 0, 0))
866	return 0;
867	}
868
869	if (event->type == YAML_MAPPING_END_EVENT)
870	{
871	emitter->indent = POP(emitter, emitter->indents);
872	emitter->state = POP(emitter, emitter->states);
873
874	return 1;
875	}
876
877	if (!yaml_emitter_write_indent(emitter))
878	return 0;
879
880	if (yaml_emitter_check_simple_key(emitter))
881	{
882	if (!PUSH(emitter, emitter->states,
883	YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE))
884	return 0;
885
886	return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
887	}
888	else
889	{
890	if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1))
891	return 0;
892	if (!PUSH(emitter, emitter->states,
893	YAML_EMIT_BLOCK_MAPPING_VALUE_STATE))
894	return 0;
895
896	return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
897	}
898	}
899
900	/*
901	* Expect a block value node.
902	*/
903
904	static int
905	yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
906	yaml_event_t *event, int simple)
907	{
908	if (simple) {
909	if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
910	return 0;
911	}
912	else {
913	if (!yaml_emitter_write_indent(emitter))
914	return 0;
915	if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1))
916	return 0;
917	}
918	if (!PUSH(emitter, emitter->states,
919	YAML_EMIT_BLOCK_MAPPING_KEY_STATE))
920	return 0;
921
922	return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
923	}
924
925	/*
926	* Expect a node.
927	*/
928
929	static int
930	yaml_emitter_emit_node(yaml_emitter_t emitter, yaml_event_t event,
931	int root, int sequence, int mapping, int simple_key)
932	{
933	emitter->root_context = root;
934	emitter->sequence_context = sequence;
935	emitter->mapping_context = mapping;
936	emitter->simple_key_context = simple_key;
937
938	switch (event->type)
939	{
940	case YAML_ALIAS_EVENT:
941	return yaml_emitter_emit_alias(emitter, event);
942
943	case YAML_SCALAR_EVENT:
944	return yaml_emitter_emit_scalar(emitter, event);
945
946	case YAML_SEQUENCE_START_EVENT:
947	return yaml_emitter_emit_sequence_start(emitter, event);
948
949	case YAML_MAPPING_START_EVENT:
950	return yaml_emitter_emit_mapping_start(emitter, event);
951
952	default:
953	return yaml_emitter_set_emitter_error(emitter,
954	"expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS");
955	}
956
957	return 0;
958	}
959
960	/*
961	* Expect ALIAS.
962	*/
963
964	static int
965	yaml_emitter_emit_alias(yaml_emitter_t emitter, yaml_event_t event)
966	{
967	if (!yaml_emitter_process_anchor(emitter))
968	return 0;
969	emitter->state = POP(emitter, emitter->states);
970
971	return 1;
972	}
973
974	/*
975	* Expect SCALAR.
976	*/
977
978	static int
979	yaml_emitter_emit_scalar(yaml_emitter_t emitter, yaml_event_t event)
980	{
981	if (!yaml_emitter_select_scalar_style(emitter, event))
982	return 0;
983	if (!yaml_emitter_process_anchor(emitter))
984	return 0;
985	if (!yaml_emitter_process_tag(emitter))
986	return 0;
987	if (!yaml_emitter_increase_indent(emitter, 1, 0))
988	return 0;
989	if (!yaml_emitter_process_scalar(emitter))
990	return 0;
991	emitter->indent = POP(emitter, emitter->indents);
992	emitter->state = POP(emitter, emitter->states);
993
994	return 1;
995	}
996
997	/*
998	* Expect SEQUENCE-START.
999	*/
1000
1001	static int
1002	yaml_emitter_emit_sequence_start(yaml_emitter_t emitter, yaml_event_t event)
1003	{
1004	if (!yaml_emitter_process_anchor(emitter))
1005	return 0;
1006	if (!yaml_emitter_process_tag(emitter))
1007	return 0;
1008
1009	if (emitter->flow_level \|\| emitter->canonical
1010	\|\| event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE
1011	\|\| yaml_emitter_check_empty_sequence(emitter)) {
1012	emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE;
1013	}
1014	else {
1015	emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE;
1016	}
1017
1018	return 1;
1019	}
1020
1021	/*
1022	* Expect MAPPING-START.
1023	*/
1024
1025	static int
1026	yaml_emitter_emit_mapping_start(yaml_emitter_t emitter, yaml_event_t event)
1027	{
1028	if (!yaml_emitter_process_anchor(emitter))
1029	return 0;
1030	if (!yaml_emitter_process_tag(emitter))
1031	return 0;
1032
1033	if (emitter->flow_level \|\| emitter->canonical
1034	\|\| event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE
1035	\|\| yaml_emitter_check_empty_mapping(emitter)) {
1036	emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE;
1037	}
1038	else {
1039	emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE;
1040	}
1041
1042	return 1;
1043	}
1044
1045	/*
1046	* Check if the document content is an empty scalar.
1047	*/
1048
1049	static int
1050	yaml_emitter_check_empty_document(yaml_emitter_t *emitter)
1051	{
1052	return 0;
1053	}
1054
1055	/*
1056	* Check if the next events represent an empty sequence.
1057	*/
1058
1059	static int
1060	yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter)
1061	{
1062	if (emitter->events.tail - emitter->events.head < 2)
1063	return 0;
1064
1065	return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT
1066	&& emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT);
1067	}
1068
1069	/*
1070	* Check if the next events represent an empty mapping.
1071	*/
1072
1073	static int
1074	yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter)
1075	{
1076	if (emitter->events.tail - emitter->events.head < 2)
1077	return 0;
1078
1079	return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT
1080	&& emitter->events.head[1].type == YAML_MAPPING_END_EVENT);
1081	}
1082
1083	/*
1084	* Check if the next node can be expressed as a simple key.
1085	*/
1086
1087	static int
1088	yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
1089	{
1090	yaml_event_t *event = emitter->events.head;
1091	size_t length = 0;
1092
1093	switch (event->type)
1094	{
1095	case YAML_ALIAS_EVENT:
1096	length += emitter->anchor_data.anchor_length;
1097	break;
1098
1099	case YAML_SCALAR_EVENT:
1100	if (emitter->scalar_data.multiline)
1101	return 0;
1102	length += emitter->anchor_data.anchor_length
1103	+ emitter->tag_data.handle_length
1104	+ emitter->tag_data.suffix_length
1105	+ emitter->scalar_data.length;
1106	break;
1107
1108	case YAML_SEQUENCE_START_EVENT:
1109	if (!yaml_emitter_check_empty_sequence(emitter))
1110	return 0;
1111	length += emitter->anchor_data.anchor_length
1112	+ emitter->tag_data.handle_length
1113	+ emitter->tag_data.suffix_length;
1114	break;
1115
1116	case YAML_MAPPING_START_EVENT:
1117	if (!yaml_emitter_check_empty_sequence(emitter))
1118	return 0;
1119	length += emitter->anchor_data.anchor_length
1120	+ emitter->tag_data.handle_length
1121	+ emitter->tag_data.suffix_length;
1122	break;
1123
1124	default:
1125	return 0;
1126	}
1127
1128	if (length > 128)
1129	return 0;
1130
1131	return 1;
1132	}
1133
1134	/*
1135	* Determine an acceptable scalar style.
1136	*/
1137
1138	static int
1139	yaml_emitter_select_scalar_style(yaml_emitter_t emitter, yaml_event_t event)
1140	{
1141	yaml_scalar_style_t style = event->data.scalar.style;
1142
1143	if (style == YAML_ANY_SCALAR_STYLE)
1144	style = YAML_PLAIN_SCALAR_STYLE;
1145
1146	if (emitter->canonical)
1147	style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1148
1149	if (emitter->simple_key_context && emitter->scalar_data.multiline)
1150	style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1151
1152	if (style == YAML_PLAIN_SCALAR_STYLE)
1153	{
1154	if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed)
1155	\|\| (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed))
1156	style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1157	if (!emitter->scalar_data.length
1158	&& (emitter->flow_level \|\| emitter->simple_key_context))
1159	style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1160	if (!event->data.scalar.plain_implicit
1161	&& !emitter->tag_data.handle && !emitter->tag_data.suffix)
1162	style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1163	}
1164
1165	if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE)
1166	{
1167	if (!emitter->scalar_data.single_quoted_allowed)
1168	style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1169	}
1170
1171	if (style == YAML_LITERAL_SCALAR_STYLE \|\| style == YAML_FOLDED_SCALAR_STYLE)
1172	{
1173	if (!emitter->scalar_data.block_allowed)
1174	style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1175	}
1176
1177	if (!emitter->tag_data.handle && !emitter->tag_data.suffix)
1178	{
1179	if (!event->data.scalar.plain_implicit
1180	&& !event->data.scalar.quoted_implicit) {
1181	return yaml_emitter_set_emitter_error(emitter,
1182	"neither tag nor implicit flags are specified");
1183	}
1184
1185	if (event->data.scalar.plain_implicit
1186	&& style != YAML_PLAIN_SCALAR_STYLE) {
1187	emitter->tag_data.handle = (yaml_char_t *)"!";
1188	emitter->tag_data.handle_length = 1;
1189	}
1190	}
1191
1192	emitter->scalar_data.style = style;
1193
1194	return 1;
1195	}
1196
1197	/*
1198	* Write an achor.
1199	*/
1200
1201	static int
1202	yaml_emitter_process_anchor(yaml_emitter_t *emitter)
1203	{
1204	if (!emitter->anchor_data.anchor)
1205	return 1;
1206
1207	if (!yaml_emitter_write_indicator(emitter,
1208	(emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0))
1209	return 0;
1210
1211	return yaml_emitter_write_anchor(emitter,
1212	emitter->anchor_data.anchor, emitter->anchor_data.anchor_length);
1213	}
1214
1215	/*
1216	* Write a tag.
1217	*/
1218
1219	static int
1220	yaml_emitter_process_tag(yaml_emitter_t *emitter)
1221	{
1222	if (!emitter->tag_data.handle && !emitter->tag_data.suffix)
1223	return 1;
1224
1225	if (emitter->tag_data.handle)
1226	{
1227	if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle,
1228	emitter->tag_data.handle_length))
1229	return 0;
1230	if (emitter->tag_data.suffix) {
1231	if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
1232	emitter->tag_data.suffix_length))
1233	return 0;
1234	}
1235	}
1236	else
1237	{
1238	if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0))
1239	return 0;
1240	if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
1241	emitter->tag_data.suffix_length))
1242	return 0;
1243	if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0))
1244	return 0;
1245	}
1246
1247	return 1;
1248	}
1249
1250	/*
1251	* Write a scalar.
1252	*/
1253
1254	static int
1255	yaml_emitter_process_scalar(yaml_emitter_t *emitter)
1256	{
1257	switch (emitter->scalar_data.style)
1258	{
1259	case YAML_PLAIN_SCALAR_STYLE:
1260	return yaml_emitter_write_plain_scalar(emitter,
1261	emitter->scalar_data.value, emitter->scalar_data.length,
1262	!emitter->simple_key_context);
1263
1264	case YAML_SINGLE_QUOTED_SCALAR_STYLE:
1265	return yaml_emitter_write_single_quoted_scalar(emitter,
1266	emitter->scalar_data.value, emitter->scalar_data.length,
1267	!emitter->simple_key_context);
1268
1269	case YAML_DOUBLE_QUOTED_SCALAR_STYLE:
1270	return yaml_emitter_write_double_quoted_scalar(emitter,
1271	emitter->scalar_data.value, emitter->scalar_data.length,
1272	!emitter->simple_key_context);
1273
1274	case YAML_LITERAL_SCALAR_STYLE:
1275	return yaml_emitter_write_literal_scalar(emitter,
1276	emitter->scalar_data.value, emitter->scalar_data.length);
1277
1278	case YAML_FOLDED_SCALAR_STYLE:
1279	return yaml_emitter_write_folded_scalar(emitter,
1280	emitter->scalar_data.value, emitter->scalar_data.length);
1281
1282	default:
1283	assert(1); /* Impossible. */
1284	}
1285
1286	return 0;
1287	}
1288
1289	/*
1290	* Check if a %YAML directive is valid.
1291	*/
1292
1293	static int
1294	yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
1295	yaml_version_directive_t version_directive)
1296	{
1297	if (version_directive.major != 1 \|\| version_directive.minor != 1) {
1298	return yaml_emitter_set_emitter_error(emitter,
1299	"incompatible %YAML directive");
1300	}
1301
1302	return 1;
1303	}
1304
1305	/*
1306	* Check if a %TAG directive is valid.
1307	*/
1308
1309	static int
1310	yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
1311	yaml_tag_directive_t tag_directive)
1312	{
1313	yaml_string_t handle = STRING(tag_directive.handle,
1314	strlen((char *)tag_directive.handle));
1315	yaml_string_t prefix = STRING(tag_directive.prefix,
1316	strlen((char *)tag_directive.prefix));
1317
1318	if (handle.start == handle.end) {
1319	return yaml_emitter_set_emitter_error(emitter,
1320	"tag handle must not be empty");
1321	}
1322
1323	if (handle.start[0] != '!') {
1324	return yaml_emitter_set_emitter_error(emitter,
1325	"tag handle must start with '!'");
1326	}
1327
1328	if (handle.end[-1] != '!') {
1329	return yaml_emitter_set_emitter_error(emitter,
1330	"tag handle must end with '!'");
1331	}
1332
1333	handle.pointer ++;
1334
1335	while (handle.pointer != handle.end-1) {
1336	if (!IS_ALPHA(handle)) {
1337	return yaml_emitter_set_emitter_error(emitter,
1338	"tag handle must contain alphanumerical characters only");
1339	}
1340	MOVE(handle);
1341	}
1342
1343	if (prefix.start == prefix.end) {
1344	return yaml_emitter_set_emitter_error(emitter,
1345	"tag prefix must not be empty");
1346	}
1347
1348	return 1;
1349	}
1350
1351	/*
1352	* Check if an anchor is valid.
1353	*/
1354
1355	static int
1356	yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
1357	yaml_char_t *anchor, int alias)
1358	{
1359	yaml_string_t string = STRING(anchor, strlen((char *)anchor));
1360
1361	if (string.start == string.end) {
1362	return yaml_emitter_set_emitter_error(emitter, alias ?
1363	"alias value must not be empty" :
1364	"anchor value must not be empty");
1365	}
1366
1367	while (string.pointer != string.end) {
1368	if (!IS_ALPHA(string)) {
1369	return yaml_emitter_set_emitter_error(emitter, alias ?
1370	"alias value must contain alphanumerical characters only" :
1371	"anchor value must contain alphanumerical characters only");
1372	}
1373	MOVE(string);
1374	}
1375	}
1376
1377	/*
1378	* Check if a tag is valid.
1379	*/
1380
1381	static int
1382	yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
1383	yaml_char_t *tag)
1384	{
1385	yaml_string_t string = STRING(tag, strlen((char *)tag));
1386	yaml_tag_directive_t *tag_directive;
1387
1388	if (string.start == string.end) {
1389	return yaml_emitter_set_emitter_error(emitter,
1390	"tag value must not be empty");
1391	}
1392
1393	for (tag_directive = emitter->tag_directives.start;
1394	tag_directive != emitter->tag_directives.end; tag_directive ++) {
1395	size_t prefix_length = strlen((char *)tag_directive->prefix);
1396	if (prefix_length < (string.end - string.start)
1397	&& strncmp((char )tag_directive->prefix, (char )string.start,
1398	prefix_length) == 0)
1399	{
1400	emitter->tag_data.handle = tag_directive->handle;
1401	emitter->tag_data.handle_length =
1402	strlen((char *)tag_directive->handle);
1403	emitter->tag_data.suffix = string.start + prefix_length;
1404	emitter->tag_data.suffix_length =
1405	(string.end - string.start) - prefix_length;
1406	return 1;
1407	}
1408	}
1409
1410	emitter->tag_data.suffix = string.start;
1411	emitter->tag_data.suffix_length = string.end - string.start;
1412
1413	return 1;
1414	}
1415
1416	/*
1417	* Check if a scalar is valid.
1418	*/
1419
1420	static int
1421	yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
1422	yaml_char_t *value, size_t length)
1423	{
1424	yaml_string_t string = STRING(value, length);
1425
1426	int block_indicators = 0;
1427	int flow_indicators = 0;
1428	int line_breaks = 0;
1429	int special_characters = 0;
1430
1431	int inline_spaces = 0;
1432	int inline_breaks = 0;
1433	int leading_spaces = 0;
1434	int leading_breaks = 0;
1435	int trailing_spaces = 0;
1436	int trailing_breaks = 0;
1437	int inline_breaks_spaces = 0;
1438	int mixed_breaks_spaces = 0;
1439
1440	int preceeded_by_space = 0;
1441	int followed_by_space = 0;
1442	int spaces = 0;
1443	int breaks = 0;
1444	int mixed = 0;
1445	int leading = 0;
1446
1447	emitter->scalar_data.value = value;
1448	emitter->scalar_data.length = length;
1449
1450	if (string.start == string.end)
1451	{
1452	emitter->scalar_data.multiline = 0;
1453	emitter->scalar_data.flow_plain_allowed = 0;
1454	emitter->scalar_data.block_plain_allowed = 1;
1455	emitter->scalar_data.single_quoted_allowed = 1;
1456	emitter->scalar_data.block_allowed = 0;
1457
1458	return 1;
1459	}
1460
1461	if ((CHECK_AT(string, '-', 0)
1462	&& CHECK_AT(string, '-', 1)
1463	&& CHECK_AT(string, '-', 2))
1464	\|\| (CHECK_AT(string, '.', 0)
1465	&& CHECK_AT(string, '.', 1)
1466	&& CHECK_AT(string, '.', 2))) {
1467	block_indicators = 1;
1468	flow_indicators = 1;
1469	}
1470
1471	preceeded_by_space = 1;
1472	followed_by_space = IS_BLANKZ_AT(string, WIDTH(string));
1473
1474	while (string.pointer != string.end)
1475	{
1476	if (string.start == string.pointer)
1477	{
1478	if (CHECK(string, '#') \|\| CHECK(string, ',')
1479	\|\| CHECK(string, '[') \|\| CHECK(string, ']')
1480	\|\| CHECK(string, '{') \|\| CHECK(string, '}')
1481	\|\| CHECK(string, '&') \|\| CHECK(string, '*')
1482	\|\| CHECK(string, '!') \|\| CHECK(string, '\|')
1483	\|\| CHECK(string, '>') \|\| CHECK(string, '\'')
1484	\|\| CHECK(string, '"') \|\| CHECK(string, '%')
1485	\|\| CHECK(string, '@') \|\| CHECK(string, '`')) {
1486	flow_indicators = 1;
1487	block_indicators = 1;
1488	}
1489
1490	if (CHECK(string, '?') \|\| CHECK(string, ':')) {
1491	flow_indicators = 1;
1492	if (followed_by_space) {
1493	block_indicators = 1;
1494	}
1495	}
1496
1497	if (CHECK(string, '-') && followed_by_space) {
1498	flow_indicators = 1;
1499	block_indicators = 1;
1500	}
1501	}
1502	else
1503	{
1504	if (CHECK(string, ',') \|\| CHECK(string, '?')
1505	\|\| CHECK(string, '[') \|\| CHECK(string, ']')
1506	\|\| CHECK(string, '{') \|\| CHECK(string, '}')) {
1507	flow_indicators = 1;
1508	}
1509
1510	if (CHECK(string, ':')) {
1511	flow_indicators = 1;
1512	if (followed_by_space) {
1513	block_indicators = 1;
1514	}
1515	}
1516
1517	if (CHECK(string, '#') && preceeded_by_space) {
1518	flow_indicators = 1;
1519	block_indicators = 1;
1520	}
1521	}
1522
1523	if (!IS_PRINTABLE(string)
1524	\|\| (!IS_ASCII(string) && !emitter->unicode)) {
1525	special_characters = 1;
1526	}
1527
1528	if (IS_BREAK(string)) {
1529	line_breaks = 1;
1530	}
1531
1532	if (IS_SPACE(string))
1533	{
1534	spaces = 1;
1535	if (string.start == string.pointer) {
1536	leading = 1;
1537	}
1538	}
1539
1540	else if (IS_BREAK(string))
1541	{
1542	if (spaces) {
1543	mixed = 1;
1544	}
1545	breaks = 1;
1546	if (string.start == string.pointer) {
1547	leading = 1;
1548	}
1549	}
1550
1551	else if (spaces \|\| breaks)
1552	{
1553	if (leading) {
1554	if (spaces && breaks) {
1555	mixed_breaks_spaces = 1;
1556	}
1557	else if (spaces) {
1558	leading_spaces = 1;
1559	}
1560	else if (breaks) {
1561	leading_breaks = 1;
1562	}
1563	}
1564	else {
1565	if (mixed) {
1566	mixed_breaks_spaces = 1;
1567	}
1568	else if (spaces && breaks) {
1569	inline_breaks_spaces = 1;
1570	}
1571	else if (spaces) {
1572	inline_spaces = 1;
1573	}
1574	else if (breaks) {
1575	inline_breaks = 1;
1576	}
1577	}
1578	spaces = breaks = mixed = leading = 0;
1579	}
1580
1581	preceeded_by_space = IS_BLANKZ(string);
1582	MOVE(string);
1583	if (string.pointer != string.end) {
1584	followed_by_space = IS_BLANKZ_AT(string, WIDTH(string));
1585	}
1586	}
1587
1588	emitter->scalar_data.multiline = line_breaks;
1589
1590	emitter->scalar_data.flow_plain_allowed = 1;
1591	emitter->scalar_data.block_plain_allowed = 1;
1592	emitter->scalar_data.single_quoted_allowed = 1;
1593	emitter->scalar_data.block_allowed = 1;
1594
1595	if (leading_spaces \|\| leading_breaks \|\| trailing_spaces) {
1596	emitter->scalar_data.flow_plain_allowed = 0;
1597	emitter->scalar_data.block_plain_allowed = 0;
1598	emitter->scalar_data.block_allowed = 0;
1599	}
1600
1601	if (trailing_breaks) {
1602	emitter->scalar_data.flow_plain_allowed = 0;
1603	emitter->scalar_data.block_plain_allowed = 0;
1604	}
1605
1606	if (inline_breaks_spaces) {
1607	emitter->scalar_data.flow_plain_allowed = 0;
1608	emitter->scalar_data.block_plain_allowed = 0;
1609	emitter->scalar_data.single_quoted_allowed = 0;
1610	}
1611
1612	if (mixed_breaks_spaces \|\| special_characters) {
1613	emitter->scalar_data.flow_plain_allowed = 0;
1614	emitter->scalar_data.block_plain_allowed = 0;
1615	emitter->scalar_data.single_quoted_allowed = 0;
1616	emitter->scalar_data.block_allowed = 0;
1617	}
1618
1619	if (line_breaks) {
1620	emitter->scalar_data.flow_plain_allowed = 0;
1621	emitter->scalar_data.block_plain_allowed = 0;
1622	}
1623
1624	if (flow_indicators) {
1625	emitter->scalar_data.flow_plain_allowed = 0;
1626	}
1627
1628	if (block_indicators) {
1629	emitter->scalar_data.block_plain_allowed = 0;
1630	}
1631
1632	return 1;
1633	}
1634
1635	/*
1636	* Check if the event data is valid.
1637	*/
1638
1639	static int
1640	yaml_emitter_analyze_event(yaml_emitter_t *emitter,
1641	yaml_event_t *event)
1642	{
1643	emitter->anchor_data.anchor = NULL;
1644	emitter->anchor_data.anchor_length = 0;
1645	emitter->tag_data.handle = NULL;
1646	emitter->tag_data.handle_length = 0;
1647	emitter->tag_data.suffix = NULL;
1648	emitter->tag_data.suffix_length = 0;
1649	emitter->scalar_data.value = NULL;
1650	emitter->scalar_data.length = 0;
1651
1652	switch (event->type)
1653	{
1654	case YAML_ALIAS_EVENT:
1655	if (!yaml_emitter_analyze_anchor(emitter,
1656	event->data.alias.anchor, 1))
1657	return 0;
1658	return 1;
1659
1660	case YAML_SCALAR_EVENT:
1661	if (event->data.scalar.anchor) {
1662	if (!yaml_emitter_analyze_anchor(emitter,
1663	event->data.scalar.anchor, 0))
1664	return 0;
1665	}
1666	if (event->data.scalar.tag && (emitter->canonical \|\|
1667	(!event->data.scalar.plain_implicit
1668	&& !event->data.scalar.quoted_implicit))) {
1669	if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag))
1670	return 0;
1671	}
1672	if (!yaml_emitter_analyze_scalar(emitter,
1673	event->data.scalar.value, event->data.scalar.length))
1674	return 0;
1675	return 1;
1676
1677	case YAML_SEQUENCE_START_EVENT:
1678	if (event->data.sequence_start.anchor) {
1679	if (!yaml_emitter_analyze_anchor(emitter,
1680	event->data.sequence_start.anchor, 0))
1681	return 0;
1682	}
1683	if (event->data.sequence_start.tag && (emitter->canonical \|\|
1684	!event->data.sequence_start.implicit)) {
1685	if (!yaml_emitter_analyze_tag(emitter,
1686	event->data.sequence_start.tag))
1687	return 0;
1688	}
1689	return 1;
1690
1691	case YAML_MAPPING_START_EVENT:
1692	if (event->data.mapping_start.anchor) {
1693	if (!yaml_emitter_analyze_anchor(emitter,
1694	event->data.mapping_start.anchor, 0))
1695	return 0;
1696	}
1697	if (event->data.mapping_start.tag && (emitter->canonical \|\|
1698	!event->data.mapping_start.implicit)) {
1699	if (!yaml_emitter_analyze_tag(emitter,
1700	event->data.mapping_start.tag))
1701	return 0;
1702	}
1703	return 1;
1704
1705	default:
1706	return 1;
1707	}
1708	}
1709
1710	/*
1711	* Write the BOM character.
1712	*/
1713
1714	static int
1715	yaml_emitter_write_bom(yaml_emitter_t *emitter)
1716	{
1717	if (!FLUSH(emitter)) return 0;
1718
1719	*(emitter->buffer.pointer++) = (yaml_char_t) '\xEF';
1720	*(emitter->buffer.pointer++) = (yaml_char_t) '\xBB';
1721	*(emitter->buffer.pointer++) = (yaml_char_t) '\xBF';
1722
1723	return 1;
1724	}
1725
1726	static int
1727	yaml_emitter_write_indent(yaml_emitter_t *emitter)
1728	{
1729	int indent = (emitter->indent >= 0) ? emitter->indent : 0;
1730
1731	if (!emitter->indention \|\| emitter->column > indent
1732	\|\| (emitter->column == indent && !emitter->whitespace)) {
1733	if (!PUT_BREAK(emitter)) return 0;
1734	}
1735
1736	while (emitter->column < indent) {
1737	if (!PUT(emitter, ' ')) return 0;
1738	}
1739
1740	emitter->whitespace = 1;
1741	emitter->indention = 1;
1742
1743	return 1;
1744	}
1745
1746	static int
1747	yaml_emitter_write_indicator(yaml_emitter_t *emitter,
1748	char *indicator, int need_whitespace,
1749	int is_whitespace, int is_indention)
1750	{
1751	yaml_string_t string = STRING((yaml_char_t *)indicator, strlen(indicator));
1752
1753	if (need_whitespace && !emitter->whitespace) {
1754	if (!PUT(emitter, ' ')) return 0;
1755	}
1756
1757	while (string.pointer != string.end) {
1758	if (!WRITE(emitter, string)) return 0;
1759	}
1760
1761	emitter->whitespace = is_whitespace;
1762	emitter->indention = (emitter->indention && is_indention);
1763
1764	return 1;
1765	}
1766
1767	static int
1768	yaml_emitter_write_anchor(yaml_emitter_t *emitter,
1769	yaml_char_t *value, size_t length)
1770	{
1771	yaml_string_t string = STRING(value, length);
1772
1773	while (string.pointer != string.end) {
1774	if (!WRITE(emitter, string)) return 0;
1775	}
1776
1777	emitter->whitespace = 0;
1778	emitter->indention = 0;
1779
1780	return 1;
1781	}
1782
1783	static int
1784	yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
1785	yaml_char_t *value, size_t length)
1786	{
1787	yaml_string_t string = STRING(value, length);
1788
1789	while (string.pointer != string.end) {
1790	if (!WRITE(emitter, string)) return 0;
1791	}
1792
1793	emitter->whitespace = 0;
1794	emitter->indention = 0;
1795
1796	return 1;
1797	}
1798
1799	static int
1800	yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
1801	yaml_char_t *value, size_t length)
1802	{
1803	return 0;
1804	}
1805
1806	static int
1807	yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
1808	yaml_char_t *value, size_t length, int allow_breaks)
1809	{
1810	return 0;
1811	}
1812
1813	static int
1814	yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
1815	yaml_char_t *value, size_t length, int allow_breaks)
1816	{
1817	return 0;
1818	}
1819
1820	static int
1821	yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
1822	yaml_char_t *value, size_t length, int allow_breaks)
1823	{
1824	return 0;
1825	}
1826
1827	static int
1828	yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
1829	yaml_char_t *value, size_t length)
1830	{
1831	return 0;
1832	}
1833
1834	static int
1835	yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
1836	yaml_char_t *value, size_t length)
1837	{
1838	return 0;
1839	}
1840

Note: See TracBrowser for help on using the repository browser.

Download in other formats: