2 #include "yaml_private.h"
5 * Get the library version.
8 YAML_DECLARE(const char *)
9 yaml_get_version_string(void)
11 return YAML_VERSION_STRING;
15 * Get the library version numbers.
19 yaml_get_version(int *major, int *minor, int *patch)
21 *major = YAML_VERSION_MAJOR;
22 *minor = YAML_VERSION_MINOR;
23 *patch = YAML_VERSION_PATCH;
27 * Allocate a dynamic memory block.
31 yaml_malloc(size_t size)
33 return malloc(size ? size : 1);
37 * Reallocate a dynamic memory block.
41 yaml_realloc(void *ptr, size_t size)
43 return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
47 * Free a dynamic memory block.
60 YAML_DECLARE(yaml_char_t *)
61 yaml_strdup(const yaml_char_t *str)
66 return (yaml_char_t *)strdup((char *)str);
74 yaml_string_extend(yaml_char_t **start,
75 yaml_char_t **pointer, yaml_char_t **end)
77 yaml_char_t *new_start = (yaml_char_t *)yaml_realloc((void*)*start, (*end - *start)*2);
79 if (!new_start) return 0;
81 memset(new_start + (*end - *start), 0, *end - *start);
83 *pointer = new_start + (*pointer - *start);
84 *end = new_start + (*end - *start)*2;
91 * Append a string B to a string A.
96 yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
97 yaml_char_t **b_start, yaml_char_t **b_pointer, SHIM(yaml_char_t **b_end))
100 if (*b_start == *b_pointer)
103 while (*a_end - *a_pointer <= *b_pointer - *b_start) {
104 if (!yaml_string_extend(a_start, a_pointer, a_end))
108 memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
109 *a_pointer += *b_pointer - *b_start;
119 yaml_stack_extend(void **start, void **top, void **end)
123 if ((char *)*end - (char *)*start >= INT_MAX / 2)
126 new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2);
128 if (!new_start) return 0;
130 *top = (char *)new_start + ((char *)*top - (char *)*start);
131 *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
138 * Extend or move a queue.
142 yaml_queue_extend(void **start, void **head, void **tail, void **end)
144 /* Check if we need to resize the queue. */
146 if (*start == *head && *tail == *end) {
147 void *new_start = yaml_realloc(*start,
148 ((char *)*end - (char *)*start)*2);
150 if (!new_start) return 0;
152 *head = (char *)new_start + ((char *)*head - (char *)*start);
153 *tail = (char *)new_start + ((char *)*tail - (char *)*start);
154 *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
158 /* Check if we need to move the queue at the beginning of the buffer. */
161 if (*head != *tail) {
162 memmove(*start, *head, (char *)*tail - (char *)*head);
164 *tail = (char *)*tail - (char *)*head + (char *)*start;
173 * Create a new parser object.
177 yaml_parser_initialize(yaml_parser_t *parser)
179 assert(parser); /* Non-NULL parser object expected. */
181 memset(parser, 0, sizeof(yaml_parser_t));
182 if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE))
184 if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
186 if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE, yaml_token_t*))
188 if (!STACK_INIT(parser, parser->indents, int*))
190 if (!STACK_INIT(parser, parser->simple_keys, yaml_simple_key_t*))
192 if (!STACK_INIT(parser, parser->states, yaml_parser_state_t*))
194 if (!STACK_INIT(parser, parser->marks, yaml_mark_t*))
196 if (!STACK_INIT(parser, parser->tag_directives, yaml_tag_directive_t*))
203 BUFFER_DEL(parser, parser->raw_buffer);
204 BUFFER_DEL(parser, parser->buffer);
205 QUEUE_DEL(parser, parser->tokens);
206 STACK_DEL(parser, parser->indents);
207 STACK_DEL(parser, parser->simple_keys);
208 STACK_DEL(parser, parser->states);
209 STACK_DEL(parser, parser->marks);
210 STACK_DEL(parser, parser->tag_directives);
216 * Destroy a parser object.
220 yaml_parser_delete(yaml_parser_t *parser)
222 assert(parser); /* Non-NULL parser object expected. */
224 BUFFER_DEL(parser, parser->raw_buffer);
225 BUFFER_DEL(parser, parser->buffer);
226 while (!QUEUE_EMPTY(parser, parser->tokens)) {
227 yaml_token_delete(&DEQUEUE(parser, parser->tokens));
229 QUEUE_DEL(parser, parser->tokens);
230 STACK_DEL(parser, parser->indents);
231 STACK_DEL(parser, parser->simple_keys);
232 STACK_DEL(parser, parser->states);
233 STACK_DEL(parser, parser->marks);
234 while (!STACK_EMPTY(parser, parser->tag_directives)) {
235 yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
236 yaml_free(tag_directive.handle);
237 yaml_free(tag_directive.prefix);
239 STACK_DEL(parser, parser->tag_directives);
241 memset(parser, 0, sizeof(yaml_parser_t));
245 * String read handler.
249 yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
252 yaml_parser_t *parser = (yaml_parser_t *)data;
254 if (parser->input.string.current == parser->input.string.end) {
259 if (size > (size_t)(parser->input.string.end
260 - parser->input.string.current)) {
261 size = parser->input.string.end - parser->input.string.current;
264 memcpy(buffer, parser->input.string.current, size);
265 parser->input.string.current += size;
275 yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
278 yaml_parser_t *parser = (yaml_parser_t *)data;
280 *size_read = fread(buffer, 1, size, parser->input.file);
281 return !ferror(parser->input.file);
285 * Set a string input.
289 yaml_parser_set_input_string(yaml_parser_t *parser,
290 const unsigned char *input, size_t size)
292 assert(parser); /* Non-NULL parser object expected. */
293 assert(!parser->read_handler); /* You can set the source only once. */
294 assert(input); /* Non-NULL input string expected. */
296 parser->read_handler = yaml_string_read_handler;
297 parser->read_handler_data = parser;
299 parser->input.string.start = input;
300 parser->input.string.current = input;
301 parser->input.string.end = input+size;
309 yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
311 assert(parser); /* Non-NULL parser object expected. */
312 assert(!parser->read_handler); /* You can set the source only once. */
313 assert(file); /* Non-NULL file object expected. */
315 parser->read_handler = yaml_file_read_handler;
316 parser->read_handler_data = parser;
318 parser->input.file = file;
322 * Set a generic input.
326 yaml_parser_set_input(yaml_parser_t *parser,
327 yaml_read_handler_t *handler, void *data)
329 assert(parser); /* Non-NULL parser object expected. */
330 assert(!parser->read_handler); /* You can set the source only once. */
331 assert(handler); /* Non-NULL read handler expected. */
333 parser->read_handler = handler;
334 parser->read_handler_data = data;
338 * Set the source encoding.
342 yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
344 assert(parser); /* Non-NULL parser object expected. */
345 assert(!parser->encoding); /* Encoding is already set or detected. */
347 parser->encoding = encoding;
351 * Create a new emitter object.
355 yaml_emitter_initialize(yaml_emitter_t *emitter)
357 assert(emitter); /* Non-NULL emitter object expected. */
359 memset(emitter, 0, sizeof(yaml_emitter_t));
360 if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE))
362 if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
364 if (!STACK_INIT(emitter, emitter->states, yaml_emitter_state_t*))
366 if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE, yaml_event_t*))
368 if (!STACK_INIT(emitter, emitter->indents, int*))
370 if (!STACK_INIT(emitter, emitter->tag_directives, yaml_tag_directive_t*))
377 BUFFER_DEL(emitter, emitter->buffer);
378 BUFFER_DEL(emitter, emitter->raw_buffer);
379 STACK_DEL(emitter, emitter->states);
380 QUEUE_DEL(emitter, emitter->events);
381 STACK_DEL(emitter, emitter->indents);
382 STACK_DEL(emitter, emitter->tag_directives);
388 * Destroy an emitter object.
392 yaml_emitter_delete(yaml_emitter_t *emitter)
394 assert(emitter); /* Non-NULL emitter object expected. */
396 BUFFER_DEL(emitter, emitter->buffer);
397 BUFFER_DEL(emitter, emitter->raw_buffer);
398 STACK_DEL(emitter, emitter->states);
399 while (!QUEUE_EMPTY(emitter, emitter->events)) {
400 yaml_event_delete(&DEQUEUE(emitter, emitter->events));
402 QUEUE_DEL(emitter, emitter->events);
403 STACK_DEL(emitter, emitter->indents);
404 while (!STACK_EMPTY(empty, emitter->tag_directives)) {
405 yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
406 yaml_free(tag_directive.handle);
407 yaml_free(tag_directive.prefix);
409 STACK_DEL(emitter, emitter->tag_directives);
410 yaml_free(emitter->anchors);
412 memset(emitter, 0, sizeof(yaml_emitter_t));
416 * String write handler.
420 yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
422 yaml_emitter_t *emitter = (yaml_emitter_t *)data;
424 if (emitter->output.string.size - *emitter->output.string.size_written
426 memcpy(emitter->output.string.buffer
427 + *emitter->output.string.size_written,
429 emitter->output.string.size
430 - *emitter->output.string.size_written);
431 *emitter->output.string.size_written = emitter->output.string.size;
435 memcpy(emitter->output.string.buffer
436 + *emitter->output.string.size_written, buffer, size);
437 *emitter->output.string.size_written += size;
442 * File write handler.
446 yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
448 yaml_emitter_t *emitter = (yaml_emitter_t *)data;
450 return (fwrite(buffer, 1, size, emitter->output.file) == size);
453 * Set a string output.
457 yaml_emitter_set_output_string(yaml_emitter_t *emitter,
458 unsigned char *output, size_t size, size_t *size_written)
460 assert(emitter); /* Non-NULL emitter object expected. */
461 assert(!emitter->write_handler); /* You can set the output only once. */
462 assert(output); /* Non-NULL output string expected. */
464 emitter->write_handler = yaml_string_write_handler;
465 emitter->write_handler_data = emitter;
467 emitter->output.string.buffer = output;
468 emitter->output.string.size = size;
469 emitter->output.string.size_written = size_written;
478 yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
480 assert(emitter); /* Non-NULL emitter object expected. */
481 assert(!emitter->write_handler); /* You can set the output only once. */
482 assert(file); /* Non-NULL file object expected. */
484 emitter->write_handler = yaml_file_write_handler;
485 emitter->write_handler_data = emitter;
487 emitter->output.file = file;
491 * Set a generic output handler.
495 yaml_emitter_set_output(yaml_emitter_t *emitter,
496 yaml_write_handler_t *handler, void *data)
498 assert(emitter); /* Non-NULL emitter object expected. */
499 assert(!emitter->write_handler); /* You can set the output only once. */
500 assert(handler); /* Non-NULL handler object expected. */
502 emitter->write_handler = handler;
503 emitter->write_handler_data = data;
507 * Set the output encoding.
511 yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding)
513 assert(emitter); /* Non-NULL emitter object expected. */
514 assert(!emitter->encoding); /* You can set encoding only once. */
516 emitter->encoding = encoding;
520 * Set the canonical output style.
524 yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
526 assert(emitter); /* Non-NULL emitter object expected. */
528 emitter->canonical = (canonical != 0);
532 * Set the indentation increment.
536 yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
538 assert(emitter); /* Non-NULL emitter object expected. */
540 emitter->best_indent = (1 < indent && indent < 10) ? indent : 2;
544 * Set the preferred line width.
548 yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
550 assert(emitter); /* Non-NULL emitter object expected. */
552 emitter->best_width = (width >= 0) ? width : -1;
556 * Set if unescaped non-ASCII characters are allowed.
560 yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
562 assert(emitter); /* Non-NULL emitter object expected. */
564 emitter->unicode = (unicode != 0);
568 * Set the preferred line break character.
572 yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
574 assert(emitter); /* Non-NULL emitter object expected. */
576 emitter->line_break = line_break;
580 * Destroy a token object.
584 yaml_token_delete(yaml_token_t *token)
586 assert(token); /* Non-NULL token object expected. */
590 case YAML_TAG_DIRECTIVE_TOKEN:
591 yaml_free(token->data.tag_directive.handle);
592 yaml_free(token->data.tag_directive.prefix);
595 case YAML_ALIAS_TOKEN:
596 yaml_free(token->data.alias.value);
599 case YAML_ANCHOR_TOKEN:
600 yaml_free(token->data.anchor.value);
604 yaml_free(token->data.tag.handle);
605 yaml_free(token->data.tag.suffix);
608 case YAML_SCALAR_TOKEN:
609 yaml_free(token->data.scalar.value);
616 memset(token, 0, sizeof(yaml_token_t));
620 * Check if a string is a valid UTF-8 sequence.
622 * Check 'reader.c' for more details on UTF-8 encoding.
626 yaml_check_utf8(yaml_char_t *start, size_t length)
628 yaml_char_t *end = start+length;
629 yaml_char_t *pointer = start;
631 while (pointer < end) {
638 width = (octet & 0x80) == 0x00 ? 1 :
639 (octet & 0xE0) == 0xC0 ? 2 :
640 (octet & 0xF0) == 0xE0 ? 3 :
641 (octet & 0xF8) == 0xF0 ? 4 : 0;
642 value = (octet & 0x80) == 0x00 ? octet & 0x7F :
643 (octet & 0xE0) == 0xC0 ? octet & 0x1F :
644 (octet & 0xF0) == 0xE0 ? octet & 0x0F :
645 (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
646 if (!width) return 0;
647 if (pointer+width > end) return 0;
648 for (k = 1; k < width; k ++) {
650 if ((octet & 0xC0) != 0x80) return 0;
651 value = (value << 6) + (octet & 0x3F);
653 if (!((width == 1) ||
654 (width == 2 && value >= 0x80) ||
655 (width == 3 && value >= 0x800) ||
656 (width == 4 && value >= 0x10000))) return 0;
665 * Create STREAM-START.
669 yaml_stream_start_event_initialize(yaml_event_t *event,
670 yaml_encoding_t encoding)
672 yaml_mark_t mark = { 0, 0, 0 };
674 assert(event); /* Non-NULL event object is expected. */
676 STREAM_START_EVENT_INIT(*event, encoding, mark, mark);
686 yaml_stream_end_event_initialize(yaml_event_t *event)
688 yaml_mark_t mark = { 0, 0, 0 };
690 assert(event); /* Non-NULL event object is expected. */
692 STREAM_END_EVENT_INIT(*event, mark, mark);
698 * Create DOCUMENT-START.
702 yaml_document_start_event_initialize(yaml_event_t *event,
703 yaml_version_directive_t *version_directive,
704 yaml_tag_directive_t *tag_directives_start,
705 yaml_tag_directive_t *tag_directives_end,
709 yaml_error_type_t error;
711 yaml_mark_t mark = { 0, 0, 0 };
712 yaml_version_directive_t *version_directive_copy = NULL;
714 yaml_tag_directive_t *start;
715 yaml_tag_directive_t *end;
716 yaml_tag_directive_t *top;
717 } tag_directives_copy = { NULL, NULL, NULL };
718 yaml_tag_directive_t value = { NULL, NULL };
720 assert(event); /* Non-NULL event object is expected. */
721 assert((tag_directives_start && tag_directives_end) ||
722 (tag_directives_start == tag_directives_end));
723 /* Valid tag directives are expected. */
725 if (version_directive) {
726 version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
727 if (!version_directive_copy) goto error;
728 version_directive_copy->major = version_directive->major;
729 version_directive_copy->minor = version_directive->minor;
732 if (tag_directives_start != tag_directives_end) {
733 yaml_tag_directive_t *tag_directive;
734 if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
736 for (tag_directive = tag_directives_start;
737 tag_directive != tag_directives_end; tag_directive ++) {
738 assert(tag_directive->handle);
739 assert(tag_directive->prefix);
740 if (!yaml_check_utf8(tag_directive->handle,
741 strlen((char *)tag_directive->handle)))
743 if (!yaml_check_utf8(tag_directive->prefix,
744 strlen((char *)tag_directive->prefix)))
746 value.handle = yaml_strdup(tag_directive->handle);
747 value.prefix = yaml_strdup(tag_directive->prefix);
748 if (!value.handle || !value.prefix) goto error;
749 if (!PUSH(&context, tag_directives_copy, value))
756 DOCUMENT_START_EVENT_INIT(*event, version_directive_copy,
757 tag_directives_copy.start, tag_directives_copy.top,
758 implicit, mark, mark);
763 yaml_free(version_directive_copy);
764 while (!STACK_EMPTY(context, tag_directives_copy)) {
765 yaml_tag_directive_t value = POP(context, tag_directives_copy);
766 yaml_free(value.handle);
767 yaml_free(value.prefix);
769 STACK_DEL(context, tag_directives_copy);
770 yaml_free(value.handle);
771 yaml_free(value.prefix);
777 * Create DOCUMENT-END.
781 yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
783 yaml_mark_t mark = { 0, 0, 0 };
785 assert(event); /* Non-NULL emitter object is expected. */
787 DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark);
797 yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
799 yaml_mark_t mark = { 0, 0, 0 };
800 yaml_char_t *anchor_copy = NULL;
802 assert(event); /* Non-NULL event object is expected. */
803 assert(anchor); /* Non-NULL anchor is expected. */
805 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;
807 anchor_copy = yaml_strdup(anchor);
811 ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);
821 yaml_scalar_event_initialize(yaml_event_t *event,
822 yaml_char_t *anchor, yaml_char_t *tag,
823 yaml_char_t *value, int length,
824 int plain_implicit, int quoted_implicit,
825 yaml_scalar_style_t style)
827 yaml_mark_t mark = { 0, 0, 0 };
828 yaml_char_t *anchor_copy = NULL;
829 yaml_char_t *tag_copy = NULL;
830 yaml_char_t *value_copy = NULL;
832 assert(event); /* Non-NULL event object is expected. */
833 assert(value); /* Non-NULL anchor is expected. */
836 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
837 anchor_copy = yaml_strdup(anchor);
838 if (!anchor_copy) goto error;
842 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
843 tag_copy = yaml_strdup(tag);
844 if (!tag_copy) goto error;
848 length = strlen((char *)value);
851 if (!yaml_check_utf8(value, length)) goto error;
852 value_copy = YAML_MALLOC(length+1);
853 if (!value_copy) goto error;
854 memcpy(value_copy, value, length);
855 value_copy[length] = '\0';
857 SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length,
858 plain_implicit, quoted_implicit, style, mark, mark);
863 yaml_free(anchor_copy);
865 yaml_free(value_copy);
871 * Create SEQUENCE-START.
875 yaml_sequence_start_event_initialize(yaml_event_t *event,
876 yaml_char_t *anchor, yaml_char_t *tag, int implicit,
877 yaml_sequence_style_t style)
879 yaml_mark_t mark = { 0, 0, 0 };
880 yaml_char_t *anchor_copy = NULL;
881 yaml_char_t *tag_copy = NULL;
883 assert(event); /* Non-NULL event object is expected. */
886 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
887 anchor_copy = yaml_strdup(anchor);
888 if (!anchor_copy) goto error;
892 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
893 tag_copy = yaml_strdup(tag);
894 if (!tag_copy) goto error;
897 SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy,
898 implicit, style, mark, mark);
903 yaml_free(anchor_copy);
910 * Create SEQUENCE-END.
914 yaml_sequence_end_event_initialize(yaml_event_t *event)
916 yaml_mark_t mark = { 0, 0, 0 };
918 assert(event); /* Non-NULL event object is expected. */
920 SEQUENCE_END_EVENT_INIT(*event, mark, mark);
926 * Create MAPPING-START.
930 yaml_mapping_start_event_initialize(yaml_event_t *event,
931 yaml_char_t *anchor, yaml_char_t *tag, int implicit,
932 yaml_mapping_style_t style)
934 yaml_mark_t mark = { 0, 0, 0 };
935 yaml_char_t *anchor_copy = NULL;
936 yaml_char_t *tag_copy = NULL;
938 assert(event); /* Non-NULL event object is expected. */
941 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
942 anchor_copy = yaml_strdup(anchor);
943 if (!anchor_copy) goto error;
947 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
948 tag_copy = yaml_strdup(tag);
949 if (!tag_copy) goto error;
952 MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy,
953 implicit, style, mark, mark);
958 yaml_free(anchor_copy);
965 * Create MAPPING-END.
969 yaml_mapping_end_event_initialize(yaml_event_t *event)
971 yaml_mark_t mark = { 0, 0, 0 };
973 assert(event); /* Non-NULL event object is expected. */
975 MAPPING_END_EVENT_INIT(*event, mark, mark);
981 * Destroy an event object.
985 yaml_event_delete(yaml_event_t *event)
987 yaml_tag_directive_t *tag_directive;
989 assert(event); /* Non-NULL event object expected. */
993 case YAML_DOCUMENT_START_EVENT:
994 yaml_free(event->data.document_start.version_directive);
995 for (tag_directive = event->data.document_start.tag_directives.start;
996 tag_directive != event->data.document_start.tag_directives.end;
998 yaml_free(tag_directive->handle);
999 yaml_free(tag_directive->prefix);
1001 yaml_free(event->data.document_start.tag_directives.start);
1004 case YAML_ALIAS_EVENT:
1005 yaml_free(event->data.alias.anchor);
1008 case YAML_SCALAR_EVENT:
1009 yaml_free(event->data.scalar.anchor);
1010 yaml_free(event->data.scalar.tag);
1011 yaml_free(event->data.scalar.value);
1014 case YAML_SEQUENCE_START_EVENT:
1015 yaml_free(event->data.sequence_start.anchor);
1016 yaml_free(event->data.sequence_start.tag);
1019 case YAML_MAPPING_START_EVENT:
1020 yaml_free(event->data.mapping_start.anchor);
1021 yaml_free(event->data.mapping_start.tag);
1028 memset(event, 0, sizeof(yaml_event_t));
1032 * Create a document object.
1036 yaml_document_initialize(yaml_document_t *document,
1037 yaml_version_directive_t *version_directive,
1038 yaml_tag_directive_t *tag_directives_start,
1039 yaml_tag_directive_t *tag_directives_end,
1040 int start_implicit, int end_implicit)
1043 yaml_error_type_t error;
1049 } nodes = { NULL, NULL, NULL };
1050 yaml_version_directive_t *version_directive_copy = NULL;
1052 yaml_tag_directive_t *start;
1053 yaml_tag_directive_t *end;
1054 yaml_tag_directive_t *top;
1055 } tag_directives_copy = { NULL, NULL, NULL };
1056 yaml_tag_directive_t value = { NULL, NULL };
1057 yaml_mark_t mark = { 0, 0, 0 };
1059 assert(document); /* Non-NULL document object is expected. */
1060 assert((tag_directives_start && tag_directives_end) ||
1061 (tag_directives_start == tag_directives_end));
1062 /* Valid tag directives are expected. */
1064 if (!STACK_INIT(&context, nodes, yaml_node_t*)) goto error;
1066 if (version_directive) {
1067 version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
1068 if (!version_directive_copy) goto error;
1069 version_directive_copy->major = version_directive->major;
1070 version_directive_copy->minor = version_directive->minor;
1073 if (tag_directives_start != tag_directives_end) {
1074 yaml_tag_directive_t *tag_directive;
1075 if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
1077 for (tag_directive = tag_directives_start;
1078 tag_directive != tag_directives_end; tag_directive ++) {
1079 assert(tag_directive->handle);
1080 assert(tag_directive->prefix);
1081 if (!yaml_check_utf8(tag_directive->handle,
1082 strlen((char *)tag_directive->handle)))
1084 if (!yaml_check_utf8(tag_directive->prefix,
1085 strlen((char *)tag_directive->prefix)))
1087 value.handle = yaml_strdup(tag_directive->handle);
1088 value.prefix = yaml_strdup(tag_directive->prefix);
1089 if (!value.handle || !value.prefix) goto error;
1090 if (!PUSH(&context, tag_directives_copy, value))
1092 value.handle = NULL;
1093 value.prefix = NULL;
1097 DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
1098 tag_directives_copy.start, tag_directives_copy.top,
1099 start_implicit, end_implicit, mark, mark);
1104 STACK_DEL(&context, nodes);
1105 yaml_free(version_directive_copy);
1106 while (!STACK_EMPTY(&context, tag_directives_copy)) {
1107 yaml_tag_directive_t value = POP(&context, tag_directives_copy);
1108 yaml_free(value.handle);
1109 yaml_free(value.prefix);
1111 STACK_DEL(&context, tag_directives_copy);
1112 yaml_free(value.handle);
1113 yaml_free(value.prefix);
1119 * Destroy a document object.
1123 yaml_document_delete(yaml_document_t *document)
1125 yaml_tag_directive_t *tag_directive;
1127 assert(document); /* Non-NULL document object is expected. */
1129 while (!STACK_EMPTY(&context, document->nodes)) {
1130 yaml_node_t node = POP(&context, document->nodes);
1131 yaml_free(node.tag);
1132 switch (node.type) {
1133 case YAML_SCALAR_NODE:
1134 yaml_free(node.data.scalar.value);
1136 case YAML_SEQUENCE_NODE:
1137 STACK_DEL(&context, node.data.sequence.items);
1139 case YAML_MAPPING_NODE:
1140 STACK_DEL(&context, node.data.mapping.pairs);
1143 assert(0); /* Should not happen. */
1146 STACK_DEL(&context, document->nodes);
1148 yaml_free(document->version_directive);
1149 for (tag_directive = document->tag_directives.start;
1150 tag_directive != document->tag_directives.end;
1152 yaml_free(tag_directive->handle);
1153 yaml_free(tag_directive->prefix);
1155 yaml_free(document->tag_directives.start);
1157 memset(document, 0, sizeof(yaml_document_t));
1161 * Get a document node.
1164 YAML_DECLARE(yaml_node_t *)
1165 yaml_document_get_node(yaml_document_t *document, int index)
1167 assert(document); /* Non-NULL document object is expected. */
1169 if (index > 0 && document->nodes.start + index <= document->nodes.top) {
1170 return document->nodes.start + index - 1;
1176 * Get the root object.
1179 YAML_DECLARE(yaml_node_t *)
1180 yaml_document_get_root_node(yaml_document_t *document)
1182 assert(document); /* Non-NULL document object is expected. */
1184 if (document->nodes.top != document->nodes.start) {
1185 return document->nodes.start;
1191 * Add a scalar node to a document.
1195 yaml_document_add_scalar(yaml_document_t *document,
1196 yaml_char_t *tag, yaml_char_t *value, int length,
1197 yaml_scalar_style_t style)
1200 yaml_error_type_t error;
1202 yaml_mark_t mark = { 0, 0, 0 };
1203 yaml_char_t *tag_copy = NULL;
1204 yaml_char_t *value_copy = NULL;
1207 assert(document); /* Non-NULL document object is expected. */
1208 assert(value); /* Non-NULL value is expected. */
1211 tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG;
1214 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1215 tag_copy = yaml_strdup(tag);
1216 if (!tag_copy) goto error;
1219 length = strlen((char *)value);
1222 if (!yaml_check_utf8(value, length)) goto error;
1223 value_copy = YAML_MALLOC(length+1);
1224 if (!value_copy) goto error;
1225 memcpy(value_copy, value, length);
1226 value_copy[length] = '\0';
1228 SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark);
1229 if (!PUSH(&context, document->nodes, node)) goto error;
1231 return document->nodes.top - document->nodes.start;
1234 yaml_free(tag_copy);
1235 yaml_free(value_copy);
1241 * Add a sequence node to a document.
1245 yaml_document_add_sequence(yaml_document_t *document,
1246 yaml_char_t *tag, yaml_sequence_style_t style)
1249 yaml_error_type_t error;
1251 yaml_mark_t mark = { 0, 0, 0 };
1252 yaml_char_t *tag_copy = NULL;
1254 yaml_node_item_t *start;
1255 yaml_node_item_t *end;
1256 yaml_node_item_t *top;
1257 } items = { NULL, NULL, NULL };
1260 assert(document); /* Non-NULL document object is expected. */
1263 tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG;
1266 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1267 tag_copy = yaml_strdup(tag);
1268 if (!tag_copy) goto error;
1270 if (!STACK_INIT(&context, items, yaml_node_item_t*)) goto error;
1272 SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
1274 if (!PUSH(&context, document->nodes, node)) goto error;
1276 return document->nodes.top - document->nodes.start;
1279 STACK_DEL(&context, items);
1280 yaml_free(tag_copy);
1286 * Add a mapping node to a document.
1290 yaml_document_add_mapping(yaml_document_t *document,
1291 yaml_char_t *tag, yaml_mapping_style_t style)
1294 yaml_error_type_t error;
1296 yaml_mark_t mark = { 0, 0, 0 };
1297 yaml_char_t *tag_copy = NULL;
1299 yaml_node_pair_t *start;
1300 yaml_node_pair_t *end;
1301 yaml_node_pair_t *top;
1302 } pairs = { NULL, NULL, NULL };
1305 assert(document); /* Non-NULL document object is expected. */
1308 tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG;
1311 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1312 tag_copy = yaml_strdup(tag);
1313 if (!tag_copy) goto error;
1315 if (!STACK_INIT(&context, pairs, yaml_node_pair_t*)) goto error;
1317 MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
1319 if (!PUSH(&context, document->nodes, node)) goto error;
1321 return document->nodes.top - document->nodes.start;
1324 STACK_DEL(&context, pairs);
1325 yaml_free(tag_copy);
1331 * Append an item to a sequence node.
1335 yaml_document_append_sequence_item(yaml_document_t *document,
1336 int sequence, int item)
1339 yaml_error_type_t error;
1342 assert(document); /* Non-NULL document is required. */
1344 && document->nodes.start + sequence <= document->nodes.top);
1345 /* Valid sequence id is required. */
1346 assert(document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE);
1347 /* A sequence node is required. */
1348 assert(item > 0 && document->nodes.start + item <= document->nodes.top);
1349 /* Valid item id is required. */
1352 document->nodes.start[sequence-1].data.sequence.items, item))
1359 * Append a pair of a key and a value to a mapping node.
1363 yaml_document_append_mapping_pair(yaml_document_t *document,
1364 int mapping, int key, int value)
1367 yaml_error_type_t error;
1370 yaml_node_pair_t pair;
1372 assert(document); /* Non-NULL document is required. */
1374 && document->nodes.start + mapping <= document->nodes.top);
1375 /* Valid mapping id is required. */
1376 assert(document->nodes.start[mapping-1].type == YAML_MAPPING_NODE);
1377 /* A mapping node is required. */
1378 assert(key > 0 && document->nodes.start + key <= document->nodes.top);
1379 /* Valid key id is required. */
1380 assert(value > 0 && document->nodes.start + value <= document->nodes.top);
1381 /* Valid value id is required. */
1387 document->nodes.start[mapping-1].data.mapping.pairs, pair))