git.iko.soy/typeable/yaml
on 64dfd86 help sign in
typeable/yaml/libyaml/api.c
1403 lines 37 kB history raw
2#include "yaml_private.h"
4/*
5 * Get the library version.
6 */
8/*
9 * added to support _WIN64
10 */
11#if _WIN64
12#define STRDUP _strdup
13#else
14#define STRDUP strdup
15#endif
17YAML_DECLARE(const char *)
18yaml_get_version_string(void)
20 return YAML_VERSION_STRING;
23/*
24 * Get the library version numbers.
25 */
27YAML_DECLARE(void)
28yaml_get_version(int *major, int *minor, int *patch)
30 *major = YAML_VERSION_MAJOR;
31 *minor = YAML_VERSION_MINOR;
32 *patch = YAML_VERSION_PATCH;
35/*
36 * Allocate a dynamic memory block.
37 */
39YAML_DECLARE(void *)
40yaml_malloc(size_t size)
42 return malloc(size ? size : 1);
45/*
46 * Reallocate a dynamic memory block.
47 */
49YAML_DECLARE(void *)
50yaml_realloc(void *ptr, size_t size)
52 return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
55/*
56 * Free a dynamic memory block.
57 */
59YAML_DECLARE(void)
60yaml_free(void *ptr)
62 if (ptr) free(ptr);
65/*
66 * Duplicate a string.
67 */
69YAML_DECLARE(yaml_char_t *)
70yaml_strdup(const yaml_char_t *str)
72 if (!str)
73 return NULL;
75 return (yaml_char_t *) STRDUP((char *)str);
78/*
79 * Extend a string.
80 */
82YAML_DECLARE(int)
83yaml_string_extend(yaml_char_t **start,
84 yaml_char_t **pointer, yaml_char_t **end)
86 yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2);
88 if (!new_start) return 0;
90 memset(new_start + (*end - *start), 0, *end - *start);
92 *pointer = new_start + (*pointer - *start);
93 *end = new_start + (*end - *start)*2;
94 *start = new_start;
96 return 1;
99/*
100 * Append a string B to a string A.
101 */
103YAML_DECLARE(int)
104yaml_string_join(
105 yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
106 yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end)
108 if (*b_start == *b_pointer)
109 return 1;
111 while (*a_end - *a_pointer <= *b_pointer - *b_start) {
112 if (!yaml_string_extend(a_start, a_pointer, a_end))
113 return 0;
114 }
116 memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
117 *a_pointer += *b_pointer - *b_start;
119 return 1;
122/*
123 * Extend a stack.
124 */
126YAML_DECLARE(int)
127yaml_stack_extend(void **start, void **top, void **end)
129 void *new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2);
131 if (!new_start) return 0;
133 *top = (char *)new_start + ((char *)*top - (char *)*start);
134 *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
135 *start = new_start;
137 return 1;
140/*
141 * Extend or move a queue.
142 */
144YAML_DECLARE(int)
145yaml_queue_extend(void **start, void **head, void **tail, void **end)
147 /* Check if we need to resize the queue. */
149 if (*start == *head && *tail == *end) {
150 void *new_start = yaml_realloc(*start,
151 ((char *)*end - (char *)*start)*2);
153 if (!new_start) return 0;
155 *head = (char *)new_start + ((char *)*head - (char *)*start);
156 *tail = (char *)new_start + ((char *)*tail - (char *)*start);
157 *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
158 *start = new_start;
159 }
161 /* Check if we need to move the queue at the beginning of the buffer. */
163 if (*tail == *end) {
164 if (*head != *tail) {
165 memmove(*start, *head, (char *)*tail - (char *)*head);
166 }
167 *tail = (char *)*tail - (char *)*head + (char *)*start;
168 *head = *start;
169 }
171 return 1;
175/*
176 * Create a new parser object.
177 */
179YAML_DECLARE(int)
180yaml_parser_initialize(yaml_parser_t *parser)
182 assert(parser); /* Non-NULL parser object expected. */
184 memset(parser, 0, sizeof(yaml_parser_t));
185 if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE))
186 goto error;
187 if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
188 goto error;
189 if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE))
190 goto error;
191 if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE))
192 goto error;
193 if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE))
194 goto error;
195 if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE))
196 goto error;
197 if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE))
198 goto error;
199 if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE))
200 goto error;
202 return 1;
204error:
206 BUFFER_DEL(parser, parser->raw_buffer);
207 BUFFER_DEL(parser, parser->buffer);
208 QUEUE_DEL(parser, parser->tokens);
209 STACK_DEL(parser, parser->indents);
210 STACK_DEL(parser, parser->simple_keys);
211 STACK_DEL(parser, parser->states);
212 STACK_DEL(parser, parser->marks);
213 STACK_DEL(parser, parser->tag_directives);
215 return 0;
218/*
219 * Destroy a parser object.
220 */
222YAML_DECLARE(void)
223yaml_parser_delete(yaml_parser_t *parser)
225 assert(parser); /* Non-NULL parser object expected. */
227 BUFFER_DEL(parser, parser->raw_buffer);
228 BUFFER_DEL(parser, parser->buffer);
229 while (!QUEUE_EMPTY(parser, parser->tokens)) {
230 yaml_token_delete(&DEQUEUE(parser, parser->tokens));
231 }
232 QUEUE_DEL(parser, parser->tokens);
233 STACK_DEL(parser, parser->indents);
234 STACK_DEL(parser, parser->simple_keys);
235 STACK_DEL(parser, parser->states);
236 STACK_DEL(parser, parser->marks);
237 while (!STACK_EMPTY(parser, parser->tag_directives)) {
238 yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
239 yaml_free(tag_directive.handle);
240 yaml_free(tag_directive.prefix);
241 }
242 STACK_DEL(parser, parser->tag_directives);
244 memset(parser, 0, sizeof(yaml_parser_t));
247/*
248 * String read handler.
249 */
251static int
252yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
253 size_t *size_read)
255 yaml_parser_t *parser = data;
257 if (parser->input.string.current == parser->input.string.end) {
258 *size_read = 0;
259 return 1;
260 }
262 if (size > (size_t)(parser->input.string.end
263 - parser->input.string.current)) {
264 size = parser->input.string.end - parser->input.string.current;
265 }
267 memcpy(buffer, parser->input.string.current, size);
268 parser->input.string.current += size;
269 *size_read = size;
270 return 1;
273/*
274 * File read handler.
275 */
277static int
278yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
279 size_t *size_read)
281 yaml_parser_t *parser = data;
283 *size_read = fread(buffer, 1, size, parser->input.file);
284 return !ferror(parser->input.file);
287/*
288 * Set a string input.
289 */
291YAML_DECLARE(void)
292yaml_parser_set_input_string(yaml_parser_t *parser,
293 const unsigned char *input, size_t size)
295 assert(parser); /* Non-NULL parser object expected. */
296 assert(!parser->read_handler); /* You can set the source only once. */
297 assert(input); /* Non-NULL input string expected. */
299 parser->read_handler = yaml_string_read_handler;
300 parser->read_handler_data = parser;
302 parser->input.string.start = input;
303 parser->input.string.current = input;
304 parser->input.string.end = input+size;
307/*
308 * Set a file input.
309 */
311YAML_DECLARE(void)
312yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
314 assert(parser); /* Non-NULL parser object expected. */
315 assert(!parser->read_handler); /* You can set the source only once. */
316 assert(file); /* Non-NULL file object expected. */
318 parser->read_handler = yaml_file_read_handler;
319 parser->read_handler_data = parser;
321 parser->input.file = file;
324/*
325 * Set a generic input.
326 */
328YAML_DECLARE(void)
329yaml_parser_set_input(yaml_parser_t *parser,
330 yaml_read_handler_t *handler, void *data)
332 assert(parser); /* Non-NULL parser object expected. */
333 assert(!parser->read_handler); /* You can set the source only once. */
334 assert(handler); /* Non-NULL read handler expected. */
336 parser->read_handler = handler;
337 parser->read_handler_data = data;
340/*
341 * Set the source encoding.
342 */
344YAML_DECLARE(void)
345yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
347 assert(parser); /* Non-NULL parser object expected. */
348 assert(!parser->encoding); /* Encoding is already set or detected. */
350 parser->encoding = encoding;
353/*
354 * Create a new emitter object.
355 */
357YAML_DECLARE(int)
358yaml_emitter_initialize(yaml_emitter_t *emitter)
360 assert(emitter); /* Non-NULL emitter object expected. */
362 memset(emitter, 0, sizeof(yaml_emitter_t));
363 if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE))
364 goto error;
365 if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
366 goto error;
367 if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE))
368 goto error;
369 if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE))
370 goto error;
371 if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE))
372 goto error;
373 if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE))
374 goto error;
376 return 1;
378error:
380 BUFFER_DEL(emitter, emitter->buffer);
381 BUFFER_DEL(emitter, emitter->raw_buffer);
382 STACK_DEL(emitter, emitter->states);
383 QUEUE_DEL(emitter, emitter->events);
384 STACK_DEL(emitter, emitter->indents);
385 STACK_DEL(emitter, emitter->tag_directives);
387 return 0;
390/*
391 * Destroy an emitter object.
392 */
394YAML_DECLARE(void)
395yaml_emitter_delete(yaml_emitter_t *emitter)
397 assert(emitter); /* Non-NULL emitter object expected. */
399 BUFFER_DEL(emitter, emitter->buffer);
400 BUFFER_DEL(emitter, emitter->raw_buffer);
401 STACK_DEL(emitter, emitter->states);
402 while (!QUEUE_EMPTY(emitter, emitter->events)) {
403 yaml_event_delete(&DEQUEUE(emitter, emitter->events));
404 }
405 QUEUE_DEL(emitter, emitter->events);
406 STACK_DEL(emitter, emitter->indents);
407 while (!STACK_EMPTY(empty, emitter->tag_directives)) {
408 yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
409 yaml_free(tag_directive.handle);
410 yaml_free(tag_directive.prefix);
411 }
412 STACK_DEL(emitter, emitter->tag_directives);
413 yaml_free(emitter->anchors);
415 memset(emitter, 0, sizeof(yaml_emitter_t));
418/*
419 * String write handler.
420 */
422static int
423yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
425 yaml_emitter_t *emitter = data;
427 if (emitter->output.string.size + *emitter->output.string.size_written
428 < size) {
429 memcpy(emitter->output.string.buffer
430 + *emitter->output.string.size_written,
431 buffer,
432 emitter->output.string.size
433 - *emitter->output.string.size_written);
434 *emitter->output.string.size_written = emitter->output.string.size;
435 return 0;
436 }
438 memcpy(emitter->output.string.buffer
439 + *emitter->output.string.size_written, buffer, size);
440 *emitter->output.string.size_written += size;
441 return 1;
444/*
445 * File write handler.
446 */
448static int
449yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
451 yaml_emitter_t *emitter = data;
453 return (fwrite(buffer, 1, size, emitter->output.file) == size);
455/*
456 * Set a string output.
457 */
459YAML_DECLARE(void)
460yaml_emitter_set_output_string(yaml_emitter_t *emitter,
461 unsigned char *output, size_t size, size_t *size_written)
463 assert(emitter); /* Non-NULL emitter object expected. */
464 assert(!emitter->write_handler); /* You can set the output only once. */
465 assert(output); /* Non-NULL output string expected. */
467 emitter->write_handler = yaml_string_write_handler;
468 emitter->write_handler_data = emitter;
470 emitter->output.string.buffer = output;
471 emitter->output.string.size = size;
472 emitter->output.string.size_written = size_written;
473 *size_written = 0;
476/*
477 * Set a file output.
478 */
480YAML_DECLARE(void)
481yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
483 assert(emitter); /* Non-NULL emitter object expected. */
484 assert(!emitter->write_handler); /* You can set the output only once. */
485 assert(file); /* Non-NULL file object expected. */
487 emitter->write_handler = yaml_file_write_handler;
488 emitter->write_handler_data = emitter;
490 emitter->output.file = file;
493/*
494 * Set a generic output handler.
495 */
497YAML_DECLARE(void)
498yaml_emitter_set_output(yaml_emitter_t *emitter,
499 yaml_write_handler_t *handler, void *data)
501 assert(emitter); /* Non-NULL emitter object expected. */
502 assert(!emitter->write_handler); /* You can set the output only once. */
503 assert(handler); /* Non-NULL handler object expected. */
505 emitter->write_handler = handler;
506 emitter->write_handler_data = data;
509/*
510 * Set the output encoding.
511 */
513YAML_DECLARE(void)
514yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding)
516 assert(emitter); /* Non-NULL emitter object expected. */
517 assert(!emitter->encoding); /* You can set encoding only once. */
519 emitter->encoding = encoding;
522/*
523 * Set the canonical output style.
524 */
526YAML_DECLARE(void)
527yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
529 assert(emitter); /* Non-NULL emitter object expected. */
531 emitter->canonical = (canonical != 0);
534/*
535 * Set the indentation increment.
536 */
538YAML_DECLARE(void)
539yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
541 assert(emitter); /* Non-NULL emitter object expected. */
543 emitter->best_indent = (1 < indent && indent < 10) ? indent : 2;
546/*
547 * Set the preferred line width.
548 */
550YAML_DECLARE(void)
551yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
553 assert(emitter); /* Non-NULL emitter object expected. */
555 emitter->best_width = (width >= 0) ? width : -1;
558/*
559 * Set if unescaped non-ASCII characters are allowed.
560 */
562YAML_DECLARE(void)
563yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
565 assert(emitter); /* Non-NULL emitter object expected. */
567 emitter->unicode = (unicode != 0);
570/*
571 * Set the preferred line break character.
572 */
574YAML_DECLARE(void)
575yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
577 assert(emitter); /* Non-NULL emitter object expected. */
579 emitter->line_break = line_break;
582/*
583 * Destroy a token object.
584 */
586YAML_DECLARE(void)
587yaml_token_delete(yaml_token_t *token)
589 assert(token); /* Non-NULL token object expected. */
591 switch (token->type)
592 {
593 case YAML_TAG_DIRECTIVE_TOKEN:
594 yaml_free(token->data.tag_directive.handle);
595 yaml_free(token->data.tag_directive.prefix);
596 break;
598 case YAML_ALIAS_TOKEN:
599 yaml_free(token->data.alias.value);
600 break;
602 case YAML_ANCHOR_TOKEN:
603 yaml_free(token->data.anchor.value);
604 break;
606 case YAML_TAG_TOKEN:
607 yaml_free(token->data.tag.handle);
608 yaml_free(token->data.tag.suffix);
609 break;
611 case YAML_SCALAR_TOKEN:
612 yaml_free(token->data.scalar.value);
613 break;
615 default:
616 break;
617 }
619 memset(token, 0, sizeof(yaml_token_t));
622/*
623 * Check if a string is a valid UTF-8 sequence.
624 *
625 * Check 'reader.c' for more details on UTF-8 encoding.
626 */
628static int
629yaml_check_utf8(yaml_char_t *start, size_t length)
631 yaml_char_t *end = start+length;
632 yaml_char_t *pointer = start;
634 while (pointer < end) {
635 unsigned char octet;
636 unsigned int width;
637 unsigned int value;
638 size_t k;
640 octet = pointer[0];
641 width = (octet & 0x80) == 0x00 ? 1 :
642 (octet & 0xE0) == 0xC0 ? 2 :
643 (octet & 0xF0) == 0xE0 ? 3 :
644 (octet & 0xF8) == 0xF0 ? 4 : 0;
645 value = (octet & 0x80) == 0x00 ? octet & 0x7F :
646 (octet & 0xE0) == 0xC0 ? octet & 0x1F :
647 (octet & 0xF0) == 0xE0 ? octet & 0x0F :
648 (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
649 if (!width) return 0;
650 if (pointer+width > end) return 0;
651 for (k = 1; k < width; k ++) {
652 octet = pointer[k];
653 if ((octet & 0xC0) != 0x80) return 0;
654 value = (value << 6) + (octet & 0x3F);
655 }
656 if (!((width == 1) ||
657 (width == 2 && value >= 0x80) ||
658 (width == 3 && value >= 0x800) ||
659 (width == 4 && value >= 0x10000))) return 0;
661 pointer += width;
662 }
664 return 1;
667/*
668 * Create STREAM-START.
669 */
671YAML_DECLARE(int)
672yaml_stream_start_event_initialize(yaml_event_t *event,
673 yaml_encoding_t encoding)
675 yaml_mark_t mark = { 0, 0, 0 };
677 assert(event); /* Non-NULL event object is expected. */
679 STREAM_START_EVENT_INIT(*event, encoding, mark, mark);
681 return 1;
684/*
685 * Create STREAM-END.
686 */
688YAML_DECLARE(int)
689yaml_stream_end_event_initialize(yaml_event_t *event)
691 yaml_mark_t mark = { 0, 0, 0 };
693 assert(event); /* Non-NULL event object is expected. */
695 STREAM_END_EVENT_INIT(*event, mark, mark);
697 return 1;
700/*
701 * Create DOCUMENT-START.
702 */
704YAML_DECLARE(int)
705yaml_document_start_event_initialize(yaml_event_t *event,
706 yaml_version_directive_t *version_directive,
707 yaml_tag_directive_t *tag_directives_start,
708 yaml_tag_directive_t *tag_directives_end,
709 int implicit)
711 struct {
712 yaml_error_type_t error;
713 } context;
714 yaml_mark_t mark = { 0, 0, 0 };
715 yaml_version_directive_t *version_directive_copy = NULL;
716 struct {
717 yaml_tag_directive_t *start;
718 yaml_tag_directive_t *end;
719 yaml_tag_directive_t *top;
720 } tag_directives_copy = { NULL, NULL, NULL };
721 yaml_tag_directive_t value = { NULL, NULL };
723 assert(event); /* Non-NULL event object is expected. */
724 assert((tag_directives_start && tag_directives_end) ||
725 (tag_directives_start == tag_directives_end));
726 /* Valid tag directives are expected. */
728 if (version_directive) {
729 version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
730 if (!version_directive_copy) goto error;
731 version_directive_copy->major = version_directive->major;
732 version_directive_copy->minor = version_directive->minor;
733 }
735 if (tag_directives_start != tag_directives_end) {
736 yaml_tag_directive_t *tag_directive;
737 if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
738 goto error;
739 for (tag_directive = tag_directives_start;
740 tag_directive != tag_directives_end; tag_directive ++) {
741 assert(tag_directive->handle);
742 assert(tag_directive->prefix);
743 if (!yaml_check_utf8(tag_directive->handle,
744 strlen((char *)tag_directive->handle)))
745 goto error;
746 if (!yaml_check_utf8(tag_directive->prefix,
747 strlen((char *)tag_directive->prefix)))
748 goto error;
749 value.handle = yaml_strdup(tag_directive->handle);
750 value.prefix = yaml_strdup(tag_directive->prefix);
751 if (!value.handle || !value.prefix) goto error;
752 if (!PUSH(&context, tag_directives_copy, value))
753 goto error;
754 value.handle = NULL;
755 value.prefix = NULL;
756 }
757 }
759 DOCUMENT_START_EVENT_INIT(*event, version_directive_copy,
760 tag_directives_copy.start, tag_directives_copy.top,
761 implicit, mark, mark);
763 return 1;
765error:
766 yaml_free(version_directive_copy);
767 while (!STACK_EMPTY(context, tag_directives_copy)) {
768 yaml_tag_directive_t value = POP(context, tag_directives_copy);
769 yaml_free(value.handle);
770 yaml_free(value.prefix);
771 }
772 STACK_DEL(context, tag_directives_copy);
773 yaml_free(value.handle);
774 yaml_free(value.prefix);
776 return 0;
779/*
780 * Create DOCUMENT-END.
781 */
783YAML_DECLARE(int)
784yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
786 yaml_mark_t mark = { 0, 0, 0 };
788 assert(event); /* Non-NULL emitter object is expected. */
790 DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark);
792 return 1;
795/*
796 * Create ALIAS.
797 */
799YAML_DECLARE(int)
800yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
802 yaml_mark_t mark = { 0, 0, 0 };
803 yaml_char_t *anchor_copy = NULL;
805 assert(event); /* Non-NULL event object is expected. */
806 assert(anchor); /* Non-NULL anchor is expected. */
808 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;
810 anchor_copy = yaml_strdup(anchor);
811 if (!anchor_copy)
812 return 0;
814 ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);
816 return 1;
819/*
820 * Create SCALAR.
821 */
823YAML_DECLARE(int)
824yaml_scalar_event_initialize(yaml_event_t *event,
825 yaml_char_t *anchor, yaml_char_t *tag,
826 yaml_char_t *value, int length,
827 int plain_implicit, int quoted_implicit,
828 yaml_scalar_style_t style)
830 yaml_mark_t mark = { 0, 0, 0 };
831 yaml_char_t *anchor_copy = NULL;
832 yaml_char_t *tag_copy = NULL;
833 yaml_char_t *value_copy = NULL;
835 assert(event); /* Non-NULL event object is expected. */
836 /* following line added for Haskell yaml library */
837 if (!value && !length) value = "";
838 assert(value); /* Non-NULL anchor is expected. */
840 if (anchor) {
841 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
842 anchor_copy = yaml_strdup(anchor);
843 if (!anchor_copy) goto error;
844 }
846 if (tag) {
847 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
848 tag_copy = yaml_strdup(tag);
849 if (!tag_copy) goto error;
850 }
852 if (length < 0) {
853 length = strlen((char *)value);
854 }
856 if (!yaml_check_utf8(value, length)) goto error;
857 value_copy = yaml_malloc(length+1);
858 if (!value_copy) goto error;
859 memcpy(value_copy, value, length);
860 value_copy[length] = '\0';
862 SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length,
863 plain_implicit, quoted_implicit, style, mark, mark);
865 return 1;
867error:
868 yaml_free(anchor_copy);
869 yaml_free(tag_copy);
870 yaml_free(value_copy);
872 return 0;
875/*
876 * Create SEQUENCE-START.
877 */
879YAML_DECLARE(int)
880yaml_sequence_start_event_initialize(yaml_event_t *event,
881 yaml_char_t *anchor, yaml_char_t *tag, int implicit,
882 yaml_sequence_style_t style)
884 yaml_mark_t mark = { 0, 0, 0 };
885 yaml_char_t *anchor_copy = NULL;
886 yaml_char_t *tag_copy = NULL;
888 assert(event); /* Non-NULL event object is expected. */
890 if (anchor) {
891 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
892 anchor_copy = yaml_strdup(anchor);
893 if (!anchor_copy) goto error;
894 }
896 if (tag) {
897 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
898 tag_copy = yaml_strdup(tag);
899 if (!tag_copy) goto error;
900 }
902 SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy,
903 implicit, style, mark, mark);
905 return 1;
907error:
908 yaml_free(anchor_copy);
909 yaml_free(tag_copy);
911 return 0;
914/*
915 * Create SEQUENCE-END.
916 */
918YAML_DECLARE(int)
919yaml_sequence_end_event_initialize(yaml_event_t *event)
921 yaml_mark_t mark = { 0, 0, 0 };
923 assert(event); /* Non-NULL event object is expected. */
925 SEQUENCE_END_EVENT_INIT(*event, mark, mark);
927 return 1;
930/*
931 * Create MAPPING-START.
932 */
934YAML_DECLARE(int)
935yaml_mapping_start_event_initialize(yaml_event_t *event,
936 yaml_char_t *anchor, yaml_char_t *tag, int implicit,
937 yaml_mapping_style_t style)
939 yaml_mark_t mark = { 0, 0, 0 };
940 yaml_char_t *anchor_copy = NULL;
941 yaml_char_t *tag_copy = NULL;
943 assert(event); /* Non-NULL event object is expected. */
945 if (anchor) {
946 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
947 anchor_copy = yaml_strdup(anchor);
948 if (!anchor_copy) goto error;
949 }
951 if (tag) {
952 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
953 tag_copy = yaml_strdup(tag);
954 if (!tag_copy) goto error;
955 }
957 MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy,
958 implicit, style, mark, mark);
960 return 1;
962error:
963 yaml_free(anchor_copy);
964 yaml_free(tag_copy);
966 return 0;
969/*
970 * Create MAPPING-END.
971 */
973YAML_DECLARE(int)
974yaml_mapping_end_event_initialize(yaml_event_t *event)
976 yaml_mark_t mark = { 0, 0, 0 };
978 assert(event); /* Non-NULL event object is expected. */
980 MAPPING_END_EVENT_INIT(*event, mark, mark);
982 return 1;
985/*
986 * Destroy an event object.
987 */
989YAML_DECLARE(void)
990yaml_event_delete(yaml_event_t *event)
992 yaml_tag_directive_t *tag_directive;
994 assert(event); /* Non-NULL event object expected. */
996 switch (event->type)
997 {
998 case YAML_DOCUMENT_START_EVENT:
999 yaml_free(event->data.document_start.version_directive);
1000 for (tag_directive = event->data.document_start.tag_directives.start;
1001 tag_directive != event->data.document_start.tag_directives.end;
1002 tag_directive++) {
1003 yaml_free(tag_directive->handle);
1004 yaml_free(tag_directive->prefix);
1006 yaml_free(event->data.document_start.tag_directives.start);
1007 break;
1009 case YAML_ALIAS_EVENT:
1010 yaml_free(event->data.alias.anchor);
1011 break;
1013 case YAML_SCALAR_EVENT:
1014 yaml_free(event->data.scalar.anchor);
1015 yaml_free(event->data.scalar.tag);
1016 yaml_free(event->data.scalar.value);
1017 break;
1019 case YAML_SEQUENCE_START_EVENT:
1020 yaml_free(event->data.sequence_start.anchor);
1021 yaml_free(event->data.sequence_start.tag);
1022 break;
1024 case YAML_MAPPING_START_EVENT:
1025 yaml_free(event->data.mapping_start.anchor);
1026 yaml_free(event->data.mapping_start.tag);
1027 break;
1029 default:
1030 break;
1033 memset(event, 0, sizeof(yaml_event_t));
1037 * Create a document object.
1038 */
1040YAML_DECLARE(int)
1041yaml_document_initialize(yaml_document_t *document,
1042 yaml_version_directive_t *version_directive,
1043 yaml_tag_directive_t *tag_directives_start,
1044 yaml_tag_directive_t *tag_directives_end,
1045 int start_implicit, int end_implicit)
1047 struct {
1048 yaml_error_type_t error;
1049 } context;
1050 struct {
1051 yaml_node_t *start;
1052 yaml_node_t *end;
1053 yaml_node_t *top;
1054 } nodes = { NULL, NULL, NULL };
1055 yaml_version_directive_t *version_directive_copy = NULL;
1056 struct {
1057 yaml_tag_directive_t *start;
1058 yaml_tag_directive_t *end;
1059 yaml_tag_directive_t *top;
1060 } tag_directives_copy = { NULL, NULL, NULL };
1061 yaml_tag_directive_t value = { NULL, NULL };
1062 yaml_mark_t mark = { 0, 0, 0 };
1064 assert(document); /* Non-NULL document object is expected. */
1065 assert((tag_directives_start && tag_directives_end) ||
1066 (tag_directives_start == tag_directives_end));
1067 /* Valid tag directives are expected. */
1069 if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error;
1071 if (version_directive) {
1072 version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
1073 if (!version_directive_copy) goto error;
1074 version_directive_copy->major = version_directive->major;
1075 version_directive_copy->minor = version_directive->minor;
1078 if (tag_directives_start != tag_directives_end) {
1079 yaml_tag_directive_t *tag_directive;
1080 if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
1081 goto error;
1082 for (tag_directive = tag_directives_start;
1083 tag_directive != tag_directives_end; tag_directive ++) {
1084 assert(tag_directive->handle);
1085 assert(tag_directive->prefix);
1086 if (!yaml_check_utf8(tag_directive->handle,
1087 strlen((char *)tag_directive->handle)))
1088 goto error;
1089 if (!yaml_check_utf8(tag_directive->prefix,
1090 strlen((char *)tag_directive->prefix)))
1091 goto error;
1092 value.handle = yaml_strdup(tag_directive->handle);
1093 value.prefix = yaml_strdup(tag_directive->prefix);
1094 if (!value.handle || !value.prefix) goto error;
1095 if (!PUSH(&context, tag_directives_copy, value))
1096 goto error;
1097 value.handle = NULL;
1098 value.prefix = NULL;
1102 DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
1103 tag_directives_copy.start, tag_directives_copy.top,
1104 start_implicit, end_implicit, mark, mark);
1106 return 1;
1108error:
1109 STACK_DEL(&context, nodes);
1110 yaml_free(version_directive_copy);
1111 while (!STACK_EMPTY(&context, tag_directives_copy)) {
1112 yaml_tag_directive_t value = POP(&context, tag_directives_copy);
1113 yaml_free(value.handle);
1114 yaml_free(value.prefix);
1116 STACK_DEL(&context, tag_directives_copy);
1117 yaml_free(value.handle);
1118 yaml_free(value.prefix);
1120 return 0;
1124 * Destroy a document object.
1125 */
1127YAML_DECLARE(void)
1128yaml_document_delete(yaml_document_t *document)
1130 struct {
1131 yaml_error_type_t error;
1132 } context;
1133 yaml_tag_directive_t *tag_directive;
1135 context.error = YAML_NO_ERROR; /* Eliminate a compliler warning. */
1137 assert(document); /* Non-NULL document object is expected. */
1139 while (!STACK_EMPTY(&context, document->nodes)) {
1140 yaml_node_t node = POP(&context, document->nodes);
1141 yaml_free(node.tag);
1142 switch (node.type) {
1143 case YAML_SCALAR_NODE:
1144 yaml_free(node.data.scalar.value);
1145 break;
1146 case YAML_SEQUENCE_NODE:
1147 STACK_DEL(&context, node.data.sequence.items);
1148 break;
1149 case YAML_MAPPING_NODE:
1150 STACK_DEL(&context, node.data.mapping.pairs);
1151 break;
1152 default:
1153 assert(0); /* Should not happen. */
1156 STACK_DEL(&context, document->nodes);
1158 yaml_free(document->version_directive);
1159 for (tag_directive = document->tag_directives.start;
1160 tag_directive != document->tag_directives.end;
1161 tag_directive++) {
1162 yaml_free(tag_directive->handle);
1163 yaml_free(tag_directive->prefix);
1165 yaml_free(document->tag_directives.start);
1167 memset(document, 0, sizeof(yaml_document_t));
1170/**
1171 * Get a document node.
1172 */
1174YAML_DECLARE(yaml_node_t *)
1175yaml_document_get_node(yaml_document_t *document, int index)
1177 assert(document); /* Non-NULL document object is expected. */
1179 if (index > 0 && document->nodes.start + index <= document->nodes.top) {
1180 return document->nodes.start + index - 1;
1182 return NULL;
1185/**
1186 * Get the root object.
1187 */
1189YAML_DECLARE(yaml_node_t *)
1190yaml_document_get_root_node(yaml_document_t *document)
1192 assert(document); /* Non-NULL document object is expected. */
1194 if (document->nodes.top != document->nodes.start) {
1195 return document->nodes.start;
1197 return NULL;
1201 * Add a scalar node to a document.
1202 */
1204YAML_DECLARE(int)
1205yaml_document_add_scalar(yaml_document_t *document,
1206 yaml_char_t *tag, yaml_char_t *value, int length,
1207 yaml_scalar_style_t style)
1209 struct {
1210 yaml_error_type_t error;
1211 } context;
1212 yaml_mark_t mark = { 0, 0, 0 };
1213 yaml_char_t *tag_copy = NULL;
1214 yaml_char_t *value_copy = NULL;
1215 yaml_node_t node;
1217 assert(document); /* Non-NULL document object is expected. */
1218 assert(value); /* Non-NULL value is expected. */
1220 if (!tag) {
1221 tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG;
1224 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1225 tag_copy = yaml_strdup(tag);
1226 if (!tag_copy) goto error;
1228 if (length < 0) {
1229 length = strlen((char *)value);
1232 if (!yaml_check_utf8(value, length)) goto error;
1233 value_copy = yaml_malloc(length+1);
1234 if (!value_copy) goto error;
1235 memcpy(value_copy, value, length);
1236 value_copy[length] = '\0';
1238 SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark);
1239 if (!PUSH(&context, document->nodes, node)) goto error;
1241 return document->nodes.top - document->nodes.start;
1243error:
1244 yaml_free(tag_copy);
1245 yaml_free(value_copy);
1247 return 0;
1251 * Add a sequence node to a document.
1252 */
1254YAML_DECLARE(int)
1255yaml_document_add_sequence(yaml_document_t *document,
1256 yaml_char_t *tag, yaml_sequence_style_t style)
1258 struct {
1259 yaml_error_type_t error;
1260 } context;
1261 yaml_mark_t mark = { 0, 0, 0 };
1262 yaml_char_t *tag_copy = NULL;
1263 struct {
1264 yaml_node_item_t *start;
1265 yaml_node_item_t *end;
1266 yaml_node_item_t *top;
1267 } items = { NULL, NULL, NULL };
1268 yaml_node_t node;
1270 assert(document); /* Non-NULL document object is expected. */
1272 if (!tag) {
1273 tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG;
1276 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1277 tag_copy = yaml_strdup(tag);
1278 if (!tag_copy) goto error;
1280 if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error;
1282 SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
1283 style, mark, mark);
1284 if (!PUSH(&context, document->nodes, node)) goto error;
1286 return document->nodes.top - document->nodes.start;
1288error:
1289 STACK_DEL(&context, items);
1290 yaml_free(tag_copy);
1292 return 0;
1296 * Add a mapping node to a document.
1297 */
1299YAML_DECLARE(int)
1300yaml_document_add_mapping(yaml_document_t *document,
1301 yaml_char_t *tag, yaml_mapping_style_t style)
1303 struct {
1304 yaml_error_type_t error;
1305 } context;
1306 yaml_mark_t mark = { 0, 0, 0 };
1307 yaml_char_t *tag_copy = NULL;
1308 struct {
1309 yaml_node_pair_t *start;
1310 yaml_node_pair_t *end;
1311 yaml_node_pair_t *top;
1312 } pairs = { NULL, NULL, NULL };
1313 yaml_node_t node;
1315 assert(document); /* Non-NULL document object is expected. */
1317 if (!tag) {
1318 tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG;
1321 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1322 tag_copy = yaml_strdup(tag);
1323 if (!tag_copy) goto error;
1325 if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error;
1327 MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
1328 style, mark, mark);
1329 if (!PUSH(&context, document->nodes, node)) goto error;
1331 return document->nodes.top - document->nodes.start;
1333error:
1334 STACK_DEL(&context, pairs);
1335 yaml_free(tag_copy);
1337 return 0;
1341 * Append an item to a sequence node.
1342 */
1344YAML_DECLARE(int)
1345yaml_document_append_sequence_item(yaml_document_t *document,
1346 int sequence, int item)
1348 struct {
1349 yaml_error_type_t error;
1350 } context;
1352 assert(document); /* Non-NULL document is required. */
1353 assert(sequence > 0
1354 && document->nodes.start + sequence <= document->nodes.top);
1355 /* Valid sequence id is required. */
1356 assert(document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE);
1357 /* A sequence node is required. */
1358 assert(item > 0 && document->nodes.start + item <= document->nodes.top);
1359 /* Valid item id is required. */
1361 if (!PUSH(&context,
1362 document->nodes.start[sequence-1].data.sequence.items, item))
1363 return 0;
1365 return 1;
1369 * Append a pair of a key and a value to a mapping node.
1370 */
1372YAML_DECLARE(int)
1373yaml_document_append_mapping_pair(yaml_document_t *document,
1374 int mapping, int key, int value)
1376 struct {
1377 yaml_error_type_t error;
1378 } context;
1380 yaml_node_pair_t pair;
1382 assert(document); /* Non-NULL document is required. */
1383 assert(mapping > 0
1384 && document->nodes.start + mapping <= document->nodes.top);
1385 /* Valid mapping id is required. */
1386 assert(document->nodes.start[mapping-1].type == YAML_MAPPING_NODE);
1387 /* A mapping node is required. */
1388 assert(key > 0 && document->nodes.start + key <= document->nodes.top);
1389 /* Valid key id is required. */
1390 assert(value > 0 && document->nodes.start + value <= document->nodes.top);
1391 /* Valid value id is required. */
1393 pair.key = key;
1394 pair.value = value;
1396 if (!PUSH(&context,
1397 document->nodes.start[mapping-1].data.mapping.pairs, pair))
1398 return 0;
1400 return 1;