source: libyaml/trunk/src/api.c @ 237

Revision 237, 29.0 KB checked in by xi, 7 years ago (diff)

Add const qualifier for yaml_parser_set_input_string parameter input.

RevLine 
[178]1
[208]2#include "yaml_private.h"
[178]3
[208]4/*
5 * Get the library version.
6 */
[178]7
[200]8YAML_DECLARE(const char *)
9yaml_get_version_string(void)
10{
11    return YAML_VERSION_STRING;
12}
13
[208]14/*
15 * Get the library version numbers.
16 */
17
[200]18YAML_DECLARE(void)
19yaml_get_version(int *major, int *minor, int *patch)
20{
21    *major = YAML_VERSION_MAJOR;
22    *minor = YAML_VERSION_MINOR;
23    *patch = YAML_VERSION_PATCH;
24}
25
[178]26/*
[179]27 * Allocate a dynamic memory block.
[178]28 */
29
[183]30YAML_DECLARE(void *)
[179]31yaml_malloc(size_t size)
32{
33    return malloc(size ? size : 1);
34}
35
36/*
37 * Reallocate a dynamic memory block.
38 */
39
[183]40YAML_DECLARE(void *)
[179]41yaml_realloc(void *ptr, size_t size)
42{
43    return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
44}
45
46/*
47 * Free a dynamic memory block.
48 */
49
[183]50YAML_DECLARE(void)
[179]51yaml_free(void *ptr)
52{
53    if (ptr) free(ptr);
54}
55
56/*
[208]57 * Duplicate a string.
[179]58 */
59
[212]60YAML_DECLARE(yaml_char_t *)
61yaml_strdup(const yaml_char_t *str)
[178]62{
[212]63    if (!str)
64        return NULL;
65
66    return (yaml_char_t *)strdup((char *)str);
[208]67}
[178]68
[208]69/*
70 * Extend a string.
71 */
[180]72
[208]73YAML_DECLARE(int)
74yaml_string_extend(yaml_char_t **start,
75        yaml_char_t **pointer, yaml_char_t **end)
76{
77    void *new_start = yaml_realloc(*start, (*end - *start)*2);
[178]78
[208]79    if (!new_start) return 0;
[178]80
[208]81    memset(new_start + (*end - *start), 0, *end - *start);
[180]82
[208]83    *pointer = new_start + (*pointer - *start);
84    *end = new_start + (*end - *start)*2;
85    *start = new_start;
[185]86
[208]87    return 1;
88}
[180]89
[208]90/*
91 * Append a string B to a string A.
92 */
[180]93
[208]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)
98{
99    if (*b_start == *b_pointer)
100        return 1;
[185]101
[208]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    }
[180]106
[208]107    memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
108    *a_pointer += *b_pointer - *b_start;
[185]109
[208]110    return 1;
111}
[185]112
[208]113/*
114 * Extend a stack.
115 */
[185]116
[208]117YAML_DECLARE(int)
118yaml_stack_extend(void **start, void **top, void **end)
119{
120    void *new_start = yaml_realloc(*start, (*end - *start)*2);
[185]121
[208]122    if (!new_start) return 0;
[185]123
[208]124    *top = new_start + (*top - *start);
125    *end = new_start + (*end - *start)*2;
126    *start = new_start;
[185]127
[208]128    return 1;
129}
[185]130
[208]131/*
132 * Extend or move a queue.
133 */
[185]134
[208]135YAML_DECLARE(int)
136yaml_queue_extend(void **start, void **head, void **tail, void **end)
137{
138    /* Check if we need to resize the queue. */
[185]139
[208]140    if (*start == *head && *tail == *end) {
141        void *new_start = yaml_realloc(*start, (*end - *start)*2);
[201]142
[208]143        if (!new_start) return 0;
[201]144
[208]145        *head = new_start + (*head - *start);
146        *tail = new_start + (*tail - *start);
147        *end = new_start + (*end - *start)*2;
148        *start = new_start;
149    }
[201]150
[208]151    /* Check if we need to move the queue at the beginning of the buffer. */
[201]152
[208]153    if (*tail == *end) {
154        if (*head != *tail) {
155            memmove(*start, *head, *tail - *head);
156        }
157        *tail -= *head - *start;
158        *head = *start;
159    }
[201]160
[208]161    return 1;
162}
[203]163
164
[208]165/*
166 * Create a new parser object.
167 */
[203]168
[208]169YAML_DECLARE(int)
170yaml_parser_initialize(yaml_parser_t *parser)
171{
172    assert(parser);     /* Non-NULL parser object expected. */
[201]173
[208]174    memset(parser, 0, sizeof(yaml_parser_t));
[211]175    if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE))
[208]176        goto error;
[211]177    if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
[208]178        goto error;
179    if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE))
180        goto error;
181    if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE))
182        goto error;
183    if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE))
184        goto error;
185    if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE))
186        goto error;
187    if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE))
188        goto error;
189    if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE))
190        goto error;
[201]191
[208]192    return 1;
[201]193
[185]194error:
195
[208]196    BUFFER_DEL(parser, parser->raw_buffer);
197    BUFFER_DEL(parser, parser->buffer);
198    QUEUE_DEL(parser, parser->tokens);
199    STACK_DEL(parser, parser->indents);
200    STACK_DEL(parser, parser->simple_keys);
201    STACK_DEL(parser, parser->states);
202    STACK_DEL(parser, parser->marks);
203    STACK_DEL(parser, parser->tag_directives);
[185]204
[208]205    return 0;
[178]206}
207
208/*
209 * Destroy a parser object.
210 */
211
[183]212YAML_DECLARE(void)
[178]213yaml_parser_delete(yaml_parser_t *parser)
214{
[179]215    assert(parser); /* Non-NULL parser object expected. */
216
[208]217    BUFFER_DEL(parser, parser->raw_buffer);
218    BUFFER_DEL(parser, parser->buffer);
219    while (!QUEUE_EMPTY(parser, parser->tokens)) {
220        yaml_token_delete(&DEQUEUE(parser, parser->tokens));
221    }
222    QUEUE_DEL(parser, parser->tokens);
223    STACK_DEL(parser, parser->indents);
224    STACK_DEL(parser, parser->simple_keys);
225    STACK_DEL(parser, parser->states);
226    STACK_DEL(parser, parser->marks);
227    while (!STACK_EMPTY(parser, parser->tag_directives)) {
228        yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
229        yaml_free(tag_directive.handle);
230        yaml_free(tag_directive.prefix);
231    }
232    STACK_DEL(parser, parser->tag_directives);
[179]233
234    memset(parser, 0, sizeof(yaml_parser_t));
[178]235}
236
[179]237/*
[180]238 * String read handler.
[179]239 */
240
241static int
242yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
243        size_t *size_read)
244{
[208]245    yaml_parser_t *parser = data;
[180]246
[208]247    if (parser->input.string.current == parser->input.string.end) {
[180]248        *size_read = 0;
249        return 1;
250    }
251
[208]252    if (size > (parser->input.string.end - parser->input.string.current)) {
253        size = parser->input.string.end - parser->input.string.current;
[180]254    }
255
[208]256    memcpy(buffer, parser->input.string.current, size);
257    parser->input.string.current += size;
[180]258    *size_read = size;
[179]259    return 1;
260}
261
262/*
263 * File read handler.
264 */
265
266static int
267yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
268        size_t *size_read)
269{
[208]270    yaml_parser_t *parser = data;
271
272    *size_read = fread(buffer, 1, size, parser->input.file);
273    return !ferror(parser->input.file);
[179]274}
275
276/*
277 * Set a string input.
278 */
279
[183]280YAML_DECLARE(void)
[179]281yaml_parser_set_input_string(yaml_parser_t *parser,
[237]282        const unsigned char *input, size_t size)
[179]283{
284    assert(parser); /* Non-NULL parser object expected. */
[180]285    assert(!parser->read_handler);  /* You can set the source only once. */
[179]286    assert(input);  /* Non-NULL input string expected. */
287
288    parser->read_handler = yaml_string_read_handler;
[208]289    parser->read_handler_data = parser;
290
291    parser->input.string.start = input;
292    parser->input.string.current = input;
293    parser->input.string.end = input+size;
[179]294}
295
296/*
297 * Set a file input.
298 */
299
[183]300YAML_DECLARE(void)
[179]301yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
302{
303    assert(parser); /* Non-NULL parser object expected. */
[180]304    assert(!parser->read_handler);  /* You can set the source only once. */
[179]305    assert(file);   /* Non-NULL file object expected. */
306
307    parser->read_handler = yaml_file_read_handler;
[208]308    parser->read_handler_data = parser;
309
310    parser->input.file = file;
[179]311}
312
313/*
314 * Set a generic input.
315 */
316
[183]317YAML_DECLARE(void)
[179]318yaml_parser_set_input(yaml_parser_t *parser,
319        yaml_read_handler_t *handler, void *data)
320{
321    assert(parser); /* Non-NULL parser object expected. */
[180]322    assert(!parser->read_handler);  /* You can set the source only once. */
[179]323    assert(handler);    /* Non-NULL read handler expected. */
324
325    parser->read_handler = handler;
[180]326    parser->read_handler_data = data;
[179]327}
328
329/*
330 * Set the source encoding.
331 */
332
[183]333YAML_DECLARE(void)
[179]334yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
335{
336    assert(parser); /* Non-NULL parser object expected. */
337    assert(!parser->encoding); /* Encoding is already set or detected. */
338
339    parser->encoding = encoding;
340}
341
[183]342/*
[211]343 * Create a new emitter object.
344 */
345
346YAML_DECLARE(int)
347yaml_emitter_initialize(yaml_emitter_t *emitter)
348{
349    assert(emitter);    /* Non-NULL emitter object expected. */
350
351    memset(emitter, 0, sizeof(yaml_emitter_t));
352    if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE))
353        goto error;
354    if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
355        goto error;
356    if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_SIZE))
357        goto error;
358    if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE))
359        goto error;
360    if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_SIZE))
361        goto error;
362    if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_SIZE))
363        goto error;
364
365    return 1;
366
367error:
368
369    BUFFER_DEL(emitter, emitter->buffer);
370    BUFFER_DEL(emitter, emitter->raw_buffer);
371    STACK_DEL(emitter, emitter->states);
372    QUEUE_DEL(emitter, emitter->events);
373    STACK_DEL(emitter, emitter->indents);
374    STACK_DEL(emitter, emitter->tag_directives);
375
376    return 0;
377}
378
379/*
380 * Destroy an emitter object.
381 */
382
383YAML_DECLARE(void)
384yaml_emitter_delete(yaml_emitter_t *emitter)
385{
386    assert(emitter);    /* Non-NULL emitter object expected. */
387
388    BUFFER_DEL(emitter, emitter->buffer);
389    BUFFER_DEL(emitter, emitter->raw_buffer);
390    STACK_DEL(emitter, emitter->states);
391    while (!QUEUE_EMPTY(emitter, emitter->events)) {
392        yaml_event_delete(&DEQUEUE(emitter, emitter->events));
393    }
[216]394    QUEUE_DEL(emitter, emitter->events);
[211]395    STACK_DEL(emitter, emitter->indents);
396    while (!STACK_EMPTY(empty, emitter->tag_directives)) {
397        yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
398        yaml_free(tag_directive.handle);
399        yaml_free(tag_directive.prefix);
400    }
401    STACK_DEL(emitter, emitter->tag_directives);
402
403    memset(emitter, 0, sizeof(yaml_emitter_t));
404}
405
406/*
407 * String write handler.
408 */
409
410static int
411yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
412{
413    yaml_emitter_t *emitter = data;
414
415    if (emitter->output.string.size + *emitter->output.string.size_written
416            < size) {
417        memcpy(emitter->output.string.buffer
418                + *emitter->output.string.size_written,
419                buffer,
420                emitter->output.string.size
421                - *emitter->output.string.size_written);
422        *emitter->output.string.size_written = emitter->output.string.size;
423        return 0;
424    }
425
426    memcpy(emitter->output.string.buffer
427            + *emitter->output.string.size_written, buffer, size);
428    *emitter->output.string.size_written += size;
429    return 1;
430}
431
432/*
433 * File write handler.
434 */
435
436static int
437yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
438{
439    yaml_emitter_t *emitter = data;
440
441    return (fwrite(buffer, 1, size, emitter->output.file) == size);
442}
443/*
444 * Set a string output.
445 */
446
447YAML_DECLARE(void)
448yaml_emitter_set_output_string(yaml_emitter_t *emitter,
449        unsigned char *output, size_t size, size_t *size_written)
450{
451    assert(emitter);    /* Non-NULL emitter object expected. */
452    assert(!emitter->write_handler);    /* You can set the output only once. */
453    assert(output);     /* Non-NULL output string expected. */
454
455    emitter->write_handler = yaml_string_write_handler;
456    emitter->write_handler_data = emitter;
457
458    emitter->output.string.buffer = output;
459    emitter->output.string.size = size;
460    emitter->output.string.size_written = size_written;
461    *size_written = 0;
462}
463
464/*
465 * Set a file output.
466 */
467
468YAML_DECLARE(void)
469yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
470{
471    assert(emitter);    /* Non-NULL emitter object expected. */
472    assert(!emitter->write_handler);    /* You can set the output only once. */
473    assert(file);       /* Non-NULL file object expected. */
474
475    emitter->write_handler = yaml_file_write_handler;
476    emitter->write_handler_data = emitter;
477
478    emitter->output.file = file;
479}
480
481/*
482 * Set a generic output handler.
483 */
484
485YAML_DECLARE(void)
486yaml_emitter_set_output(yaml_emitter_t *emitter,
487        yaml_write_handler_t *handler, void *data)
488{
489    assert(emitter);    /* Non-NULL emitter object expected. */
490    assert(!emitter->write_handler);    /* You can set the output only once. */
491    assert(handler);    /* Non-NULL handler object expected. */
492
493    emitter->write_handler = handler;
494    emitter->write_handler_data = data;
495}
496
497/*
498 * Set the output encoding.
499 */
500
501YAML_DECLARE(void)
502yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding)
503{
504    assert(emitter);    /* Non-NULL emitter object expected. */
505    assert(!emitter->encoding);     /* You can set encoding only once. */
506
507    emitter->encoding = encoding;
508}
509
510/*
511 * Set the canonical output style.
512 */
513
514YAML_DECLARE(void)
515yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
516{
517    assert(emitter);    /* Non-NULL emitter object expected. */
518
519    emitter->canonical = (canonical != 0);
520}
521
522/*
523 * Set the indentation increment.
524 */
525
526YAML_DECLARE(void)
527yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
528{
529    assert(emitter);    /* Non-NULL emitter object expected. */
530
531    emitter->best_indent = (1 < indent && indent < 10) ? indent : 2;
532}
533
534/*
535 * Set the preferred line width.
536 */
537
538YAML_DECLARE(void)
539yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
540{
541    assert(emitter);    /* Non-NULL emitter object expected. */
542
[212]543    emitter->best_width = (width >= 0) ? width : -1;
[211]544}
545
546/*
547 * Set if unescaped non-ASCII characters are allowed.
548 */
549
550YAML_DECLARE(void)
551yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
552{
553    assert(emitter);    /* Non-NULL emitter object expected. */
554
555    emitter->unicode = (unicode != 0);
556}
557
558/*
559 * Set the preferred line break character.
560 */
561
562YAML_DECLARE(void)
563yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
564{
565    assert(emitter);    /* Non-NULL emitter object expected. */
566
567    emitter->line_break = line_break;
568}
569
570/*
[183]571 * Destroy a token object.
572 */
573
574YAML_DECLARE(void)
575yaml_token_delete(yaml_token_t *token)
576{
577    assert(token);  /* Non-NULL token object expected. */
578
579    switch (token->type)
580    {
581        case YAML_TAG_DIRECTIVE_TOKEN:
582            yaml_free(token->data.tag_directive.handle);
583            yaml_free(token->data.tag_directive.prefix);
584            break;
585
586        case YAML_ALIAS_TOKEN:
[199]587            yaml_free(token->data.alias.value);
588            break;
589
[183]590        case YAML_ANCHOR_TOKEN:
[199]591            yaml_free(token->data.anchor.value);
[183]592            break;
593
594        case YAML_TAG_TOKEN:
595            yaml_free(token->data.tag.handle);
596            yaml_free(token->data.tag.suffix);
597            break;
598
599        case YAML_SCALAR_TOKEN:
600            yaml_free(token->data.scalar.value);
601            break;
[210]602
603        default:
604            break;
[183]605    }
606
607    memset(token, 0, sizeof(yaml_token_t));
608}
609
[199]610/*
[213]611 * Check if a string is a valid UTF-8 sequence.
612 *
613 * Check 'reader.c' for more details on UTF-8 encoding.
614 */
615
616static int
617yaml_check_utf8(yaml_char_t *start, size_t length)
618{
619    yaml_char_t *end = start+length;
620    yaml_char_t *pointer = start;
621
622    while (pointer < end) {
623        unsigned char octet;
624        unsigned int width;
625        unsigned int value;
626        int k;
627
628        octet = pointer[0];
629        width = (octet & 0x80) == 0x00 ? 1 :
630                (octet & 0xE0) == 0xC0 ? 2 :
631                (octet & 0xF0) == 0xE0 ? 3 :
632                (octet & 0xF8) == 0xF0 ? 4 : 0;
[215]633        value = (octet & 0x80) == 0x00 ? octet & 0x7F :
[213]634                (octet & 0xE0) == 0xC0 ? octet & 0x1F :
635                (octet & 0xF0) == 0xE0 ? octet & 0x0F :
636                (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
637        if (!width) return 0;
638        if (pointer+width > end) return 0;
639        for (k = 1; k < width; k ++) {
640            octet = pointer[k];
641            if ((octet & 0xC0) != 0x80) return 0;
642            value = (value << 6) + (octet & 0x3F);
643        }
644        if (!((width == 1) ||
645            (width == 2 && value >= 0x80) ||
646            (width == 3 && value >= 0x800) ||
647            (width == 4 && value >= 0x10000))) return 0;
648
649        pointer += width;
650    }
651
652    return 1;
653}
654
655/*
656 * Create STREAM-START.
657 */
658
659YAML_DECLARE(int)
660yaml_stream_start_event_initialize(yaml_event_t *event,
661        yaml_encoding_t encoding)
662{
663    yaml_mark_t mark = { 0, 0, 0 };
664
665    assert(event);  /* Non-NULL event object is expected. */
666
667    STREAM_START_EVENT_INIT(*event, encoding, mark, mark);
668
669    return 1;
670}
671
672/*
673 * Create STREAM-END.
674 */
675
676YAML_DECLARE(int)
677yaml_stream_end_event_initialize(yaml_event_t *event)
678{
679    yaml_mark_t mark = { 0, 0, 0 };
680
681    assert(event);  /* Non-NULL event object is expected. */
682
683    STREAM_END_EVENT_INIT(*event, mark, mark);
684
685    return 1;
686}
687
688/*
689 * Create DOCUMENT-START.
690 */
691
692YAML_DECLARE(int)
693yaml_document_start_event_initialize(yaml_event_t *event,
694        yaml_version_directive_t *version_directive,
695        yaml_tag_directive_t *tag_directives_start,
696        yaml_tag_directive_t *tag_directives_end,
697        int implicit)
698{
699    struct {
700        yaml_error_type_t error;
701    } context;
702    yaml_mark_t mark = { 0, 0, 0 };
703    yaml_version_directive_t *version_directive_copy = NULL;
704    struct {
705        yaml_tag_directive_t *start;
706        yaml_tag_directive_t *end;
707        yaml_tag_directive_t *top;
708    } tag_directives_copy = { NULL, NULL, NULL };
709    yaml_tag_directive_t value = { NULL, NULL };
710
711    assert(event);          /* Non-NULL event object is expected. */
712    assert((tag_directives_start && tag_directives_end) ||
713            (tag_directives_start == tag_directives_end));
714                            /* Valid tag directives are expected. */
715
716    if (version_directive) {
717        version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t));
718        if (!version_directive_copy) goto error;
719        version_directive_copy->major = version_directive->major;
720        version_directive_copy->minor = version_directive->minor;
721    }
722
723    if (tag_directives_start != tag_directives_end) {
724        yaml_tag_directive_t *tag_directive;
725        if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
726            goto error;
727        for (tag_directive = tag_directives_start;
728                tag_directive != tag_directives_end; tag_directive ++) {
729            assert(tag_directive->handle);
730            assert(tag_directive->prefix);
731            if (!yaml_check_utf8(tag_directive->handle,
732                        strlen((char *)tag_directive->handle)))
733                goto error;
734            if (!yaml_check_utf8(tag_directive->prefix,
735                        strlen((char *)tag_directive->prefix)))
736                goto error;
737            value.handle = yaml_strdup(tag_directive->handle);
738            value.prefix = yaml_strdup(tag_directive->prefix);
739            if (!value.handle || !value.prefix) goto error;
740            if (!PUSH(&context, tag_directives_copy, value))
741                goto error;
742            value.handle = NULL;
743            value.prefix = NULL;
744        }
745    }
746
747    DOCUMENT_START_EVENT_INIT(*event, version_directive_copy,
[216]748            tag_directives_copy.start, tag_directives_copy.top,
[213]749            implicit, mark, mark);
750
751    return 1;
752
753error:
754    yaml_free(version_directive_copy);
755    while (!STACK_EMPTY(context, tag_directives_copy)) {
756        yaml_tag_directive_t value = POP(context, tag_directives_copy);
757        yaml_free(value.handle);
758        yaml_free(value.prefix);
759    }
760    STACK_DEL(context, tag_directives_copy);
761    yaml_free(value.handle);
762    yaml_free(value.prefix);
763
764    return 0;
765}
766
767/*
768 * Create DOCUMENT-END.
769 */
770
771YAML_DECLARE(int)
772yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
773{
774    yaml_mark_t mark = { 0, 0, 0 };
775
776    assert(event);      /* Non-NULL emitter object is expected. */
777
778    DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark);
779
780    return 1;
781}
782
783/*
784 * Create ALIAS.
785 */
786
787YAML_DECLARE(int)
788yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
789{
790    yaml_mark_t mark = { 0, 0, 0 };
791    yaml_char_t *anchor_copy = NULL;
792
793    assert(event);      /* Non-NULL event object is expected. */
794    assert(anchor);     /* Non-NULL anchor is expected. */
795
796    if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;
797
798    anchor_copy = yaml_strdup(anchor);
799    if (!anchor_copy)
800        return 0;
801
802    ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);
803
804    return 1;
805}
806
807/*
808 * Create SCALAR.
809 */
810
811YAML_DECLARE(int)
812yaml_scalar_event_initialize(yaml_event_t *event,
813        yaml_char_t *anchor, yaml_char_t *tag,
[219]814        yaml_char_t *value, int length,
[213]815        int plain_implicit, int quoted_implicit,
816        yaml_scalar_style_t style)
817{
818    yaml_mark_t mark = { 0, 0, 0 };
819    yaml_char_t *anchor_copy = NULL;
820    yaml_char_t *tag_copy = NULL;
821    yaml_char_t *value_copy = NULL;
822
823    assert(event);      /* Non-NULL event object is expected. */
824    assert(value);      /* Non-NULL anchor is expected. */
825
826    if (anchor) {
827        if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
828        anchor_copy = yaml_strdup(anchor);
829        if (!anchor_copy) goto error;
830    }
831
832    if (tag) {
833        if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
834        tag_copy = yaml_strdup(tag);
835        if (!tag_copy) goto error;
836    }
837
[219]838    if (length < 0) {
839        length = strlen((char *)value);
840    }
841
[213]842    if (!yaml_check_utf8(value, length)) goto error;
843    value_copy = yaml_malloc(length+1);
844    if (!value_copy) goto error;
845    memcpy(value_copy, value, length);
846    value_copy[length] = '\0';
847
848    SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length,
849            plain_implicit, quoted_implicit, style, mark, mark);
850
851    return 1;
852
853error:
854    yaml_free(anchor_copy);
855    yaml_free(tag_copy);
856    yaml_free(value_copy);
857
858    return 0;
859}
860
861/*
862 * Create SEQUENCE-START.
863 */
864
865YAML_DECLARE(int)
866yaml_sequence_start_event_initialize(yaml_event_t *event,
867        yaml_char_t *anchor, yaml_char_t *tag, int implicit,
868        yaml_sequence_style_t style)
869{
870    yaml_mark_t mark = { 0, 0, 0 };
871    yaml_char_t *anchor_copy = NULL;
872    yaml_char_t *tag_copy = NULL;
873
874    assert(event);      /* Non-NULL event object is expected. */
875
876    if (anchor) {
877        if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
878        anchor_copy = yaml_strdup(anchor);
879        if (!anchor_copy) goto error;
880    }
881
882    if (tag) {
883        if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
884        tag_copy = yaml_strdup(tag);
885        if (!tag_copy) goto error;
886    }
887
888    SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy,
889            implicit, style, mark, mark);
890
891    return 1;
892
893error:
894    yaml_free(anchor_copy);
895    yaml_free(tag_copy);
896
897    return 0;
898}
899
900/*
901 * Create SEQUENCE-END.
902 */
903
904YAML_DECLARE(int)
905yaml_sequence_end_event_initialize(yaml_event_t *event)
906{
907    yaml_mark_t mark = { 0, 0, 0 };
908
909    assert(event);      /* Non-NULL event object is expected. */
910
911    SEQUENCE_END_EVENT_INIT(*event, mark, mark);
912
913    return 1;
914}
915
916/*
917 * Create MAPPING-START.
918 */
919
920YAML_DECLARE(int)
921yaml_mapping_start_event_initialize(yaml_event_t *event,
922        yaml_char_t *anchor, yaml_char_t *tag, int implicit,
923        yaml_mapping_style_t style)
924{
925    yaml_mark_t mark = { 0, 0, 0 };
926    yaml_char_t *anchor_copy = NULL;
927    yaml_char_t *tag_copy = NULL;
928
929    assert(event);      /* Non-NULL event object is expected. */
930
931    if (anchor) {
932        if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
933        anchor_copy = yaml_strdup(anchor);
934        if (!anchor_copy) goto error;
935    }
936
937    if (tag) {
938        if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
939        tag_copy = yaml_strdup(tag);
940        if (!tag_copy) goto error;
941    }
942
943    MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy,
944            implicit, style, mark, mark);
945
946    return 1;
947
948error:
949    yaml_free(anchor_copy);
950    yaml_free(tag_copy);
951
952    return 0;
953}
954
955/*
956 * Create MAPPING-END.
957 */
958
959YAML_DECLARE(int)
960yaml_mapping_end_event_initialize(yaml_event_t *event)
961{
962    yaml_mark_t mark = { 0, 0, 0 };
963
964    assert(event);      /* Non-NULL event object is expected. */
965
966    MAPPING_END_EVENT_INIT(*event, mark, mark);
967
968    return 1;
969}
970
971/*
[199]972 * Destroy an event object.
973 */
974
975YAML_DECLARE(void)
976yaml_event_delete(yaml_event_t *event)
977{
[208]978    yaml_tag_directive_t *tag_directive;
979
[199]980    assert(event);  /* Non-NULL event object expected. */
981
982    switch (event->type)
983    {
984        case YAML_DOCUMENT_START_EVENT:
[208]985            yaml_free(event->data.document_start.version_directive);
986            for (tag_directive = event->data.document_start.tag_directives.start;
987                    tag_directive != event->data.document_start.tag_directives.end;
988                    tag_directive++) {
989                yaml_free(tag_directive->handle);
990                yaml_free(tag_directive->prefix);
991            }
992            yaml_free(event->data.document_start.tag_directives.start);
[199]993            break;
994
995        case YAML_ALIAS_EVENT:
996            yaml_free(event->data.alias.anchor);
997            break;
998
999        case YAML_SCALAR_EVENT:
1000            yaml_free(event->data.scalar.anchor);
1001            yaml_free(event->data.scalar.tag);
1002            yaml_free(event->data.scalar.value);
1003            break;
1004
1005        case YAML_SEQUENCE_START_EVENT:
1006            yaml_free(event->data.sequence_start.anchor);
1007            yaml_free(event->data.sequence_start.tag);
1008            break;
1009
1010        case YAML_MAPPING_START_EVENT:
1011            yaml_free(event->data.mapping_start.anchor);
1012            yaml_free(event->data.mapping_start.tag);
1013            break;
[210]1014
1015        default:
1016            break;
[199]1017    }
1018
1019    memset(event, 0, sizeof(yaml_event_t));
1020}
1021
[237]1022#if 0
1023
1024/*
1025 * Create a SCALAR node.
1026 */
1027
1028YAML_DECLARE(int)
1029yaml_scalar_node_initialize(yaml_node_t *node,
1030        yaml_char_t *tag, yaml_char_t *value, int length,
1031        yaml_scalar_style_t style)
1032{
1033    yaml_mark_t mark = { 0, 0, 0 };
1034    yaml_char_t *tag_copy = NULL;
1035    yaml_char_t *value_copy = NULL;
1036
1037    assert(node);       /* Non-NULL node object is expected. */
1038    assert(value);      /* Non-NULL anchor is expected. */
1039
1040    if (!tag) {
1041        tag = YAML_DEFAULT_SCALAR_TAG;
1042    }
1043
1044    if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1045    tag_copy = yaml_strdup(tag);
1046    if (!tag_copy) goto error;
1047
1048    if (length < 0) {
1049        length = strlen((char *)value);
1050    }
1051
1052    if (!yaml_check_utf8(value, length)) goto error;
1053    value_copy = yaml_malloc(length+1);
1054    if (!value_copy) goto error;
1055    memcpy(value_copy, value, length);
1056    value_copy[length] = '\0';
1057
1058    SCALAR_NODE_INIT(*node, tag_copy, value_copy, length, style, mark, mark);
1059
1060    return 1;
1061
1062error:
1063    yaml_free(tag_copy);
1064    yaml_free(value_copy);
1065
1066    return 0;
1067}
1068
1069/*
1070 * Create a SEQUENCE node.
1071 */
1072
1073YAML_DECLARE(int)
1074yaml_sequence_node_initialize(yaml_node_t *node,
1075        yaml_char_t *tag, yaml_sequence_style_t style)
1076{
1077    struct {
1078        yaml_error_type_t error;
1079    } context;
1080    yaml_mark_t mark = { 0, 0, 0 };
1081    yaml_char_t *tag_copy = NULL;
1082    struct {
1083        yaml_node_item_t *start;
1084        yaml_node_item_t *end;
1085        yaml_node_item_t *top;
1086    } items = { NULL, NULL, NULL };
1087
1088    assert(node);   /* Non-NULL node object is expected. */
1089
1090    if (!tag) {
1091        tag = YAML_DEFAULT_SEQUENCE_TAG;
1092    }
1093
1094    if (tag) {
1095        if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1096        tag_copy = yaml_strdup(tag);
1097        if (!tag_copy) goto error;
1098    }
1099
1100    if (!STACK_INIT(context, items, INITIAL_STACK_SIZE)) goto error;
1101
1102    SEQUENCE_NODE_INIT(*node, tag_copy, items.start, item.end, style,
1103            mark, mark);
1104
1105    return 1;
1106
1107error:
1108    yaml_free(tag_copy);
1109    STACK_DEL(context, items);
1110
1111    return 0;
1112}
1113
1114/*
1115 * Create a MAPPING node.
1116 */
1117
1118YAML_DECLARE(int)
1119yaml_mapping_node_initialize(yaml_node_t *node,
1120        yaml_char_t *tag, yaml_mapping_style_t style)
1121{
1122    struct {
1123        yaml_error_type_t error;
1124    } context;
1125    yaml_mark_t mark = { 0, 0, 0 };
1126    yaml_char_t *tag_copy = NULL;
1127    struct {
1128        yaml_node_pair_t *start;
1129        yaml_node_pair_t *end;
1130        yaml_node_pair_t *top;
1131    } pairs = { NULL, NULL, NULL };
1132
1133    assert(node);   /* Non-NULL node object is expected. */
1134
1135    if (!tag) {
1136        tag = YAML_DEFAULT_MAPPING_TAG;
1137    }
1138
1139    if (tag) {
1140        if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1141        tag_copy = yaml_strdup(tag);
1142        if (!tag_copy) goto error;
1143    }
1144
1145    if (!STACK_INIT(context, pairs, INITIAL_STACK_SIZE)) goto error;
1146
1147    MAPPING_NODE_INIT(*node, tag_copy, pairs.start, pairs.end, style,
1148            mark, mark);
1149
1150    return 1;
1151
1152error:
1153    yaml_free(tag_copy);
1154    STACK_DEL(context, pairs);
1155
1156    return 0;
1157}
1158
1159/*
1160 * Delete a node and its subnodes.
1161 */
1162
1163YAML_DECLARE(void)
1164yaml_node_delete(yaml_node_t *node)
1165{
1166    struct {
1167        yaml_error_type_t error;
1168    } context;
1169    struct {
1170        yaml_node_item_t *start;
1171        yaml_node_item_t *end;
1172        yaml_node_item_t *head;
1173        yaml_node_item_t *tail;
1174    } queue = { NULL, NULL, NULL, NULL };
1175
1176    assert(node);   /* Non-NULL node object is expected. */
1177
1178    if (node->type == YAML_SCALAR_NODE) {
1179        yaml_free(node->data.scalar.tag);
1180        yaml_free(node->data.scalar.value);
1181        memset(node, 0, sizeof(yaml_node_t));
1182        return;
1183    }
1184
1185    if (!QUEUE_INIT(context, queue, INITIAL_QUEUE_SIZE)) goto error;
1186    if (!ENQUEUE(context, queue, node)) goto error;
1187
1188    while (!QUEUE_EMPTY(context, queue)) {
1189        yaml_node_t node = DEQUEUE(context, queue);
1190        if (node.type == YAML_SCALAR_NODE) {
1191            if (!node->reference)
1192        }
1193        if (node->type == YAML_SEQUENCE_NODE) {
1194            while (!STACK_EMPTY(context, node->data.sequence.items)) {
1195                yaml_node_t *item =
1196            }
1197        }
1198    }
1199}
1200
1201#endif
1202
Note: See TracBrowser for help on using the repository browser.