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)
121 void *new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2);
123 if (!new_start) return 0;
125 *top = (char *)new_start + ((char *)*top - (char *)*start);
126 *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
133 * Extend or move a queue.
137 yaml_queue_extend(void **start, void **head, void **tail, void **end)
139 /* Check if we need to resize the queue. */
141 if (*start == *head && *tail == *end) {
142 void *new_start = yaml_realloc(*start,
143 ((char *)*end - (char *)*start)*2);
145 if (!new_start) return 0;
147 *head = (char *)new_start + ((char *)*head - (char *)*start);
148 *tail = (char *)new_start + ((char *)*tail - (char *)*start);
149 *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
153 /* Check if we need to move the queue at the beginning of the buffer. */
156 if (*head != *tail) {
157 memmove(*start, *head, (char *)*tail - (char *)*head);
159 *tail = (char *)*tail - (char *)*head + (char *)*start;
168 * Create a new parser object.
172 yaml_parser_initialize(yaml_parser_t *parser)
174 assert(parser); /* Non-NULL parser object expected. */
176 memset(parser, 0, sizeof(yaml_parser_t));
177 if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE))
179 if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
181 if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE, yaml_token_t*))
183 if (!STACK_INIT(parser, parser->indents, int*))
185 if (!STACK_INIT(parser, parser->simple_keys, yaml_simple_key_t*))
187 if (!STACK_INIT(parser, parser->states, yaml_parser_state_t*))
189 if (!STACK_INIT(parser, parser->marks, yaml_mark_t*))
191 if (!STACK_INIT(parser, parser->tag_directives, yaml_tag_directive_t*))
198 BUFFER_DEL(parser, parser->raw_buffer);
199 BUFFER_DEL(parser, parser->buffer);
200 QUEUE_DEL(parser, parser->tokens);
201 STACK_DEL(parser, parser->indents);
202 STACK_DEL(parser, parser->simple_keys);
203 STACK_DEL(parser, parser->states);
204 STACK_DEL(parser, parser->marks);
205 STACK_DEL(parser, parser->tag_directives);
211 * Destroy a parser object.
215 yaml_parser_delete(yaml_parser_t *parser)
217 assert(parser); /* Non-NULL parser object expected. */
219 BUFFER_DEL(parser, parser->raw_buffer);
220 BUFFER_DEL(parser, parser->buffer);
221 while (!QUEUE_EMPTY(parser, parser->tokens)) {
222 yaml_token_delete(&DEQUEUE(parser, parser->tokens));
224 QUEUE_DEL(parser, parser->tokens);
225 STACK_DEL(parser, parser->indents);
226 STACK_DEL(parser, parser->simple_keys);
227 STACK_DEL(parser, parser->states);
228 STACK_DEL(parser, parser->marks);
229 while (!STACK_EMPTY(parser, parser->tag_directives)) {
230 yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
231 yaml_free(tag_directive.handle);
232 yaml_free(tag_directive.prefix);
234 STACK_DEL(parser, parser->tag_directives);
236 memset(parser, 0, sizeof(yaml_parser_t));
240 * String read handler.
244 yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
247 yaml_parser_t *parser = (yaml_parser_t *)data;
249 if (parser->input.string.current == parser->input.string.end) {
254 if (size > (size_t)(parser->input.string.end
255 - parser->input.string.current)) {
256 size = parser->input.string.end - parser->input.string.current;
259 memcpy(buffer, parser->input.string.current, size);
260 parser->input.string.current += size;
270 yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
273 yaml_parser_t *parser = (yaml_parser_t *)data;
275 *size_read = fread(buffer, 1, size, parser->input.file);
276 return !ferror(parser->input.file);
280 * Set a string input.
284 yaml_parser_set_input_string(yaml_parser_t *parser,
285 const unsigned char *input, size_t size)
287 assert(parser); /* Non-NULL parser object expected. */
288 assert(!parser->read_handler); /* You can set the source only once. */
289 assert(input); /* Non-NULL input string expected. */
291 parser->read_handler = yaml_string_read_handler;
292 parser->read_handler_data = parser;
294 parser->input.string.start = input;
295 parser->input.string.current = input;
296 parser->input.string.end = input+size;
304 yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
306 assert(parser); /* Non-NULL parser object expected. */
307 assert(!parser->read_handler); /* You can set the source only once. */
308 assert(file); /* Non-NULL file object expected. */
310 parser->read_handler = yaml_file_read_handler;
311 parser->read_handler_data = parser;
313 parser->input.file = file;
317 * Set a generic input.
321 yaml_parser_set_input(yaml_parser_t *parser,
322 yaml_read_handler_t *handler, void *data)
324 assert(parser); /* Non-NULL parser object expected. */
325 assert(!parser->read_handler); /* You can set the source only once. */
326 assert(handler); /* Non-NULL read handler expected. */
328 parser->read_handler = handler;
329 parser->read_handler_data = data;
333 * Set the source encoding.
337 yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
339 assert(parser); /* Non-NULL parser object expected. */
340 assert(!parser->encoding); /* Encoding is already set or detected. */
342 parser->encoding = encoding;
346 * Create a new emitter object.
350 yaml_emitter_initialize(yaml_emitter_t *emitter)
352 assert(emitter); /* Non-NULL emitter object expected. */
354 memset(emitter, 0, sizeof(yaml_emitter_t));
355 if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE))
357 if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
359 if (!STACK_INIT(emitter, emitter->states, yaml_emitter_state_t*))
361 if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE, yaml_event_t*))
363 if (!STACK_INIT(emitter, emitter->indents, int*))
365 if (!STACK_INIT(emitter, emitter->tag_directives, yaml_tag_directive_t*))
372 BUFFER_DEL(emitter, emitter->buffer);
373 BUFFER_DEL(emitter, emitter->raw_buffer);
374 STACK_DEL(emitter, emitter->states);
375 QUEUE_DEL(emitter, emitter->events);
376 STACK_DEL(emitter, emitter->indents);
377 STACK_DEL(emitter, emitter->tag_directives);
383 * Destroy an emitter object.
387 yaml_emitter_delete(yaml_emitter_t *emitter)
389 assert(emitter); /* Non-NULL emitter object expected. */
391 BUFFER_DEL(emitter, emitter->buffer);
392 BUFFER_DEL(emitter, emitter->raw_buffer);
393 STACK_DEL(emitter, emitter->states);
394 while (!QUEUE_EMPTY(emitter, emitter->events)) {
395 yaml_event_delete(&DEQUEUE(emitter, emitter->events));
397 QUEUE_DEL(emitter, emitter->events);
398 STACK_DEL(emitter, emitter->indents);
399 while (!STACK_EMPTY(empty, emitter->tag_directives)) {
400 yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
401 yaml_free(tag_directive.handle);
402 yaml_free(tag_directive.prefix);
404 STACK_DEL(emitter, emitter->tag_directives);
405 yaml_free(emitter->anchors);
407 memset(emitter, 0, sizeof(yaml_emitter_t));
411 * String write handler.
415 yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
417 yaml_emitter_t *emitter = (yaml_emitter_t *)data;
419 if (emitter->output.string.size - *emitter->output.string.size_written
421 memcpy(emitter->output.string.buffer
422 + *emitter->output.string.size_written,
424 emitter->output.string.size
425 - *emitter->output.string.size_written);
426 *emitter->output.string.size_written = emitter->output.string.size;
430 memcpy(emitter->output.string.buffer
431 + *emitter->output.string.size_written, buffer, size);
432 *emitter->output.string.size_written += size;
437 * File write handler.
441 yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
443 yaml_emitter_t *emitter = (yaml_emitter_t *)data;
445 return (fwrite(buffer, 1, size, emitter->output.file) == size);
448 * Set a string output.
452 yaml_emitter_set_output_string(yaml_emitter_t *emitter,
453 unsigned char *output, size_t size, size_t *size_written)
455 assert(emitter); /* Non-NULL emitter object expected. */
456 assert(!emitter->write_handler); /* You can set the output only once. */
457 assert(output); /* Non-NULL output string expected. */
459 emitter->write_handler = yaml_string_write_handler;
460 emitter->write_handler_data = emitter;
462 emitter->output.string.buffer = output;
463 emitter->output.string.size = size;
464 emitter->output.string.size_written = size_written;
473 yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
475 assert(emitter); /* Non-NULL emitter object expected. */
476 assert(!emitter->write_handler); /* You can set the output only once. */
477 assert(file); /* Non-NULL file object expected. */
479 emitter->write_handler = yaml_file_write_handler;
480 emitter->write_handler_data = emitter;
482 emitter->output.file = file;
486 * Set a generic output handler.
490 yaml_emitter_set_output(yaml_emitter_t *emitter,
491 yaml_write_handler_t *handler, void *data)
493 assert(emitter); /* Non-NULL emitter object expected. */
494 assert(!emitter->write_handler); /* You can set the output only once. */
495 assert(handler); /* Non-NULL handler object expected. */
497 emitter->write_handler = handler;
498 emitter->write_handler_data = data;
502 * Set the output encoding.
506 yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding)
508 assert(emitter); /* Non-NULL emitter object expected. */
509 assert(!emitter->encoding); /* You can set encoding only once. */
511 emitter->encoding = encoding;
515 * Set the canonical output style.
519 yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
521 assert(emitter); /* Non-NULL emitter object expected. */
523 emitter->canonical = (canonical != 0);
527 * Set the indentation increment.
531 yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
533 assert(emitter); /* Non-NULL emitter object expected. */
535 emitter->best_indent = (1 < indent && indent < 10) ? indent : 2;
539 * Set the preferred line width.
543 yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
545 assert(emitter); /* Non-NULL emitter object expected. */
547 emitter->best_width = (width >= 0) ? width : -1;
551 * Set if unescaped non-ASCII characters are allowed.
555 yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
557 assert(emitter); /* Non-NULL emitter object expected. */
559 emitter->unicode = (unicode != 0);
563 * Set the preferred line break character.
567 yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
569 assert(emitter); /* Non-NULL emitter object expected. */
571 emitter->line_break = line_break;
575 * Destroy a token object.
579 yaml_token_delete(yaml_token_t *token)
581 assert(token); /* Non-NULL token object expected. */
585 case YAML_TAG_DIRECTIVE_TOKEN:
586 yaml_free(token->data.tag_directive.handle);
587 yaml_free(token->data.tag_directive.prefix);
590 case YAML_ALIAS_TOKEN:
591 yaml_free(token->data.alias.value);
594 case YAML_ANCHOR_TOKEN:
595 yaml_free(token->data.anchor.value);
599 yaml_free(token->data.tag.handle);
600 yaml_free(token->data.tag.suffix);
603 case YAML_SCALAR_TOKEN:
604 yaml_free(token->data.scalar.value);
611 memset(token, 0, sizeof(yaml_token_t));
615 * Check if a string is a valid UTF-8 sequence.
617 * Check 'reader.c' for more details on UTF-8 encoding.
621 yaml_check_utf8(yaml_char_t *start, size_t length)
623 yaml_char_t *end = start+length;
624 yaml_char_t *pointer = start;
626 while (pointer < end) {
633 width = (octet & 0x80) == 0x00 ? 1 :
634 (octet & 0xE0) == 0xC0 ? 2 :
635 (octet & 0xF0) == 0xE0 ? 3 :
636 (octet & 0xF8) == 0xF0 ? 4 : 0;
637 value = (octet & 0x80) == 0x00 ? octet & 0x7F :
638 (octet & 0xE0) == 0xC0 ? octet & 0x1F :
639 (octet & 0xF0) == 0xE0 ? octet & 0x0F :
640 (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
641 if (!width) return 0;
642 if (pointer+width > end) return 0;
643 for (k = 1; k < width; k ++) {
645 if ((octet & 0xC0) != 0x80) return 0;
646 value = (value << 6) + (octet & 0x3F);
648 if (!((width == 1) ||
649 (width == 2 && value >= 0x80) ||
650 (width == 3 && value >= 0x800) ||
651 (width == 4 && value >= 0x10000))) return 0;
660 * Create STREAM-START.
664 yaml_stream_start_event_initialize(yaml_event_t *event,
665 yaml_encoding_t encoding)
667 yaml_mark_t mark = { 0, 0, 0 };
669 assert(event); /* Non-NULL event object is expected. */
671 STREAM_START_EVENT_INIT(*event, encoding, mark, mark);
681 yaml_stream_end_event_initialize(yaml_event_t *event)
683 yaml_mark_t mark = { 0, 0, 0 };
685 assert(event); /* Non-NULL event object is expected. */
687 STREAM_END_EVENT_INIT(*event, mark, mark);
693 * Create DOCUMENT-START.
697 yaml_document_start_event_initialize(yaml_event_t *event,
698 yaml_version_directive_t *version_directive,
699 yaml_tag_directive_t *tag_directives_start,
700 yaml_tag_directive_t *tag_directives_end,
704 yaml_error_type_t error;
706 yaml_mark_t mark = { 0, 0, 0 };
707 yaml_version_directive_t *version_directive_copy = NULL;
709 yaml_tag_directive_t *start;
710 yaml_tag_directive_t *end;
711 yaml_tag_directive_t *top;
712 } tag_directives_copy = { NULL, NULL, NULL };
713 yaml_tag_directive_t value = { NULL, NULL };
715 assert(event); /* Non-NULL event object is expected. */
716 assert((tag_directives_start && tag_directives_end) ||
717 (tag_directives_start == tag_directives_end));
718 /* Valid tag directives are expected. */
720 if (version_directive) {
721 version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
722 if (!version_directive_copy) goto error;
723 version_directive_copy->major = version_directive->major;
724 version_directive_copy->minor = version_directive->minor;
727 if (tag_directives_start != tag_directives_end) {
728 yaml_tag_directive_t *tag_directive;
729 if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
731 for (tag_directive = tag_directives_start;
732 tag_directive != tag_directives_end; tag_directive ++) {
733 assert(tag_directive->handle);
734 assert(tag_directive->prefix);
735 if (!yaml_check_utf8(tag_directive->handle,
736 strlen((char *)tag_directive->handle)))
738 if (!yaml_check_utf8(tag_directive->prefix,
739 strlen((char *)tag_directive->prefix)))
741 value.handle = yaml_strdup(tag_directive->handle);
742 value.prefix = yaml_strdup(tag_directive->prefix);
743 if (!value.handle || !value.prefix) goto error;
744 if (!PUSH(&context, tag_directives_copy, value))
751 DOCUMENT_START_EVENT_INIT(*event, version_directive_copy,
752 tag_directives_copy.start, tag_directives_copy.top,
753 implicit, mark, mark);
758 yaml_free(version_directive_copy);
759 while (!STACK_EMPTY(context, tag_directives_copy)) {
760 yaml_tag_directive_t value = POP(context, tag_directives_copy);
761 yaml_free(value.handle);
762 yaml_free(value.prefix);
764 STACK_DEL(context, tag_directives_copy);
765 yaml_free(value.handle);
766 yaml_free(value.prefix);
772 * Create DOCUMENT-END.
776 yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
778 yaml_mark_t mark = { 0, 0, 0 };
780 assert(event); /* Non-NULL emitter object is expected. */
782 DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark);
792 yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
794 yaml_mark_t mark = { 0, 0, 0 };
795 yaml_char_t *anchor_copy = NULL;
797 assert(event); /* Non-NULL event object is expected. */
798 assert(anchor); /* Non-NULL anchor is expected. */
800 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;
802 anchor_copy = yaml_strdup(anchor);
806 ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);
816 yaml_scalar_event_initialize(yaml_event_t *event,
817 yaml_char_t *anchor, yaml_char_t *tag,
818 yaml_char_t *value, int length,
819 int plain_implicit, int quoted_implicit,
820 yaml_scalar_style_t style)
822 yaml_mark_t mark = { 0, 0, 0 };
823 yaml_char_t *anchor_copy = NULL;
824 yaml_char_t *tag_copy = NULL;
825 yaml_char_t *value_copy = NULL;
827 assert(event); /* Non-NULL event object is expected. */
828 assert(value); /* Non-NULL anchor is expected. */
831 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
832 anchor_copy = yaml_strdup(anchor);
833 if (!anchor_copy) goto error;
837 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
838 tag_copy = yaml_strdup(tag);
839 if (!tag_copy) goto error;
843 length = strlen((char *)value);
846 if (!yaml_check_utf8(value, length)) goto error;
847 value_copy = YAML_MALLOC(length+1);
848 if (!value_copy) goto error;
849 memcpy(value_copy, value, length);
850 value_copy[length] = '\0';
852 SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length,
853 plain_implicit, quoted_implicit, style, mark, mark);
858 yaml_free(anchor_copy);
860 yaml_free(value_copy);
866 * Create SEQUENCE-START.
870 yaml_sequence_start_event_initialize(yaml_event_t *event,
871 yaml_char_t *anchor, yaml_char_t *tag, int implicit,
872 yaml_sequence_style_t style)
874 yaml_mark_t mark = { 0, 0, 0 };
875 yaml_char_t *anchor_copy = NULL;
876 yaml_char_t *tag_copy = NULL;
878 assert(event); /* Non-NULL event object is expected. */
881 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
882 anchor_copy = yaml_strdup(anchor);
883 if (!anchor_copy) goto error;
887 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
888 tag_copy = yaml_strdup(tag);
889 if (!tag_copy) goto error;
892 SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy,
893 implicit, style, mark, mark);
898 yaml_free(anchor_copy);
905 * Create SEQUENCE-END.
909 yaml_sequence_end_event_initialize(yaml_event_t *event)
911 yaml_mark_t mark = { 0, 0, 0 };
913 assert(event); /* Non-NULL event object is expected. */
915 SEQUENCE_END_EVENT_INIT(*event, mark, mark);
921 * Create MAPPING-START.
925 yaml_mapping_start_event_initialize(yaml_event_t *event,
926 yaml_char_t *anchor, yaml_char_t *tag, int implicit,
927 yaml_mapping_style_t style)
929 yaml_mark_t mark = { 0, 0, 0 };
930 yaml_char_t *anchor_copy = NULL;
931 yaml_char_t *tag_copy = NULL;
933 assert(event); /* Non-NULL event object is expected. */
936 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
937 anchor_copy = yaml_strdup(anchor);
938 if (!anchor_copy) goto error;
942 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
943 tag_copy = yaml_strdup(tag);
944 if (!tag_copy) goto error;
947 MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy,
948 implicit, style, mark, mark);
953 yaml_free(anchor_copy);
960 * Create MAPPING-END.
964 yaml_mapping_end_event_initialize(yaml_event_t *event)
966 yaml_mark_t mark = { 0, 0, 0 };
968 assert(event); /* Non-NULL event object is expected. */
970 MAPPING_END_EVENT_INIT(*event, mark, mark);
976 * Destroy an event object.
980 yaml_event_delete(yaml_event_t *event)
982 yaml_tag_directive_t *tag_directive;
984 assert(event); /* Non-NULL event object expected. */
988 case YAML_DOCUMENT_START_EVENT:
989 yaml_free(event->data.document_start.version_directive);
990 for (tag_directive = event->data.document_start.tag_directives.start;
991 tag_directive != event->data.document_start.tag_directives.end;
993 yaml_free(tag_directive->handle);
994 yaml_free(tag_directive->prefix);
996 yaml_free(event->data.document_start.tag_directives.start);
999 case YAML_ALIAS_EVENT:
1000 yaml_free(event->data.alias.anchor);
1003 case YAML_SCALAR_EVENT:
1004 yaml_free(event->data.scalar.anchor);
1005 yaml_free(event->data.scalar.tag);
1006 yaml_free(event->data.scalar.value);
1009 case YAML_SEQUENCE_START_EVENT:
1010 yaml_free(event->data.sequence_start.anchor);
1011 yaml_free(event->data.sequence_start.tag);
1014 case YAML_MAPPING_START_EVENT:
1015 yaml_free(event->data.mapping_start.anchor);
1016 yaml_free(event->data.mapping_start.tag);
1023 memset(event, 0, sizeof(yaml_event_t));
1027 * Create a document object.
1031 yaml_document_initialize(yaml_document_t *document,
1032 yaml_version_directive_t *version_directive,
1033 yaml_tag_directive_t *tag_directives_start,
1034 yaml_tag_directive_t *tag_directives_end,
1035 int start_implicit, int end_implicit)
1038 yaml_error_type_t error;
1044 } nodes = { NULL, NULL, NULL };
1045 yaml_version_directive_t *version_directive_copy = NULL;
1047 yaml_tag_directive_t *start;
1048 yaml_tag_directive_t *end;
1049 yaml_tag_directive_t *top;
1050 } tag_directives_copy = { NULL, NULL, NULL };
1051 yaml_tag_directive_t value = { NULL, NULL };
1052 yaml_mark_t mark = { 0, 0, 0 };
1054 assert(document); /* Non-NULL document object is expected. */
1055 assert((tag_directives_start && tag_directives_end) ||
1056 (tag_directives_start == tag_directives_end));
1057 /* Valid tag directives are expected. */
1059 if (!STACK_INIT(&context, nodes, yaml_node_t*)) goto error;
1061 if (version_directive) {
1062 version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
1063 if (!version_directive_copy) goto error;
1064 version_directive_copy->major = version_directive->major;
1065 version_directive_copy->minor = version_directive->minor;
1068 if (tag_directives_start != tag_directives_end) {
1069 yaml_tag_directive_t *tag_directive;
1070 if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
1072 for (tag_directive = tag_directives_start;
1073 tag_directive != tag_directives_end; tag_directive ++) {
1074 assert(tag_directive->handle);
1075 assert(tag_directive->prefix);
1076 if (!yaml_check_utf8(tag_directive->handle,
1077 strlen((char *)tag_directive->handle)))
1079 if (!yaml_check_utf8(tag_directive->prefix,
1080 strlen((char *)tag_directive->prefix)))
1082 value.handle = yaml_strdup(tag_directive->handle);
1083 value.prefix = yaml_strdup(tag_directive->prefix);
1084 if (!value.handle || !value.prefix) goto error;
1085 if (!PUSH(&context, tag_directives_copy, value))
1087 value.handle = NULL;
1088 value.prefix = NULL;
1092 DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
1093 tag_directives_copy.start, tag_directives_copy.top,
1094 start_implicit, end_implicit, mark, mark);
1099 STACK_DEL(&context, nodes);
1100 yaml_free(version_directive_copy);
1101 while (!STACK_EMPTY(&context, tag_directives_copy)) {
1102 yaml_tag_directive_t value = POP(&context, tag_directives_copy);
1103 yaml_free(value.handle);
1104 yaml_free(value.prefix);
1106 STACK_DEL(&context, tag_directives_copy);
1107 yaml_free(value.handle);
1108 yaml_free(value.prefix);
1114 * Destroy a document object.
1118 yaml_document_delete(yaml_document_t *document)
1121 yaml_error_type_t error;
1123 yaml_tag_directive_t *tag_directive;
1125 context.error = YAML_NO_ERROR; /* Eliminate a compliler warning. */
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))