git.iko.soy/typeable/yaml
on 2736d21 help sign in
typeable/yaml/libyaml/api.c
1401 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/*
67 * Haskell yaml package: added to support _WIN64
68 */
69#if _WIN64
70 return (yaml_char_t *)_strdup((char *)str);
71#else
72 return (yaml_char_t *)strdup((char *)str);
73#endif
76/*
77 * Extend a string.
78 */
80YAML_DECLARE(int)
81yaml_string_extend(yaml_char_t **start,
82 yaml_char_t **pointer, yaml_char_t **end)
84 yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2);
86 if (!new_start) return 0;
88 memset(new_start + (*end - *start), 0, *end - *start);
90 *pointer = new_start + (*pointer - *start);
91 *end = new_start + (*end - *start)*2;
92 *start = new_start;
94 return 1;
97/*
98 * Append a string B to a string A.
99 */
101YAML_DECLARE(int)
102yaml_string_join(
103 yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
104 yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end)
106 if (*b_start == *b_pointer)
107 return 1;
109 while (*a_end - *a_pointer <= *b_pointer - *b_start) {
110 if (!yaml_string_extend(a_start, a_pointer, a_end))
111 return 0;
112 }
114 memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
115 *a_pointer += *b_pointer - *b_start;
117 return 1;
120/*
121 * Extend a stack.
122 */
124YAML_DECLARE(int)
125yaml_stack_extend(void **start, void **top, void **end)
127 void *new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2);
129 if (!new_start) return 0;
131 *top = (char *)new_start + ((char *)*top - (char *)*start);
132 *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
133 *start = new_start;
135 return 1;
138/*
139 * Extend or move a queue.
140 */
142YAML_DECLARE(int)
143yaml_queue_extend(void **start, void **head, void **tail, void **end)
145 /* Check if we need to resize the queue. */
147 if (*start == *head && *tail == *end) {
148 void *new_start = yaml_realloc(*start,
149 ((char *)*end - (char *)*start)*2);
151 if (!new_start) return 0;
153 *head = (char *)new_start + ((char *)*head - (char *)*start);
154 *tail = (char *)new_start + ((char *)*tail - (char *)*start);
155 *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
156 *start = new_start;
157 }
159 /* Check if we need to move the queue at the beginning of the buffer. */
161 if (*tail == *end) {
162 if (*head != *tail) {
163 memmove(*start, *head, (char *)*tail - (char *)*head);
164 }
165 *tail = (char *)*tail - (char *)*head + (char *)*start;
166 *head = *start;
167 }
169 return 1;
173/*
174 * Create a new parser object.
175 */
177YAML_DECLARE(int)
178yaml_parser_initialize(yaml_parser_t *parser)
180 assert(parser); /* Non-NULL parser object expected. */
182 memset(parser, 0, sizeof(yaml_parser_t));
183 if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE))
184 goto error;
185 if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
186 goto error;
187 if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE))
188 goto error;
189 if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE))
190 goto error;
191 if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE))
192 goto error;
193 if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE))
194 goto error;
195 if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE))
196 goto error;
197 if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE))
198 goto error;
200 return 1;
202error:
204 BUFFER_DEL(parser, parser->raw_buffer);
205 BUFFER_DEL(parser, parser->buffer);
206 QUEUE_DEL(parser, parser->tokens);
207 STACK_DEL(parser, parser->indents);
208 STACK_DEL(parser, parser->simple_keys);
209 STACK_DEL(parser, parser->states);
210 STACK_DEL(parser, parser->marks);
211 STACK_DEL(parser, parser->tag_directives);
213 return 0;
216/*
217 * Destroy a parser object.
218 */
220YAML_DECLARE(void)
221yaml_parser_delete(yaml_parser_t *parser)
223 assert(parser); /* Non-NULL parser object expected. */
225 BUFFER_DEL(parser, parser->raw_buffer);
226 BUFFER_DEL(parser, parser->buffer);
227 while (!QUEUE_EMPTY(parser, parser->tokens)) {
228 yaml_token_delete(&DEQUEUE(parser, parser->tokens));
229 }
230 QUEUE_DEL(parser, parser->tokens);
231 STACK_DEL(parser, parser->indents);
232 STACK_DEL(parser, parser->simple_keys);
233 STACK_DEL(parser, parser->states);
234 STACK_DEL(parser, parser->marks);
235 while (!STACK_EMPTY(parser, parser->tag_directives)) {
236 yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
237 yaml_free(tag_directive.handle);
238 yaml_free(tag_directive.prefix);
239 }
240 STACK_DEL(parser, parser->tag_directives);
242 memset(parser, 0, sizeof(yaml_parser_t));
245/*
246 * String read handler.
247 */
249static int
250yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
251 size_t *size_read)
253 yaml_parser_t *parser = data;
255 if (parser->input.string.current == parser->input.string.end) {
256 *size_read = 0;
257 return 1;
258 }
260 if (size > (size_t)(parser->input.string.end
261 - parser->input.string.current)) {
262 size = parser->input.string.end - parser->input.string.current;
263 }
265 memcpy(buffer, parser->input.string.current, size);
266 parser->input.string.current += size;
267 *size_read = size;
268 return 1;
271/*
272 * File read handler.
273 */
275static int
276yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
277 size_t *size_read)
279 yaml_parser_t *parser = data;
281 *size_read = fread(buffer, 1, size, parser->input.file);
282 return !ferror(parser->input.file);
285/*
286 * Set a string input.
287 */
289YAML_DECLARE(void)
290yaml_parser_set_input_string(yaml_parser_t *parser,
291 const unsigned char *input, size_t size)
293 assert(parser); /* Non-NULL parser object expected. */
294 assert(!parser->read_handler); /* You can set the source only once. */
295 assert(input); /* Non-NULL input string expected. */
297 parser->read_handler = yaml_string_read_handler;
298 parser->read_handler_data = parser;
300 parser->input.string.start = input;
301 parser->input.string.current = input;
302 parser->input.string.end = input+size;
305/*
306 * Set a file input.
307 */
309YAML_DECLARE(void)
310yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
312 assert(parser); /* Non-NULL parser object expected. */
313 assert(!parser->read_handler); /* You can set the source only once. */
314 assert(file); /* Non-NULL file object expected. */
316 parser->read_handler = yaml_file_read_handler;
317 parser->read_handler_data = parser;
319 parser->input.file = file;
322/*
323 * Set a generic input.
324 */
326YAML_DECLARE(void)
327yaml_parser_set_input(yaml_parser_t *parser,
328 yaml_read_handler_t *handler, void *data)
330 assert(parser); /* Non-NULL parser object expected. */
331 assert(!parser->read_handler); /* You can set the source only once. */
332 assert(handler); /* Non-NULL read handler expected. */
334 parser->read_handler = handler;
335 parser->read_handler_data = data;
338/*
339 * Set the source encoding.
340 */
342YAML_DECLARE(void)
343yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
345 assert(parser); /* Non-NULL parser object expected. */
346 assert(!parser->encoding); /* Encoding is already set or detected. */
348 parser->encoding = encoding;
351/*
352 * Create a new emitter object.
353 */
355YAML_DECLARE(int)
356yaml_emitter_initialize(yaml_emitter_t *emitter)
358 assert(emitter); /* Non-NULL emitter object expected. */
360 memset(emitter, 0, sizeof(yaml_emitter_t));
361 if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE))
362 goto error;
363 if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
364 goto error;
365 if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE))
366 goto error;
367 if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE))
368 goto error;
369 if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE))
370 goto error;
371 if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE))
372 goto error;
374 return 1;
376error:
378 BUFFER_DEL(emitter, emitter->buffer);
379 BUFFER_DEL(emitter, emitter->raw_buffer);
380 STACK_DEL(emitter, emitter->states);
381 QUEUE_DEL(emitter, emitter->events);
382 STACK_DEL(emitter, emitter->indents);
383 STACK_DEL(emitter, emitter->tag_directives);
385 return 0;
388/*
389 * Destroy an emitter object.
390 */
392YAML_DECLARE(void)
393yaml_emitter_delete(yaml_emitter_t *emitter)
395 assert(emitter); /* Non-NULL emitter object expected. */
397 BUFFER_DEL(emitter, emitter->buffer);
398 BUFFER_DEL(emitter, emitter->raw_buffer);
399 STACK_DEL(emitter, emitter->states);
400 while (!QUEUE_EMPTY(emitter, emitter->events)) {
401 yaml_event_delete(&DEQUEUE(emitter, emitter->events));
402 }
403 QUEUE_DEL(emitter, emitter->events);
404 STACK_DEL(emitter, emitter->indents);
405 while (!STACK_EMPTY(empty, emitter->tag_directives)) {
406 yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
407 yaml_free(tag_directive.handle);
408 yaml_free(tag_directive.prefix);
409 }
410 STACK_DEL(emitter, emitter->tag_directives);
411 yaml_free(emitter->anchors);
413 memset(emitter, 0, sizeof(yaml_emitter_t));
416/*
417 * String write handler.
418 */
420static int
421yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
423 yaml_emitter_t *emitter = data;
425 if (emitter->output.string.size - *emitter->output.string.size_written
426 < size) {
427 memcpy(emitter->output.string.buffer
428 + *emitter->output.string.size_written,
429 buffer,
430 emitter->output.string.size
431 - *emitter->output.string.size_written);
432 *emitter->output.string.size_written = emitter->output.string.size;
433 return 0;
434 }
436 memcpy(emitter->output.string.buffer
437 + *emitter->output.string.size_written, buffer, size);
438 *emitter->output.string.size_written += size;
439 return 1;
442/*
443 * File write handler.
444 */
446static int
447yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
449 yaml_emitter_t *emitter = data;
451 return (fwrite(buffer, 1, size, emitter->output.file) == size);
453/*
454 * Set a string output.
455 */
457YAML_DECLARE(void)
458yaml_emitter_set_output_string(yaml_emitter_t *emitter,
459 unsigned char *output, size_t size, size_t *size_written)
461 assert(emitter); /* Non-NULL emitter object expected. */
462 assert(!emitter->write_handler); /* You can set the output only once. */
463 assert(output); /* Non-NULL output string expected. */
465 emitter->write_handler = yaml_string_write_handler;
466 emitter->write_handler_data = emitter;
468 emitter->output.string.buffer = output;
469 emitter->output.string.size = size;
470 emitter->output.string.size_written = size_written;
471 *size_written = 0;
474/*
475 * Set a file output.
476 */
478YAML_DECLARE(void)
479yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
481 assert(emitter); /* Non-NULL emitter object expected. */
482 assert(!emitter->write_handler); /* You can set the output only once. */
483 assert(file); /* Non-NULL file object expected. */
485 emitter->write_handler = yaml_file_write_handler;
486 emitter->write_handler_data = emitter;
488 emitter->output.file = file;
491/*
492 * Set a generic output handler.
493 */
495YAML_DECLARE(void)
496yaml_emitter_set_output(yaml_emitter_t *emitter,
497 yaml_write_handler_t *handler, void *data)
499 assert(emitter); /* Non-NULL emitter object expected. */
500 assert(!emitter->write_handler); /* You can set the output only once. */
501 assert(handler); /* Non-NULL handler object expected. */
503 emitter->write_handler = handler;
504 emitter->write_handler_data = data;
507/*
508 * Set the output encoding.
509 */
511YAML_DECLARE(void)
512yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding)
514 assert(emitter); /* Non-NULL emitter object expected. */
515 assert(!emitter->encoding); /* You can set encoding only once. */
517 emitter->encoding = encoding;
520/*
521 * Set the canonical output style.
522 */
524YAML_DECLARE(void)
525yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
527 assert(emitter); /* Non-NULL emitter object expected. */
529 emitter->canonical = (canonical != 0);
532/*
533 * Set the indentation increment.
534 */
536YAML_DECLARE(void)
537yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
539 assert(emitter); /* Non-NULL emitter object expected. */
541 emitter->best_indent = (1 < indent && indent < 10) ? indent : 2;
544/*
545 * Set the preferred line width.
546 */
548YAML_DECLARE(void)
549yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
551 assert(emitter); /* Non-NULL emitter object expected. */
553 emitter->best_width = (width >= 0) ? width : -1;
556/*
557 * Set if unescaped non-ASCII characters are allowed.
558 */
560YAML_DECLARE(void)
561yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
563 assert(emitter); /* Non-NULL emitter object expected. */
565 emitter->unicode = (unicode != 0);
568/*
569 * Set the preferred line break character.
570 */
572YAML_DECLARE(void)
573yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
575 assert(emitter); /* Non-NULL emitter object expected. */
577 emitter->line_break = line_break;
580/*
581 * Destroy a token object.
582 */
584YAML_DECLARE(void)
585yaml_token_delete(yaml_token_t *token)
587 assert(token); /* Non-NULL token object expected. */
589 switch (token->type)
590 {
591 case YAML_TAG_DIRECTIVE_TOKEN:
592 yaml_free(token->data.tag_directive.handle);
593 yaml_free(token->data.tag_directive.prefix);
594 break;
596 case YAML_ALIAS_TOKEN:
597 yaml_free(token->data.alias.value);
598 break;
600 case YAML_ANCHOR_TOKEN:
601 yaml_free(token->data.anchor.value);
602 break;
604 case YAML_TAG_TOKEN:
605 yaml_free(token->data.tag.handle);
606 yaml_free(token->data.tag.suffix);
607 break;
609 case YAML_SCALAR_TOKEN:
610 yaml_free(token->data.scalar.value);
611 break;
613 default:
614 break;
615 }
617 memset(token, 0, sizeof(yaml_token_t));
620/*
621 * Check if a string is a valid UTF-8 sequence.
622 *
623 * Check 'reader.c' for more details on UTF-8 encoding.
624 */
626static int
627yaml_check_utf8(yaml_char_t *start, size_t length)
629 yaml_char_t *end = start+length;
630 yaml_char_t *pointer = start;
632 while (pointer < end) {
633 unsigned char octet;
634 unsigned int width;
635 unsigned int value;
636 size_t k;
638 octet = pointer[0];
639 width = (octet & 0x80) == 0x00 ? 1 :
640 (octet & 0xE0) == 0xC0 ? 2 :
641 (octet & 0xF0) == 0xE0 ? 3 :
642 (octet & 0xF8) == 0xF0 ? 4 : 0;
643 value = (octet & 0x80) == 0x00 ? octet & 0x7F :
644 (octet & 0xE0) == 0xC0 ? octet & 0x1F :
645 (octet & 0xF0) == 0xE0 ? octet & 0x0F :
646 (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
647 if (!width) return 0;
648 if (pointer+width > end) return 0;
649 for (k = 1; k < width; k ++) {
650 octet = pointer[k];
651 if ((octet & 0xC0) != 0x80) return 0;
652 value = (value << 6) + (octet & 0x3F);
653 }
654 if (!((width == 1) ||
655 (width == 2 && value >= 0x80) ||
656 (width == 3 && value >= 0x800) ||
657 (width == 4 && value >= 0x10000))) return 0;
659 pointer += width;
660 }
662 return 1;
665/*
666 * Create STREAM-START.
667 */
669YAML_DECLARE(int)
670yaml_stream_start_event_initialize(yaml_event_t *event,
671 yaml_encoding_t encoding)
673 yaml_mark_t mark = { 0, 0, 0 };
675 assert(event); /* Non-NULL event object is expected. */
677 STREAM_START_EVENT_INIT(*event, encoding, mark, mark);
679 return 1;
682/*
683 * Create STREAM-END.
684 */
686YAML_DECLARE(int)
687yaml_stream_end_event_initialize(yaml_event_t *event)
689 yaml_mark_t mark = { 0, 0, 0 };
691 assert(event); /* Non-NULL event object is expected. */
693 STREAM_END_EVENT_INIT(*event, mark, mark);
695 return 1;
698/*
699 * Create DOCUMENT-START.
700 */
702YAML_DECLARE(int)
703yaml_document_start_event_initialize(yaml_event_t *event,
704 yaml_version_directive_t *version_directive,
705 yaml_tag_directive_t *tag_directives_start,
706 yaml_tag_directive_t *tag_directives_end,
707 int implicit)
709 struct {
710 yaml_error_type_t error;
711 } context;
712 yaml_mark_t mark = { 0, 0, 0 };
713 yaml_version_directive_t *version_directive_copy = NULL;
714 struct {
715 yaml_tag_directive_t *start;
716 yaml_tag_directive_t *end;
717 yaml_tag_directive_t *top;
718 } tag_directives_copy = { NULL, NULL, NULL };
719 yaml_tag_directive_t value = { NULL, NULL };
721 assert(event); /* Non-NULL event object is expected. */
722 assert((tag_directives_start && tag_directives_end) ||
723 (tag_directives_start == tag_directives_end));
724 /* Valid tag directives are expected. */
726 if (version_directive) {
727 version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
728 if (!version_directive_copy) goto error;
729 version_directive_copy->major = version_directive->major;
730 version_directive_copy->minor = version_directive->minor;
731 }
733 if (tag_directives_start != tag_directives_end) {
734 yaml_tag_directive_t *tag_directive;
735 if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
736 goto error;
737 for (tag_directive = tag_directives_start;
738 tag_directive != tag_directives_end; tag_directive ++) {
739 assert(tag_directive->handle);
740 assert(tag_directive->prefix);
741 if (!yaml_check_utf8(tag_directive->handle,
742 strlen((char *)tag_directive->handle)))
743 goto error;
744 if (!yaml_check_utf8(tag_directive->prefix,
745 strlen((char *)tag_directive->prefix)))
746 goto error;
747 value.handle = yaml_strdup(tag_directive->handle);
748 value.prefix = yaml_strdup(tag_directive->prefix);
749 if (!value.handle || !value.prefix) goto error;
750 if (!PUSH(&context, tag_directives_copy, value))
751 goto error;
752 value.handle = NULL;
753 value.prefix = NULL;
754 }
755 }
757 DOCUMENT_START_EVENT_INIT(*event, version_directive_copy,
758 tag_directives_copy.start, tag_directives_copy.top,
759 implicit, mark, mark);
761 return 1;
763error:
764 yaml_free(version_directive_copy);
765 while (!STACK_EMPTY(context, tag_directives_copy)) {
766 yaml_tag_directive_t value = POP(context, tag_directives_copy);
767 yaml_free(value.handle);
768 yaml_free(value.prefix);
769 }
770 STACK_DEL(context, tag_directives_copy);
771 yaml_free(value.handle);
772 yaml_free(value.prefix);
774 return 0;
777/*
778 * Create DOCUMENT-END.
779 */
781YAML_DECLARE(int)
782yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
784 yaml_mark_t mark = { 0, 0, 0 };
786 assert(event); /* Non-NULL emitter object is expected. */
788 DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark);
790 return 1;
793/*
794 * Create ALIAS.
795 */
797YAML_DECLARE(int)
798yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
800 yaml_mark_t mark = { 0, 0, 0 };
801 yaml_char_t *anchor_copy = NULL;
803 assert(event); /* Non-NULL event object is expected. */
804 assert(anchor); /* Non-NULL anchor is expected. */
806 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;
808 anchor_copy = yaml_strdup(anchor);
809 if (!anchor_copy)
810 return 0;
812 ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);
814 return 1;
817/*
818 * Create SCALAR.
819 */
821YAML_DECLARE(int)
822yaml_scalar_event_initialize(yaml_event_t *event,
823 yaml_char_t *anchor, yaml_char_t *tag,
824 yaml_char_t *value, int length,
825 int plain_implicit, int quoted_implicit,
826 yaml_scalar_style_t style)
828 yaml_mark_t mark = { 0, 0, 0 };
829 yaml_char_t *anchor_copy = NULL;
830 yaml_char_t *tag_copy = NULL;
831 yaml_char_t *value_copy = NULL;
833 assert(event); /* Non-NULL event object is expected. */
834 /* following line added for Haskell yaml library */
835 if (!value && !length) value = (unsigned char*)"";
836 assert(value); /* Non-NULL anchor is expected. */
838 if (anchor) {
839 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
840 anchor_copy = yaml_strdup(anchor);
841 if (!anchor_copy) goto error;
842 }
844 if (tag) {
845 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
846 tag_copy = yaml_strdup(tag);
847 if (!tag_copy) goto error;
848 }
850 if (length < 0) {
851 length = strlen((char *)value);
852 }
854 if (!yaml_check_utf8(value, length)) goto error;
855 value_copy = yaml_malloc(length+1);
856 if (!value_copy) goto error;
857 memcpy(value_copy, value, length);
858 value_copy[length] = '\0';
860 SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length,
861 plain_implicit, quoted_implicit, style, mark, mark);
863 return 1;
865error:
866 yaml_free(anchor_copy);
867 yaml_free(tag_copy);
868 yaml_free(value_copy);
870 return 0;
873/*
874 * Create SEQUENCE-START.
875 */
877YAML_DECLARE(int)
878yaml_sequence_start_event_initialize(yaml_event_t *event,
879 yaml_char_t *anchor, yaml_char_t *tag, int implicit,
880 yaml_sequence_style_t style)
882 yaml_mark_t mark = { 0, 0, 0 };
883 yaml_char_t *anchor_copy = NULL;
884 yaml_char_t *tag_copy = NULL;
886 assert(event); /* Non-NULL event object is expected. */
888 if (anchor) {
889 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
890 anchor_copy = yaml_strdup(anchor);
891 if (!anchor_copy) goto error;
892 }
894 if (tag) {
895 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
896 tag_copy = yaml_strdup(tag);
897 if (!tag_copy) goto error;
898 }
900 SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy,
901 implicit, style, mark, mark);
903 return 1;
905error:
906 yaml_free(anchor_copy);
907 yaml_free(tag_copy);
909 return 0;
912/*
913 * Create SEQUENCE-END.
914 */
916YAML_DECLARE(int)
917yaml_sequence_end_event_initialize(yaml_event_t *event)
919 yaml_mark_t mark = { 0, 0, 0 };
921 assert(event); /* Non-NULL event object is expected. */
923 SEQUENCE_END_EVENT_INIT(*event, mark, mark);
925 return 1;
928/*
929 * Create MAPPING-START.
930 */
932YAML_DECLARE(int)
933yaml_mapping_start_event_initialize(yaml_event_t *event,
934 yaml_char_t *anchor, yaml_char_t *tag, int implicit,
935 yaml_mapping_style_t style)
937 yaml_mark_t mark = { 0, 0, 0 };
938 yaml_char_t *anchor_copy = NULL;
939 yaml_char_t *tag_copy = NULL;
941 assert(event); /* Non-NULL event object is expected. */
943 if (anchor) {
944 if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
945 anchor_copy = yaml_strdup(anchor);
946 if (!anchor_copy) goto error;
947 }
949 if (tag) {
950 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
951 tag_copy = yaml_strdup(tag);
952 if (!tag_copy) goto error;
953 }
955 MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy,
956 implicit, style, mark, mark);
958 return 1;
960error:
961 yaml_free(anchor_copy);
962 yaml_free(tag_copy);
964 return 0;
967/*
968 * Create MAPPING-END.
969 */
971YAML_DECLARE(int)
972yaml_mapping_end_event_initialize(yaml_event_t *event)
974 yaml_mark_t mark = { 0, 0, 0 };
976 assert(event); /* Non-NULL event object is expected. */
978 MAPPING_END_EVENT_INIT(*event, mark, mark);
980 return 1;
983/*
984 * Destroy an event object.
985 */
987YAML_DECLARE(void)
988yaml_event_delete(yaml_event_t *event)
990 yaml_tag_directive_t *tag_directive;
992 assert(event); /* Non-NULL event object expected. */
994 switch (event->type)
995 {
996 case YAML_DOCUMENT_START_EVENT:
997 yaml_free(event->data.document_start.version_directive);
998 for (tag_directive = event->data.document_start.tag_directives.start;
999 tag_directive != event->data.document_start.tag_directives.end;
1000 tag_directive++) {
1001 yaml_free(tag_directive->handle);
1002 yaml_free(tag_directive->prefix);
1004 yaml_free(event->data.document_start.tag_directives.start);
1005 break;
1007 case YAML_ALIAS_EVENT:
1008 yaml_free(event->data.alias.anchor);
1009 break;
1011 case YAML_SCALAR_EVENT:
1012 yaml_free(event->data.scalar.anchor);
1013 yaml_free(event->data.scalar.tag);
1014 yaml_free(event->data.scalar.value);
1015 break;
1017 case YAML_SEQUENCE_START_EVENT:
1018 yaml_free(event->data.sequence_start.anchor);
1019 yaml_free(event->data.sequence_start.tag);
1020 break;
1022 case YAML_MAPPING_START_EVENT:
1023 yaml_free(event->data.mapping_start.anchor);
1024 yaml_free(event->data.mapping_start.tag);
1025 break;
1027 default:
1028 break;
1031 memset(event, 0, sizeof(yaml_event_t));
1035 * Create a document object.
1036 */
1038YAML_DECLARE(int)
1039yaml_document_initialize(yaml_document_t *document,
1040 yaml_version_directive_t *version_directive,
1041 yaml_tag_directive_t *tag_directives_start,
1042 yaml_tag_directive_t *tag_directives_end,
1043 int start_implicit, int end_implicit)
1045 struct {
1046 yaml_error_type_t error;
1047 } context;
1048 struct {
1049 yaml_node_t *start;
1050 yaml_node_t *end;
1051 yaml_node_t *top;
1052 } nodes = { NULL, NULL, NULL };
1053 yaml_version_directive_t *version_directive_copy = NULL;
1054 struct {
1055 yaml_tag_directive_t *start;
1056 yaml_tag_directive_t *end;
1057 yaml_tag_directive_t *top;
1058 } tag_directives_copy = { NULL, NULL, NULL };
1059 yaml_tag_directive_t value = { NULL, NULL };
1060 yaml_mark_t mark = { 0, 0, 0 };
1062 assert(document); /* Non-NULL document object is expected. */
1063 assert((tag_directives_start && tag_directives_end) ||
1064 (tag_directives_start == tag_directives_end));
1065 /* Valid tag directives are expected. */
1067 if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error;
1069 if (version_directive) {
1070 version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
1071 if (!version_directive_copy) goto error;
1072 version_directive_copy->major = version_directive->major;
1073 version_directive_copy->minor = version_directive->minor;
1076 if (tag_directives_start != tag_directives_end) {
1077 yaml_tag_directive_t *tag_directive;
1078 if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
1079 goto error;
1080 for (tag_directive = tag_directives_start;
1081 tag_directive != tag_directives_end; tag_directive ++) {
1082 assert(tag_directive->handle);
1083 assert(tag_directive->prefix);
1084 if (!yaml_check_utf8(tag_directive->handle,
1085 strlen((char *)tag_directive->handle)))
1086 goto error;
1087 if (!yaml_check_utf8(tag_directive->prefix,
1088 strlen((char *)tag_directive->prefix)))
1089 goto error;
1090 value.handle = yaml_strdup(tag_directive->handle);
1091 value.prefix = yaml_strdup(tag_directive->prefix);
1092 if (!value.handle || !value.prefix) goto error;
1093 if (!PUSH(&context, tag_directives_copy, value))
1094 goto error;
1095 value.handle = NULL;
1096 value.prefix = NULL;
1100 DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
1101 tag_directives_copy.start, tag_directives_copy.top,
1102 start_implicit, end_implicit, mark, mark);
1104 return 1;
1106error:
1107 STACK_DEL(&context, nodes);
1108 yaml_free(version_directive_copy);
1109 while (!STACK_EMPTY(&context, tag_directives_copy)) {
1110 yaml_tag_directive_t value = POP(&context, tag_directives_copy);
1111 yaml_free(value.handle);
1112 yaml_free(value.prefix);
1114 STACK_DEL(&context, tag_directives_copy);
1115 yaml_free(value.handle);
1116 yaml_free(value.prefix);
1118 return 0;
1122 * Destroy a document object.
1123 */
1125YAML_DECLARE(void)
1126yaml_document_delete(yaml_document_t *document)
1128 struct {
1129 yaml_error_type_t error;
1130 } context;
1131 yaml_tag_directive_t *tag_directive;
1133 context.error = YAML_NO_ERROR; /* Eliminate a compliler warning. */
1135 assert(document); /* Non-NULL document object is expected. */
1137 while (!STACK_EMPTY(&context, document->nodes)) {
1138 yaml_node_t node = POP(&context, document->nodes);
1139 yaml_free(node.tag);
1140 switch (node.type) {
1141 case YAML_SCALAR_NODE:
1142 yaml_free(node.data.scalar.value);
1143 break;
1144 case YAML_SEQUENCE_NODE:
1145 STACK_DEL(&context, node.data.sequence.items);
1146 break;
1147 case YAML_MAPPING_NODE:
1148 STACK_DEL(&context, node.data.mapping.pairs);
1149 break;
1150 default:
1151 assert(0); /* Should not happen. */
1154 STACK_DEL(&context, document->nodes);
1156 yaml_free(document->version_directive);
1157 for (tag_directive = document->tag_directives.start;
1158 tag_directive != document->tag_directives.end;
1159 tag_directive++) {
1160 yaml_free(tag_directive->handle);
1161 yaml_free(tag_directive->prefix);
1163 yaml_free(document->tag_directives.start);
1165 memset(document, 0, sizeof(yaml_document_t));
1168/**
1169 * Get a document node.
1170 */
1172YAML_DECLARE(yaml_node_t *)
1173yaml_document_get_node(yaml_document_t *document, int index)
1175 assert(document); /* Non-NULL document object is expected. */
1177 if (index > 0 && document->nodes.start + index <= document->nodes.top) {
1178 return document->nodes.start + index - 1;
1180 return NULL;
1183/**
1184 * Get the root object.
1185 */
1187YAML_DECLARE(yaml_node_t *)
1188yaml_document_get_root_node(yaml_document_t *document)
1190 assert(document); /* Non-NULL document object is expected. */
1192 if (document->nodes.top != document->nodes.start) {
1193 return document->nodes.start;
1195 return NULL;
1199 * Add a scalar node to a document.
1200 */
1202YAML_DECLARE(int)
1203yaml_document_add_scalar(yaml_document_t *document,
1204 yaml_char_t *tag, yaml_char_t *value, int length,
1205 yaml_scalar_style_t style)
1207 struct {
1208 yaml_error_type_t error;
1209 } context;
1210 yaml_mark_t mark = { 0, 0, 0 };
1211 yaml_char_t *tag_copy = NULL;
1212 yaml_char_t *value_copy = NULL;
1213 yaml_node_t node;
1215 assert(document); /* Non-NULL document object is expected. */
1216 assert(value); /* Non-NULL value is expected. */
1218 if (!tag) {
1219 tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG;
1222 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1223 tag_copy = yaml_strdup(tag);
1224 if (!tag_copy) goto error;
1226 if (length < 0) {
1227 length = strlen((char *)value);
1230 if (!yaml_check_utf8(value, length)) goto error;
1231 value_copy = yaml_malloc(length+1);
1232 if (!value_copy) goto error;
1233 memcpy(value_copy, value, length);
1234 value_copy[length] = '\0';
1236 SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark);
1237 if (!PUSH(&context, document->nodes, node)) goto error;
1239 return document->nodes.top - document->nodes.start;
1241error:
1242 yaml_free(tag_copy);
1243 yaml_free(value_copy);
1245 return 0;
1249 * Add a sequence node to a document.
1250 */
1252YAML_DECLARE(int)
1253yaml_document_add_sequence(yaml_document_t *document,
1254 yaml_char_t *tag, yaml_sequence_style_t style)
1256 struct {
1257 yaml_error_type_t error;
1258 } context;
1259 yaml_mark_t mark = { 0, 0, 0 };
1260 yaml_char_t *tag_copy = NULL;
1261 struct {
1262 yaml_node_item_t *start;
1263 yaml_node_item_t *end;
1264 yaml_node_item_t *top;
1265 } items = { NULL, NULL, NULL };
1266 yaml_node_t node;
1268 assert(document); /* Non-NULL document object is expected. */
1270 if (!tag) {
1271 tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG;
1274 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1275 tag_copy = yaml_strdup(tag);
1276 if (!tag_copy) goto error;
1278 if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error;
1280 SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
1281 style, mark, mark);
1282 if (!PUSH(&context, document->nodes, node)) goto error;
1284 return document->nodes.top - document->nodes.start;
1286error:
1287 STACK_DEL(&context, items);
1288 yaml_free(tag_copy);
1290 return 0;
1294 * Add a mapping node to a document.
1295 */
1297YAML_DECLARE(int)
1298yaml_document_add_mapping(yaml_document_t *document,
1299 yaml_char_t *tag, yaml_mapping_style_t style)
1301 struct {
1302 yaml_error_type_t error;
1303 } context;
1304 yaml_mark_t mark = { 0, 0, 0 };
1305 yaml_char_t *tag_copy = NULL;
1306 struct {
1307 yaml_node_pair_t *start;
1308 yaml_node_pair_t *end;
1309 yaml_node_pair_t *top;
1310 } pairs = { NULL, NULL, NULL };
1311 yaml_node_t node;
1313 assert(document); /* Non-NULL document object is expected. */
1315 if (!tag) {
1316 tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG;
1319 if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1320 tag_copy = yaml_strdup(tag);
1321 if (!tag_copy) goto error;
1323 if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error;
1325 MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
1326 style, mark, mark);
1327 if (!PUSH(&context, document->nodes, node)) goto error;
1329 return document->nodes.top - document->nodes.start;
1331error:
1332 STACK_DEL(&context, pairs);
1333 yaml_free(tag_copy);
1335 return 0;
1339 * Append an item to a sequence node.
1340 */
1342YAML_DECLARE(int)
1343yaml_document_append_sequence_item(yaml_document_t *document,
1344 int sequence, int item)
1346 struct {
1347 yaml_error_type_t error;
1348 } context;
1350 assert(document); /* Non-NULL document is required. */
1351 assert(sequence > 0
1352 && document->nodes.start + sequence <= document->nodes.top);
1353 /* Valid sequence id is required. */
1354 assert(document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE);
1355 /* A sequence node is required. */
1356 assert(item > 0 && document->nodes.start + item <= document->nodes.top);
1357 /* Valid item id is required. */
1359 if (!PUSH(&context,
1360 document->nodes.start[sequence-1].data.sequence.items, item))
1361 return 0;
1363 return 1;
1367 * Append a pair of a key and a value to a mapping node.
1368 */
1370YAML_DECLARE(int)
1371yaml_document_append_mapping_pair(yaml_document_t *document,
1372 int mapping, int key, int value)
1374 struct {
1375 yaml_error_type_t error;
1376 } context;
1378 yaml_node_pair_t pair;
1380 assert(document); /* Non-NULL document is required. */
1381 assert(mapping > 0
1382 && document->nodes.start + mapping <= document->nodes.top);
1383 /* Valid mapping id is required. */
1384 assert(document->nodes.start[mapping-1].type == YAML_MAPPING_NODE);
1385 /* A mapping node is required. */
1386 assert(key > 0 && document->nodes.start + key <= document->nodes.top);
1387 /* Valid key id is required. */
1388 assert(value > 0 && document->nodes.start + value <= document->nodes.top);
1389 /* Valid value id is required. */
1391 pair.key = key;
1392 pair.value = value;
1394 if (!PUSH(&context,
1395 document->nodes.start[mapping-1].data.mapping.pairs, pair))
1396 return 0;
1398 return 1;