git.iko.soy/typeable/yaml
on 90dd080 help sign in
typeable/yaml/libyaml/api.c
1390 lines 37 kB history raw
2#include "yaml_private.h"
4/*
5 * Get the library version.
6 */
8YAML_DECLARE(const char *)
9yaml_get_version_string(void)
11 return YAML_VERSION_STRING;
14/*
15 * Get the library version numbers.
16 */
18YAML_DECLARE(void)
19yaml_get_version(int *major, int *minor, int *patch)
21 *major = YAML_VERSION_MAJOR;
22 *minor = YAML_VERSION_MINOR;
23 *patch = YAML_VERSION_PATCH;
26/*
27 * Allocate a dynamic memory block.
28 */
30YAML_DECLARE(void *)
31yaml_malloc(size_t size)
33 return malloc(size ? size : 1);
36/*
37 * Reallocate a dynamic memory block.
38 */
40YAML_DECLARE(void *)
41yaml_realloc(void *ptr, size_t size)
43 return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
46/*
47 * Free a dynamic memory block.
48 */
50YAML_DECLARE(void)
51yaml_free(void *ptr)
53 if (ptr) free(ptr);
56/*
57 * Duplicate a string.
58 */
60YAML_DECLARE(yaml_char_t *)
61yaml_strdup(const yaml_char_t *str)
63 if (!str)
64 return NULL;
66 return (yaml_char_t *)strdup((char *)str);
69/*
70 * Extend a string.
71 */
73YAML_DECLARE(int)
74yaml_string_extend(yaml_char_t **start,
75 yaml_char_t **pointer, yaml_char_t **end)
77 yaml_char_t *new_start = yaml_realloc(*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;
85 *start = new_start;
87 return 1;
90/*
91 * Append a string B to a string A.
92 */
94YAML_DECLARE(int)
95yaml_string_join(
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, yaml_char_t **b_end)
99 if (*b_start == *b_pointer)
100 return 1;
102 while (*a_end - *a_pointer <= *b_pointer - *b_start) {
103 if (!yaml_string_extend(a_start, a_pointer, a_end))
104 return 0;
105 }
107 memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
108 *a_pointer += *b_pointer - *b_start;
110 return 1;
113/*
114 * Extend a stack.
115 */
117YAML_DECLARE(int)
118yaml_stack_extend(void **start, void **top, void **end)
120 void *new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2);
122 if (!new_start) return 0;
124 *top = (char *)new_start + ((char *)*top - (char *)*start);
125 *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
126 *start = new_start;
128 return 1;
131/*
132 * Extend or move a queue.
133 */
135YAML_DECLARE(int)
136yaml_queue_extend(void **start, void **head, void **tail, void **end)
138 /* Check if we need to resize the queue. */
140 if (*start == *head && *tail == *end) {
141 void *new_start = yaml_realloc(*start,
142 ((char *)*end - (char *)*start)*2);
144 if (!new_start) return 0;
146 *head = (char *)new_start + ((char *)*head - (char *)*start);
147 *tail = (char *)new_start + ((char *)*tail - (char *)*start);
148 *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
149 *start = new_start;
150 }
152 /* Check if we need to move the queue at the beginning of the buffer. */
154 if (*tail == *end) {
155 if (*head != *tail) {
156 memmove(*start, *head, (char *)*tail - (char *)*head);
157 }
158 *tail = (char *)*tail - (char *)*head + (char *)*start;
159 *head = *start;
160 }
162 return 1;
166/*
167 * Create a new parser object.
168 */
170YAML_DECLARE(int)
171yaml_parser_initialize(yaml_parser_t *parser)
173 assert(parser); /* Non-NULL parser object expected. */
175 memset(parser, 0, sizeof(yaml_parser_t));
176 if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE))
177 goto error;
178 if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
179 goto error;
180 if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE))
181 goto error;
182 if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE))
183 goto error;
184 if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE))
185 goto error;
186 if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE))
187 goto error;
188 if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE))
189 goto error;
190 if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE))
191 goto error;
193 return 1;
195error:
197 BUFFER_DEL(parser, parser->raw_buffer);
198 BUFFER_DEL(parser, parser->buffer);
199 QUEUE_DEL(parser, parser->tokens);
200 STACK_DEL(parser, parser->indents);
201 STACK_DEL(parser, parser->simple_keys);
202 STACK_DEL(parser, parser->states);
203 STACK_DEL(parser, parser->marks);
204 STACK_DEL(parser, parser->tag_directives);
206 return 0;
209/*
210 * Destroy a parser object.
211 */
213YAML_DECLARE(void)
214yaml_parser_delete(yaml_parser_t *parser)
216 assert(parser); /* Non-NULL parser object expected. */
218 BUFFER_DEL(parser, parser->raw_buffer);
219 BUFFER_DEL(parser, parser->buffer);
220 while (!QUEUE_EMPTY(parser, parser->tokens)) {
221 yaml_token_delete(&DEQUEUE(parser, parser->tokens));
222 }
223 QUEUE_DEL(parser, parser->tokens);
224 STACK_DEL(parser, parser->indents);
225 STACK_DEL(parser, parser->simple_keys);
226 STACK_DEL(parser, parser->states);
227 STACK_DEL(parser, parser->marks);
228 while (!STACK_EMPTY(parser, parser->tag_directives)) {
229 yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
230 yaml_free(tag_directive.handle);
231 yaml_free(tag_directive.prefix);
232 }
233 STACK_DEL(parser, parser->tag_directives);
235 memset(parser, 0, sizeof(yaml_parser_t));
238/*
239 * String read handler.
240 */
242static int
243yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
244 size_t *size_read)
246 yaml_parser_t *parser = data;
248 if (parser->input.string.current == parser->input.string.end) {
249 *size_read = 0;
250 return 1;
251 }
253 if (size > (size_t)(parser->input.string.end
254 - parser->input.string.current)) {
255 size = parser->input.string.end - parser->input.string.current;
256 }
258 memcpy(buffer, parser->input.string.current, size);
259 parser->input.string.current += size;
260 *size_read = size;
261 return 1;
264/*
265 * File read handler.
266 */
268static int
269yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
270 size_t *size_read)
272 yaml_parser_t *parser = data;
274 *size_read = fread(buffer, 1, size, parser->input.file);
275 return !ferror(parser->input.file);
278/*
279 * Set a string input.
280 */
282YAML_DECLARE(void)
283yaml_parser_set_input_string(yaml_parser_t *parser,
284 const unsigned char *input, size_t size)
286 assert(parser); /* Non-NULL parser object expected. */
287 assert(!parser->read_handler); /* You can set the source only once. */
288 assert(input); /* Non-NULL input string expected. */
290 parser->read_handler = yaml_string_read_handler;
291 parser->read_handler_data = parser;
293 parser->input.string.start = input;
294 parser->input.string.current = input;
295 parser->input.string.end = input+size;
298/*
299 * Set a file input.
300 */
302YAML_DECLARE(void)
303yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
305 assert(parser); /* Non-NULL parser object expected. */
306 assert(!parser->read_handler); /* You can set the source only once. */
307 assert(file); /* Non-NULL file object expected. */
309 parser->read_handler = yaml_file_read_handler;
310 parser->read_handler_data = parser;
312 parser->input.file = file;
315/*
316 * Set a generic input.
317 */
319YAML_DECLARE(void)
320yaml_parser_set_input(yaml_parser_t *parser,
321 yaml_read_handler_t *handler, void *data)
323 assert(parser); /* Non-NULL parser object expected. */
324 assert(!parser->read_handler); /* You can set the source only once. */
325 assert(handler); /* Non-NULL read handler expected. */
327 parser->read_handler = handler;
328 parser->read_handler_data = data;
331/*
332 * Set the source encoding.
333 */
335YAML_DECLARE(void)
336yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
338 assert(parser); /* Non-NULL parser object expected. */
339 assert(!parser->encoding); /* Encoding is already set or detected. */
341 parser->encoding = encoding;
344/*
345 * Create a new emitter object.
346 */
348YAML_DECLARE(int)
349yaml_emitter_initialize(yaml_emitter_t *emitter)
351 assert(emitter); /* Non-NULL emitter object expected. */
353 memset(emitter, 0, sizeof(yaml_emitter_t));
354 if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE))
355 goto error;
356 if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
357 goto error;
358 if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE))
359 goto error;
360 if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE))
361 goto error;
362 if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE))
363 goto error;
364 if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE))
365 goto error;
367 return 1;
369error:
371 BUFFER_DEL(emitter, emitter->buffer);
372 BUFFER_DEL(emitter, emitter->raw_buffer);
373 STACK_DEL(emitter, emitter->states);
374 QUEUE_DEL(emitter, emitter->events);
375 STACK_DEL(emitter, emitter->indents);
376 STACK_DEL(emitter, emitter->tag_directives);
378 return 0;
381/*
382 * Destroy an emitter object.
383 */
385YAML_DECLARE(void)
386yaml_emitter_delete(yaml_emitter_t *emitter)
388 assert(emitter); /* Non-NULL emitter object expected. */
390 BUFFER_DEL(emitter, emitter->buffer);
391 BUFFER_DEL(emitter, emitter->raw_buffer);
392 STACK_DEL(emitter, emitter->states);
393 while (!QUEUE_EMPTY(emitter, emitter->events)) {
394 yaml_event_delete(&DEQUEUE(emitter, emitter->events));
395 }
396 QUEUE_DEL(emitter, emitter->events);
397 STACK_DEL(emitter, emitter->indents);
398 while (!STACK_EMPTY(empty, emitter->tag_directives)) {
399 yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
400 yaml_free(tag_directive.handle);
401 yaml_free(tag_directive.prefix);
402 }
403 STACK_DEL(emitter, emitter->tag_directives);
404 yaml_free(emitter->anchors);
406 memset(emitter, 0, sizeof(yaml_emitter_t));
409/*
410 * String write handler.
411 */
413static int
414yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
416 yaml_emitter_t *emitter = data;
418 if (emitter->output.string.size + *emitter->output.string.size_written
419 < size) {
420 memcpy(emitter->output.string.buffer
421 + *emitter->output.string.size_written,
422 buffer,
423 emitter->output.string.size
424 - *emitter->output.string.size_written);
425 *emitter->output.string.size_written = emitter->output.string.size;
426 return 0;
427 }
429 memcpy(emitter->output.string.buffer
430 + *emitter->output.string.size_written, buffer, size);
431 *emitter->output.string.size_written += size;
432 return 1;
435/*
436 * File write handler.
437 */
439static int
440yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
442 yaml_emitter_t *emitter = data;
444 return (fwrite(buffer, 1, size, emitter->output.file) == size);
446/*
447 * Set a string output.
448 */
450YAML_DECLARE(void)
451yaml_emitter_set_output_string(yaml_emitter_t *emitter,
452 unsigned char *output, size_t size, size_t *size_written)
454 assert(emitter); /* Non-NULL emitter object expected. */
455 assert(!emitter->write_handler); /* You can set the output only once. */
456 assert(output); /* Non-NULL output string expected. */
458 emitter->write_handler = yaml_string_write_handler;
459 emitter->write_handler_data = emitter;
461 emitter->output.string.buffer = output;
462 emitter->output.string.size = size;
463 emitter->output.string.size_written = size_written;
464 *size_written = 0;
467/*
468 * Set a file output.
469 */
471YAML_DECLARE(void)
472yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
474 assert(emitter); /* Non-NULL emitter object expected. */
475 assert(!emitter->write_handler); /* You can set the output only once. */
476 assert(file); /* Non-NULL file object expected. */
478 emitter->write_handler = yaml_file_write_handler;
479 emitter->write_handler_data = emitter;
481 emitter->output.file = file;
484/*
485 * Set a generic output handler.
486 */
488YAML_DECLARE(void)
489yaml_emitter_set_output(yaml_emitter_t *emitter,
490 yaml_write_handler_t *handler, void *data)
492 assert(emitter); /* Non-NULL emitter object expected. */
493 assert(!emitter->write_handler); /* You can set the output only once. */
494 assert(handler); /* Non-NULL handler object expected. */
496 emitter->write_handler = handler;
497 emitter->write_handler_data = data;
500/*
501 * Set the output encoding.
502 */
504YAML_DECLARE(void)
505yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding)
507 assert(emitter); /* Non-NULL emitter object expected. */
508 assert(!emitter->encoding); /* You can set encoding only once. */
510 emitter->encoding = encoding;
513/*
514 * Set the canonical output style.
515 */
517YAML_DECLARE(void)
518yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
520 assert(emitter); /* Non-NULL emitter object expected. */
522 emitter->canonical = (canonical != 0);
525/*
526 * Set the indentation increment.
527 */
529YAML_DECLARE(void)
530yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
532 assert(emitter); /* Non-NULL emitter object expected. */
534 emitter->best_indent = (1 < indent && indent < 10) ? indent : 2;
537/*
538 * Set the preferred line width.
539 */
541YAML_DECLARE(void)
542yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
544 assert(emitter); /* Non-NULL emitter object expected. */
546 emitter->best_width = (width >= 0) ? width : -1;
549/*
550 * Set if unescaped non-ASCII characters are allowed.
551 */
553YAML_DECLARE(void)
554yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
556 assert(emitter); /* Non-NULL emitter object expected. */
558 emitter->unicode = (unicode != 0);
561/*
562 * Set the preferred line break character.
563 */
565YAML_DECLARE(void)
566yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
568 assert(emitter); /* Non-NULL emitter object expected. */
570 emitter->line_break = line_break;
573/*
574 * Destroy a token object.
575 */
577YAML_DECLARE(void)
578yaml_token_delete(yaml_token_t *token)
580 assert(token); /* Non-NULL token object expected. */
582 switch (token->type)
583 {
584 case YAML_TAG_DIRECTIVE_TOKEN:
585 yaml_free(token->data.tag_directive.handle);
586 yaml_free(token->data.tag_directive.prefix);
587 break;
589 case YAML_ALIAS_TOKEN:
590 yaml_free(token->data.alias.value);
591 break;
593 case YAML_ANCHOR_TOKEN:
594 yaml_free(token->data.anchor.value);
595 break;
597 case YAML_TAG_TOKEN:
598 yaml_free(token->data.tag.handle);
599 yaml_free(token->data.tag.suffix);
600 break;
602 case YAML_SCALAR_TOKEN:
603 yaml_free(token->data.scalar.value);
604 break;
606 default:
607 break;
608 }
610 memset(token, 0, sizeof(yaml_token_t));
613/*
614 * Check if a string is a valid UTF-8 sequence.
615 *
616 * Check 'reader.c' for more details on UTF-8 encoding.
617 */
619static int
620yaml_check_utf8(yaml_char_t *start, size_t length)
622 yaml_char_t *end = start+length;
623 yaml_char_t *pointer = start;
625 while (pointer < end) {
626 unsigned char octet;
627 unsigned int width;
628 unsigned int value;
629 size_t k;
631 octet = pointer[0];
632 width = (octet & 0x80) == 0x00 ? 1 :
633 (octet & 0xE0) == 0xC0 ? 2 :
634 (octet & 0xF0) == 0xE0 ? 3 :
635 (octet & 0xF8) == 0xF0 ? 4 : 0;
636 value = (octet & 0x80) == 0x00 ? octet & 0x7F :
637 (octet & 0xE0) == 0xC0 ? octet & 0x1F :
638 (octet & 0xF0) == 0xE0 ? octet & 0x0F :
639 (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
640 if (!width) return 0;
641 if (pointer+width > end) return 0;
642 for (k = 1; k < width; k ++) {
643 octet = pointer[k];
644 if ((octet & 0xC0) != 0x80) return 0;
645 value = (value << 6) + (octet & 0x3F);
646 }
647 if (!((width == 1) ||
648 (width == 2 && value >= 0x80) ||
649 (width == 3 && value >= 0x800) ||
650 (width == 4 && value >= 0x10000))) return 0;
652 pointer += width;
653 }
655 return 1;
658/*
659 * Create STREAM-START.
660 */
662YAML_DECLARE(int)
663yaml_stream_start_event_initialize(yaml_event_t *event,
664 yaml_encoding_t encoding)
666 yaml_mark_t mark = { 0, 0, 0 };
668 assert(event); /* Non-NULL event object is expected. */
670 STREAM_START_EVENT_INIT(*event, encoding, mark, mark);
672 return 1;
675/*
676 * Create STREAM-END.
677 */
679YAML_DECLARE(int)
680yaml_stream_end_event_initialize(yaml_event_t *event)
682 yaml_mark_t mark = { 0, 0, 0 };
684 assert(event); /* Non-NULL event object is expected. */
686 STREAM_END_EVENT_INIT(*event, mark, mark);
688 return 1;
691/*
692 * Create DOCUMENT-START.
693 */
695YAML_DECLARE(int)
696yaml_document_start_event_initialize(yaml_event_t *event,
697 yaml_version_directive_t *version_directive,
698 yaml_tag_directive_t *tag_directives_start,
699 yaml_tag_directive_t *tag_directives_end,
700 int implicit)
702 struct {
703 yaml_error_type_t error;
704 } context;
705 yaml_mark_t mark = { 0, 0, 0 };
706 yaml_version_directive_t *version_directive_copy = NULL;
707 struct {
708 yaml_tag_directive_t *start;
709 yaml_tag_directive_t *end;
710 yaml_tag_directive_t *top;
711 } tag_directives_copy = { NULL, NULL, NULL };
712 yaml_tag_directive_t value = { NULL, NULL };
714 assert(event); /* Non-NULL event object is expected. */
715 assert((tag_directives_start && tag_directives_end) ||
716 (tag_directives_start == tag_directives_end));
717 /* Valid tag directives are expected. */
719 if (version_directive) {
720 version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
721 if (!version_directive_copy) goto error;
722 version_directive_copy->major = version_directive->major;
723 version_directive_copy->minor = version_directive->minor;
724 }
726 if (tag_directives_start != tag_directives_end) {
727 yaml_tag_directive_t *tag_directive;
728 if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
729 goto error;
730 for (tag_directive = tag_directives_start;
731 tag_directive != tag_directives_end; tag_directive ++) {
732 assert(tag_directive->handle);
733 assert(tag_directive->prefix);
734 if (!yaml_check_utf8(tag_directive->handle,
735 strlen((char *)tag_directive->handle)))
736 goto error;
737 if (!yaml_check_utf8(tag_directive->prefix,
738 strlen((char *)tag_directive->prefix)))
739 goto error;
740 value.handle = yaml_strdup(tag_directive->handle);
741 value.prefix = yaml_strdup(tag_directive->prefix);
742 if (!value.handle || !value.prefix) goto error;
743 if (!PUSH(&context, tag_directives_copy, value))
744 goto error;
745 value.handle = NULL;
746 value.prefix = NULL;
747 }
748 }
750 DOCUMENT_START_EVENT_INIT(*event, version_directive_copy,
751 tag_directives_copy.start, tag_directives_copy.top,
752 implicit, mark, mark);
754 return 1;
756error:
757 yaml_free(version_directive_copy);
758 while (!STACK_EMPTY(context, tag_directives_copy)) {
759 yaml_tag_directive_t value = POP(context, tag_directives_copy);
760 yaml_free(value.handle);
761 yaml_free(value.prefix);
762 }
763 STACK_DEL(context, tag_directives_copy);
764 yaml_free(value.handle);
765 yaml_free(value.prefix);
767 return 0;
770/*
771 * Create DOCUMENT-END.
772 */
774YAML_DECLARE(int)
775yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
777 yaml_mark_t mark = { 0, 0, 0 };
779 assert(event); /* Non-NULL emitter object is expected. */
781 DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark);
783 return 1;
786/*
787 * Create ALIAS.
788 */
790YAML_DECLARE(int)
791yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
793 yaml_mark_t mark = { 0, 0, 0 };
794 yaml_char_t *anchor_copy = NULL;
796 assert(event); /* Non-NULL event object is expected. */
797 assert(anchor); /* Non-NULL anchor is expected. */
799 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;
801 anchor_copy = yaml_strdup(anchor);
802 if (!anchor_copy)
803 return 0;
805 ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);
807 return 1;
810/*
811 * Create SCALAR.
812 */
814YAML_DECLARE(int)
815yaml_scalar_event_initialize(yaml_event_t *event,
816 yaml_char_t *anchor, yaml_char_t *tag,
817 yaml_char_t *value, int length,
818 int plain_implicit, int quoted_implicit,
819 yaml_scalar_style_t style)
821 yaml_mark_t mark = { 0, 0, 0 };
822 yaml_char_t *anchor_copy = NULL;
823 yaml_char_t *tag_copy = NULL;
824 yaml_char_t *value_copy = NULL;
826 assert(event); /* Non-NULL event object is expected. */
827 /* following line added for Haskell yaml library */
828 if (!value && !length) value = "";
829 assert(value); /* Non-NULL anchor is expected. */
831 if (anchor) {
832 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
833 anchor_copy = yaml_strdup(anchor);
834 if (!anchor_copy) goto error;
835 }
837 if (tag) {
838 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
839 tag_copy = yaml_strdup(tag);
840 if (!tag_copy) goto error;
841 }
843 if (length < 0) {
844 length = strlen((char *)value);
845 }
847 if (!yaml_check_utf8(value, length)) goto error;
848 value_copy = yaml_malloc(length+1);
849 if (!value_copy) goto error;
850 memcpy(value_copy, value, length);
851 value_copy[length] = '\0';
853 SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length,
854 plain_implicit, quoted_implicit, style, mark, mark);
856 return 1;
858error:
859 yaml_free(anchor_copy);
860 yaml_free(tag_copy);
861 yaml_free(value_copy);
863 return 0;
866/*
867 * Create SEQUENCE-START.
868 */
870YAML_DECLARE(int)
871yaml_sequence_start_event_initialize(yaml_event_t *event,
872 yaml_char_t *anchor, yaml_char_t *tag, int implicit,
873 yaml_sequence_style_t style)
875 yaml_mark_t mark = { 0, 0, 0 };
876 yaml_char_t *anchor_copy = NULL;
877 yaml_char_t *tag_copy = NULL;
879 assert(event); /* Non-NULL event object is expected. */
881 if (anchor) {
882 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
883 anchor_copy = yaml_strdup(anchor);
884 if (!anchor_copy) goto error;
885 }
887 if (tag) {
888 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
889 tag_copy = yaml_strdup(tag);
890 if (!tag_copy) goto error;
891 }
893 SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy,
894 implicit, style, mark, mark);
896 return 1;
898error:
899 yaml_free(anchor_copy);
900 yaml_free(tag_copy);
902 return 0;
905/*
906 * Create SEQUENCE-END.
907 */
909YAML_DECLARE(int)
910yaml_sequence_end_event_initialize(yaml_event_t *event)
912 yaml_mark_t mark = { 0, 0, 0 };
914 assert(event); /* Non-NULL event object is expected. */
916 SEQUENCE_END_EVENT_INIT(*event, mark, mark);
918 return 1;
921/*
922 * Create MAPPING-START.
923 */
925YAML_DECLARE(int)
926yaml_mapping_start_event_initialize(yaml_event_t *event,
927 yaml_char_t *anchor, yaml_char_t *tag, int implicit,
928 yaml_mapping_style_t style)
930 yaml_mark_t mark = { 0, 0, 0 };
931 yaml_char_t *anchor_copy = NULL;
932 yaml_char_t *tag_copy = NULL;
934 assert(event); /* Non-NULL event object is expected. */
936 if (anchor) {
937 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
938 anchor_copy = yaml_strdup(anchor);
939 if (!anchor_copy) goto error;
940 }
942 if (tag) {
943 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
944 tag_copy = yaml_strdup(tag);
945 if (!tag_copy) goto error;
946 }
948 MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy,
949 implicit, style, mark, mark);
951 return 1;
953error:
954 yaml_free(anchor_copy);
955 yaml_free(tag_copy);
957 return 0;
960/*
961 * Create MAPPING-END.
962 */
964YAML_DECLARE(int)
965yaml_mapping_end_event_initialize(yaml_event_t *event)
967 yaml_mark_t mark = { 0, 0, 0 };
969 assert(event); /* Non-NULL event object is expected. */
971 MAPPING_END_EVENT_INIT(*event, mark, mark);
973 return 1;
976/*
977 * Destroy an event object.
978 */
980YAML_DECLARE(void)
981yaml_event_delete(yaml_event_t *event)
983 yaml_tag_directive_t *tag_directive;
985 assert(event); /* Non-NULL event object expected. */
987 switch (event->type)
988 {
989 case YAML_DOCUMENT_START_EVENT:
990 yaml_free(event->data.document_start.version_directive);
991 for (tag_directive = event->data.document_start.tag_directives.start;
992 tag_directive != event->data.document_start.tag_directives.end;
993 tag_directive++) {
994 yaml_free(tag_directive->handle);
995 yaml_free(tag_directive->prefix);
996 }
997 yaml_free(event->data.document_start.tag_directives.start);
998 break;
1000 case YAML_ALIAS_EVENT:
1001 yaml_free(event->data.alias.anchor);
1002 break;
1004 case YAML_SCALAR_EVENT:
1005 yaml_free(event->data.scalar.anchor);
1006 yaml_free(event->data.scalar.tag);
1007 yaml_free(event->data.scalar.value);
1008 break;
1010 case YAML_SEQUENCE_START_EVENT:
1011 yaml_free(event->data.sequence_start.anchor);
1012 yaml_free(event->data.sequence_start.tag);
1013 break;
1015 case YAML_MAPPING_START_EVENT:
1016 yaml_free(event->data.mapping_start.anchor);
1017 yaml_free(event->data.mapping_start.tag);
1018 break;
1020 default:
1021 break;
1024 memset(event, 0, sizeof(yaml_event_t));
1028 * Create a document object.
1029 */
1031YAML_DECLARE(int)
1032yaml_document_initialize(yaml_document_t *document,
1033 yaml_version_directive_t *version_directive,
1034 yaml_tag_directive_t *tag_directives_start,
1035 yaml_tag_directive_t *tag_directives_end,
1036 int start_implicit, int end_implicit)
1038 struct {
1039 yaml_error_type_t error;
1040 } context;
1041 struct {
1042 yaml_node_t *start;
1043 yaml_node_t *end;
1044 yaml_node_t *top;
1045 } nodes = { NULL, NULL, NULL };
1046 yaml_version_directive_t *version_directive_copy = NULL;
1047 struct {
1048 yaml_tag_directive_t *start;
1049 yaml_tag_directive_t *end;
1050 yaml_tag_directive_t *top;
1051 } tag_directives_copy = { NULL, NULL, NULL };
1052 yaml_tag_directive_t value = { NULL, NULL };
1053 yaml_mark_t mark = { 0, 0, 0 };
1055 assert(document); /* Non-NULL document object is expected. */
1056 assert((tag_directives_start && tag_directives_end) ||
1057 (tag_directives_start == tag_directives_end));
1058 /* Valid tag directives are expected. */
1060 if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error;
1062 if (version_directive) {
1063 version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
1064 if (!version_directive_copy) goto error;
1065 version_directive_copy->major = version_directive->major;
1066 version_directive_copy->minor = version_directive->minor;
1069 if (tag_directives_start != tag_directives_end) {
1070 yaml_tag_directive_t *tag_directive;
1071 if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
1072 goto error;
1073 for (tag_directive = tag_directives_start;
1074 tag_directive != tag_directives_end; tag_directive ++) {
1075 assert(tag_directive->handle);
1076 assert(tag_directive->prefix);
1077 if (!yaml_check_utf8(tag_directive->handle,
1078 strlen((char *)tag_directive->handle)))
1079 goto error;
1080 if (!yaml_check_utf8(tag_directive->prefix,
1081 strlen((char *)tag_directive->prefix)))
1082 goto error;
1083 value.handle = yaml_strdup(tag_directive->handle);
1084 value.prefix = yaml_strdup(tag_directive->prefix);
1085 if (!value.handle || !value.prefix) goto error;
1086 if (!PUSH(&context, tag_directives_copy, value))
1087 goto error;
1088 value.handle = NULL;
1089 value.prefix = NULL;
1093 DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
1094 tag_directives_copy.start, tag_directives_copy.top,
1095 start_implicit, end_implicit, mark, mark);
1097 return 1;
1099error:
1100 STACK_DEL(&context, nodes);
1101 yaml_free(version_directive_copy);
1102 while (!STACK_EMPTY(&context, tag_directives_copy)) {
1103 yaml_tag_directive_t value = POP(&context, tag_directives_copy);
1104 yaml_free(value.handle);
1105 yaml_free(value.prefix);
1107 STACK_DEL(&context, tag_directives_copy);
1108 yaml_free(value.handle);
1109 yaml_free(value.prefix);
1111 return 0;
1115 * Destroy a document object.
1116 */
1118YAML_DECLARE(void)
1119yaml_document_delete(yaml_document_t *document)
1121 struct {
1122 yaml_error_type_t error;
1123 } context;
1124 yaml_tag_directive_t *tag_directive;
1126 context.error = YAML_NO_ERROR; /* Eliminate a compliler warning. */
1128 assert(document); /* Non-NULL document object is expected. */
1130 while (!STACK_EMPTY(&context, document->nodes)) {
1131 yaml_node_t node = POP(&context, document->nodes);
1132 yaml_free(node.tag);
1133 switch (node.type) {
1134 case YAML_SCALAR_NODE:
1135 yaml_free(node.data.scalar.value);
1136 break;
1137 case YAML_SEQUENCE_NODE:
1138 STACK_DEL(&context, node.data.sequence.items);
1139 break;
1140 case YAML_MAPPING_NODE:
1141 STACK_DEL(&context, node.data.mapping.pairs);
1142 break;
1143 default:
1144 assert(0); /* Should not happen. */
1147 STACK_DEL(&context, document->nodes);
1149 yaml_free(document->version_directive);
1150 for (tag_directive = document->tag_directives.start;
1151 tag_directive != document->tag_directives.end;
1152 tag_directive++) {
1153 yaml_free(tag_directive->handle);
1154 yaml_free(tag_directive->prefix);
1156 yaml_free(document->tag_directives.start);
1158 memset(document, 0, sizeof(yaml_document_t));
1161/**
1162 * Get a document node.
1163 */
1165YAML_DECLARE(yaml_node_t *)
1166yaml_document_get_node(yaml_document_t *document, int index)
1168 assert(document); /* Non-NULL document object is expected. */
1170 if (index > 0 && document->nodes.start + index <= document->nodes.top) {
1171 return document->nodes.start + index - 1;
1173 return NULL;
1176/**
1177 * Get the root object.
1178 */
1180YAML_DECLARE(yaml_node_t *)
1181yaml_document_get_root_node(yaml_document_t *document)
1183 assert(document); /* Non-NULL document object is expected. */
1185 if (document->nodes.top != document->nodes.start) {
1186 return document->nodes.start;
1188 return NULL;
1192 * Add a scalar node to a document.
1193 */
1195YAML_DECLARE(int)
1196yaml_document_add_scalar(yaml_document_t *document,
1197 yaml_char_t *tag, yaml_char_t *value, int length,
1198 yaml_scalar_style_t style)
1200 struct {
1201 yaml_error_type_t error;
1202 } context;
1203 yaml_mark_t mark = { 0, 0, 0 };
1204 yaml_char_t *tag_copy = NULL;
1205 yaml_char_t *value_copy = NULL;
1206 yaml_node_t node;
1208 assert(document); /* Non-NULL document object is expected. */
1209 assert(value); /* Non-NULL value is expected. */
1211 if (!tag) {
1212 tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG;
1215 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1216 tag_copy = yaml_strdup(tag);
1217 if (!tag_copy) goto error;
1219 if (length < 0) {
1220 length = strlen((char *)value);
1223 if (!yaml_check_utf8(value, length)) goto error;
1224 value_copy = yaml_malloc(length+1);
1225 if (!value_copy) goto error;
1226 memcpy(value_copy, value, length);
1227 value_copy[length] = '\0';
1229 SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark);
1230 if (!PUSH(&context, document->nodes, node)) goto error;
1232 return document->nodes.top - document->nodes.start;
1234error:
1235 yaml_free(tag_copy);
1236 yaml_free(value_copy);
1238 return 0;
1242 * Add a sequence node to a document.
1243 */
1245YAML_DECLARE(int)
1246yaml_document_add_sequence(yaml_document_t *document,
1247 yaml_char_t *tag, yaml_sequence_style_t style)
1249 struct {
1250 yaml_error_type_t error;
1251 } context;
1252 yaml_mark_t mark = { 0, 0, 0 };
1253 yaml_char_t *tag_copy = NULL;
1254 struct {
1255 yaml_node_item_t *start;
1256 yaml_node_item_t *end;
1257 yaml_node_item_t *top;
1258 } items = { NULL, NULL, NULL };
1259 yaml_node_t node;
1261 assert(document); /* Non-NULL document object is expected. */
1263 if (!tag) {
1264 tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG;
1267 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1268 tag_copy = yaml_strdup(tag);
1269 if (!tag_copy) goto error;
1271 if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error;
1273 SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
1274 style, mark, mark);
1275 if (!PUSH(&context, document->nodes, node)) goto error;
1277 return document->nodes.top - document->nodes.start;
1279error:
1280 STACK_DEL(&context, items);
1281 yaml_free(tag_copy);
1283 return 0;
1287 * Add a mapping node to a document.
1288 */
1290YAML_DECLARE(int)
1291yaml_document_add_mapping(yaml_document_t *document,
1292 yaml_char_t *tag, yaml_mapping_style_t style)
1294 struct {
1295 yaml_error_type_t error;
1296 } context;
1297 yaml_mark_t mark = { 0, 0, 0 };
1298 yaml_char_t *tag_copy = NULL;
1299 struct {
1300 yaml_node_pair_t *start;
1301 yaml_node_pair_t *end;
1302 yaml_node_pair_t *top;
1303 } pairs = { NULL, NULL, NULL };
1304 yaml_node_t node;
1306 assert(document); /* Non-NULL document object is expected. */
1308 if (!tag) {
1309 tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG;
1312 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1313 tag_copy = yaml_strdup(tag);
1314 if (!tag_copy) goto error;
1316 if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error;
1318 MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
1319 style, mark, mark);
1320 if (!PUSH(&context, document->nodes, node)) goto error;
1322 return document->nodes.top - document->nodes.start;
1324error:
1325 STACK_DEL(&context, pairs);
1326 yaml_free(tag_copy);
1328 return 0;
1332 * Append an item to a sequence node.
1333 */
1335YAML_DECLARE(int)
1336yaml_document_append_sequence_item(yaml_document_t *document,
1337 int sequence, int item)
1339 struct {
1340 yaml_error_type_t error;
1341 } context;
1343 assert(document); /* Non-NULL document is required. */
1344 assert(sequence > 0
1345 && document->nodes.start + sequence <= document->nodes.top);
1346 /* Valid sequence id is required. */
1347 assert(document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE);
1348 /* A sequence node is required. */
1349 assert(item > 0 && document->nodes.start + item <= document->nodes.top);
1350 /* Valid item id is required. */
1352 if (!PUSH(&context,
1353 document->nodes.start[sequence-1].data.sequence.items, item))
1354 return 0;
1356 return 1;
1360 * Append a pair of a key and a value to a mapping node.
1361 */
1363YAML_DECLARE(int)
1364yaml_document_append_mapping_pair(yaml_document_t *document,
1365 int mapping, int key, int value)
1367 struct {
1368 yaml_error_type_t error;
1369 } context;
1370 yaml_node_pair_t pair = { key, value };
1372 assert(document); /* Non-NULL document is required. */
1373 assert(mapping > 0
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. */
1383 if (!PUSH(&context,
1384 document->nodes.start[mapping-1].data.mapping.pairs, pair))
1385 return 0;
1387 return 1;