Ignore:
Timestamp:
12/25/07 18:19:23 (6 years ago)
Author:
xi
Message:

API refactoring (Note: it breaks the build).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libyaml/trunk/src/api.c

    r243 r261  
    7272 
    7373YAML_DECLARE(int) 
    74 yaml_string_extend(yaml_char_t **start, 
    75         yaml_char_t **pointer, yaml_char_t **end) 
    76 { 
    77     yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2); 
    78  
    79     if (!new_start) return 0; 
    80  
    81     memset(new_start + (*end - *start), 0, *end - *start); 
    82  
    83     *pointer = new_start + (*pointer - *start); 
    84     *end = new_start + (*end - *start)*2; 
    85     *start = new_start; 
    86  
    87     return 1; 
    88 } 
    89  
    90 /* 
    91  * Append a string B to a string A. 
     74yaml_string_extend(yaml_char_t **buffer, size_t *capacity) 
     75{ 
     76    yaml_char_t *new_buffer = yaml_realloc(*buffer, (*capacity)*2); 
     77 
     78    if (!new_buffer) return 0; 
     79 
     80    memset(new_buffer + *capacity, 0, *capacity); 
     81 
     82    *buffer = new_buffer; 
     83    *capacity *= 2; 
     84 
     85    return 1; 
     86} 
     87 
     88/* 
     89 * Append an adjunct string to a base string. 
    9290 */ 
    9391 
    9492YAML_DECLARE(int) 
    9593yaml_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) 
     94        yaml_char_t **base_buffer, size_t *base_pointer, size_t *base_capacity, 
     95        yaml_char_t *adj_buffer, size_t adj_pointer, size_t adj_capacity) 
     96{ 
     97    if (!adj_pointer) 
    10098        return 1; 
    10199 
    102     while (*a_end - *a_pointer <= *b_pointer - *b_start) { 
    103         if (!yaml_string_extend(a_start, a_pointer, a_end)) 
     100    while (*base_capacity - *base_pointer <= adj_pointer) { 
     101        if (!yaml_string_extend(base_buffer, base_capacity)) 
    104102            return 0; 
    105103    } 
    106104 
    107     memcpy(*a_pointer, *b_start, *b_pointer - *b_start); 
    108     *a_pointer += *b_pointer - *b_start; 
     105    memcpy(*base_buffer+*base_pointer, adj_buffer, adj_pointer); 
     106    *base_pointer += adj_pointer; 
    109107 
    110108    return 1; 
     
    116114 
    117115YAML_DECLARE(int) 
    118 yaml_stack_extend(void **start, void **top, void **end) 
    119 { 
    120     void *new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2); 
    121  
    122     if (!new_start) return 0; 
    123  
    124     *top = (char *)new_start + ((char *)*top - (char *)*start); 
    125     *end = (char *)new_start + ((char *)*end - (char *)*start)*2; 
    126     *start = new_start; 
     116yaml_stack_extend(void **list, size_t size, size_t *length, size_t *capacity) 
     117{ 
     118    void *new_list = yaml_realloc(*list, (*capacity)*size*2); 
     119 
     120    if (!new_list) return 0; 
     121 
     122    *list = new_list; 
     123    *capacity *= 2; 
    127124 
    128125    return 1; 
     
    134131 
    135132YAML_DECLARE(int) 
    136 yaml_queue_extend(void **start, void **head, void **tail, void **end) 
     133yaml_queue_extend(void **list, size_t size, 
     134        size_t *head, size_t *tail, size_t *capacity) 
    137135{ 
    138136    /* Check if we need to resize the queue. */ 
    139137 
    140     if (*start == *head && *tail == *end) { 
    141         void *new_start = yaml_realloc(*start, 
    142                 ((char *)*end - (char *)*start)*2); 
    143  
    144         if (!new_start) return 0; 
    145  
    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; 
     138    if (*head == 0 && *tail == *capacity) { 
     139        void *new_list = yaml_realloc(*list, (*capacity)*size*2); 
     140 
     141        if (!new_list) return 0; 
     142 
     143        *list = new_list; 
     144        *capacity *= 2; 
    150145    } 
    151146 
    152147    /* Check if we need to move the queue at the beginning of the buffer. */ 
    153148 
    154     if (*tail == *end) { 
     149    if (*tail == *capacity) { 
    155150        if (*head != *tail) { 
    156             memmove(*start, *head, (char *)*tail - (char *)*head); 
     151            memmove((char *)*list, (char *)*list + (*head)*size, 
     152                    (*tail-*head)*size); 
    157153        } 
    158         *tail = (char *)*tail - (char *)*head + (char *)*start; 
    159         *head = *start; 
     154        *tail -= *head; 
     155        *head = 0; 
    160156    } 
    161157 
     
    168164 */ 
    169165 
    170 YAML_DECLARE(int) 
    171 yaml_parser_initialize(yaml_parser_t *parser) 
    172 { 
    173     assert(parser);     /* Non-NULL parser object expected. */ 
     166YAML_DECLARE(yaml_parser_t *) 
     167yaml_parser_new(void) 
     168{ 
     169    yaml_parser_t *parser = yaml_malloc(sizeof(yaml_parser_t)); 
     170 
     171    if (!parser) 
     172        return NULL; 
    174173 
    175174    memset(parser, 0, sizeof(yaml_parser_t)); 
    176     if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE)) 
     175    if (!BUFFER_INIT(parser, parser->raw_input, RAW_INPUT_BUFFER_CAPACITY)) 
    177176        goto error; 
    178     if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE)) 
     177    if (!BUFFER_INIT(parser, parser->input, INPUT_BUFFER_CAPACITY)) 
    179178        goto error; 
    180     if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE)) 
     179    if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_CAPACITY)) 
    181180        goto error; 
    182     if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE)) 
     181    if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_CAPACITY)) 
    183182        goto error; 
    184     if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE)) 
     183    if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_CAPACITY)) 
    185184        goto error; 
    186     if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE)) 
     185    if (!STACK_INIT(parser, parser->states, INITIAL_STACK_CAPACITY)) 
    187186        goto error; 
    188     if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE)) 
     187    if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_CAPACITY)) 
    189188        goto error; 
    190     if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE)) 
     189    if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_CAPACITY)) 
    191190        goto error; 
    192191 
    193     return 1; 
     192    return parser; 
    194193 
    195194error: 
    196  
    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); 
    205  
    206     return 0; 
     195    yaml_parser_delete(parser); 
     196 
     197    return NULL; 
    207198} 
    208199 
     
    216207    assert(parser); /* Non-NULL parser object expected. */ 
    217208 
    218     BUFFER_DEL(parser, parser->raw_buffer); 
    219     BUFFER_DEL(parser, parser->buffer); 
     209    BUFFER_DEL(parser, parser->raw_input); 
     210    BUFFER_DEL(parser, parser->input); 
    220211    while (!QUEUE_EMPTY(parser, parser->tokens)) { 
    221         yaml_token_delete(&DEQUEUE(parser, parser->tokens)); 
     212        yaml_token_destroy(&DEQUEUE(parser, parser->tokens)); 
    222213    } 
    223214    QUEUE_DEL(parser, parser->tokens); 
     
    234225 
    235226    memset(parser, 0, sizeof(yaml_parser_t)); 
    236 } 
    237  
    238 /* 
    239  * String read handler. 
     227    yaml_free(parser); 
     228} 
     229 
     230/* 
     231 * Get the current parser error. 
     232 */ 
     233 
     234YAML_DECLARE(void) 
     235yaml_parser_get_error(yaml_parser_t *parser, yaml_error_t *error) 
     236{ 
     237    assert(parser); /* Non-NULL parser object expected. */ 
     238 
     239    *error = parser->error; 
     240} 
     241 
     242/* 
     243 * Standard string read handler. 
    240244 */ 
    241245 
    242246static int 
    243 yaml_string_read_handler(void *data, unsigned char *buffer, size_t size, 
    244         size_t *size_read) 
    245 { 
    246     yaml_parser_t *parser = data; 
    247  
    248     if (parser->input.string.current == parser->input.string.end) { 
    249         *size_read = 0; 
     247yaml_string_reader(void *untyped_data, unsigned char *buffer, size_t capacity, 
     248        size_t *length) 
     249{ 
     250    yaml_standard_reader_data_t *data = untyped_data; 
     251 
     252    if (data->string.pointer == data->string.capacity) { 
     253        *length = 0; 
    250254        return 1; 
    251255    } 
    252256 
    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     } 
    257  
    258     memcpy(buffer, parser->input.string.current, size); 
    259     parser->input.string.current += size; 
    260     *size_read = size; 
    261     return 1; 
    262 } 
    263  
    264 /* 
    265  * File read handler. 
     257    if (capacity > (size_t)(data->string.capacity - data->string.pointer)) { 
     258        capacity = data->string.capacity - data->string.pointer; 
     259    } 
     260 
     261    memcpy(buffer, data->string.buffer + data->string.pointer, capacity); 
     262    data->string.pointer += capacity; 
     263    *length = capacity; 
     264    return 1; 
     265} 
     266 
     267/* 
     268 * Standard file read handler. 
    266269 */ 
    267270 
    268271static int 
    269 yaml_file_read_handler(void *data, unsigned char *buffer, size_t size, 
    270         size_t *size_read) 
    271 { 
    272     yaml_parser_t *parser = data; 
    273  
    274     *size_read = fread(buffer, 1, size, parser->input.file); 
    275     return !ferror(parser->input.file); 
     272yaml_file_reader(void *untyped_data, unsigned char *buffer, size_t capacity, 
     273        size_t *length) 
     274{ 
     275    yaml_standard_reader_data_t *data = untyped_data; 
     276 
     277    *length = fread(buffer, 1, capacity, data->file); 
     278    return !ferror(data->file); 
    276279} 
    277280 
     
    281284 
    282285YAML_DECLARE(void) 
    283 yaml_parser_set_input_string(yaml_parser_t *parser, 
    284         const unsigned char *input, size_t size) 
     286yaml_parser_set_string_reader(yaml_parser_t *parser, 
     287        const unsigned char *buffer, size_t length) 
    285288{ 
    286289    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. */ 
    289  
    290     parser->read_handler = yaml_string_read_handler; 
    291     parser->read_handler_data = parser; 
    292  
    293     parser->input.string.start = input; 
    294     parser->input.string.current = input; 
    295     parser->input.string.end = input+size; 
     290    assert(!parser->reader);    /* You can set the input handler only once. */ 
     291    assert(buffer); /* Non-NULL input string expected. */ 
     292 
     293    parser->reader = yaml_string_reader; 
     294    parser->reader_data = &(parser->standard_reader_data); 
     295 
     296    parser->standard_reader_data.string.buffer = (unsigned char *)buffer; 
     297    parser->standard_reader_data.string.pointer = 0; 
     298    parser->standard_reader_data.string.capacity = length; 
    296299} 
    297300 
     
    301304 
    302305YAML_DECLARE(void) 
    303 yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file) 
     306yaml_parser_set_file_reader(yaml_parser_t *parser, FILE *file) 
    304307{ 
    305308    assert(parser); /* Non-NULL parser object expected. */ 
    306     assert(!parser->read_handler);  /* You can set the source only once. */ 
     309    assert(!parser->reader);    /* You can set the input handler only once. */ 
    307310    assert(file);   /* Non-NULL file object expected. */ 
    308311 
    309     parser->read_handler = yaml_file_read_handler; 
    310     parser->read_handler_data = parser; 
    311  
    312     parser->input.file = file; 
     312    parser->reader = yaml_file_reader; 
     313    parser->reader_data = &(parser->standard_reader_data); 
     314 
     315    parser->standard_reader_data.file = file; 
    313316} 
    314317 
     
    318321 
    319322YAML_DECLARE(void) 
    320 yaml_parser_set_input(yaml_parser_t *parser, 
    321         yaml_read_handler_t *handler, void *data) 
     323yaml_parser_set_reader(yaml_parser_t *parser, 
     324        yaml_reader_t *reader, void *data) 
    322325{ 
    323326    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. */ 
    326  
    327     parser->read_handler = handler; 
    328     parser->read_handler_data = data; 
     327    assert(!parser->reader);    /* You can set the input handler only once. */ 
     328    assert(reader); /* Non-NULL read handler expected. */ 
     329 
     330    parser->reader = reader; 
     331    parser->reader_data = data; 
    329332} 
    330333 
     
    337340{ 
    338341    assert(parser); /* Non-NULL parser object expected. */ 
    339     assert(!parser->encoding); /* Encoding is already set or detected. */ 
     342    assert(!parser->encoding);  /* Encoding is already set or detected. */ 
    340343 
    341344    parser->encoding = encoding; 
     
    346349 */ 
    347350 
    348 YAML_DECLARE(int) 
    349 yaml_emitter_initialize(yaml_emitter_t *emitter) 
     351YAML_DECLARE(yaml_emitter_t *) 
     352yaml_emitter_new(void) 
     353{ 
     354    yaml_emitter_t *emitter = yaml_malloc(sizeof(yaml_emitter_t)); 
     355 
     356    if (!emitter) 
     357        return NULL; 
     358 
     359    memset(emitter, 0, sizeof(yaml_emitter_t)); 
     360    if (!BUFFER_INIT(emitter, emitter->output, OUTPUT_BUFFER_CAPACITY)) 
     361        goto error; 
     362    if (!BUFFER_INIT(emitter, emitter->raw_output, RAW_OUTPUT_BUFFER_CAPACITY)) 
     363        goto error; 
     364    if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_CAPACITY)) 
     365        goto error; 
     366    if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_CAPACITY)) 
     367        goto error; 
     368    if (!STACK_INIT(emitter, emitter->indents, INITIAL_STACK_CAPACITY)) 
     369        goto error; 
     370    if (!STACK_INIT(emitter, emitter->tag_directives, INITIAL_STACK_CAPACITY)) 
     371        goto error; 
     372 
     373    return emitter; 
     374 
     375error: 
     376    yaml_emitter_delete(emitter); 
     377 
     378    return NULL; 
     379} 
     380 
     381/* 
     382 * Destroy an emitter object. 
     383 */ 
     384 
     385YAML_DECLARE(void) 
     386yaml_emitter_delete(yaml_emitter_t *emitter) 
    350387{ 
    351388    assert(emitter);    /* Non-NULL emitter object expected. */ 
    352389 
    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; 
    366  
    367     return 1; 
    368  
    369 error: 
    370  
    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); 
    377  
    378     return 0; 
    379 } 
    380  
    381 /* 
    382  * Destroy an emitter object. 
    383  */ 
    384  
    385 YAML_DECLARE(void) 
    386 yaml_emitter_delete(yaml_emitter_t *emitter) 
    387 { 
    388     assert(emitter);    /* Non-NULL emitter object expected. */ 
    389  
    390     BUFFER_DEL(emitter, emitter->buffer); 
    391     BUFFER_DEL(emitter, emitter->raw_buffer); 
     390    BUFFER_DEL(emitter, emitter->output); 
     391    BUFFER_DEL(emitter, emitter->raw_output); 
    392392    STACK_DEL(emitter, emitter->states); 
    393393    while (!QUEUE_EMPTY(emitter, emitter->events)) { 
     
    405405 
    406406    memset(emitter, 0, sizeof(yaml_emitter_t)); 
     407    yaml_free(emitter); 
     408} 
     409 
     410/* 
     411 * Get the current emitter error. 
     412 */ 
     413 
     414YAML_DECLARE(void) 
     415yaml_emitter_get_error(yaml_emitter_t *emitter, yaml_error_t *error) 
     416{ 
     417    assert(emitter);    /* Non-NULL emitter object expected. */ 
     418 
     419    *error = emitter->error; 
    407420} 
    408421 
     
    412425 
    413426static int 
    414 yaml_string_write_handler(void *data, unsigned char *buffer, size_t size) 
    415 { 
    416     yaml_emitter_t *emitter = data; 
    417  
    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     } 
    428  
    429     memcpy(emitter->output.string.buffer 
    430             + *emitter->output.string.size_written, buffer, size); 
    431     *emitter->output.string.size_written += size; 
    432     return 1; 
     427yaml_string_writer(void *untyped_data, unsigned char *buffer, size_t length) 
     428{ 
     429    yaml_standard_writer_data_t *data = untyped_data; 
     430    int result = 1; 
     431 
     432    if (data->string.capacity - data->string.pointer < length) { 
     433        length = data->string.capacity - data->string.pointer; 
     434        result = 0; 
     435    } 
     436 
     437    memcpy(data->string.buffer + data->string.pointer, buffer, length); 
     438    data->string.pointer += length; 
     439    *data->length += length; 
     440 
     441    return result; 
    433442} 
    434443 
     
    438447 
    439448static int 
    440 yaml_file_write_handler(void *data, unsigned char *buffer, size_t size) 
    441 { 
    442     yaml_emitter_t *emitter = data; 
    443  
    444     return (fwrite(buffer, 1, size, emitter->output.file) == size); 
     449yaml_file_writer(void *untyped_data, unsigned char *buffer, size_t length) 
     450{ 
     451    yaml_standard_writer_data_t *data = untyped_data; 
     452 
     453    return (fwrite(buffer, 1, length, data->file) == length); 
    445454} 
    446455/* 
     
    449458 
    450459YAML_DECLARE(void) 
    451 yaml_emitter_set_output_string(yaml_emitter_t *emitter, 
    452         unsigned char *output, size_t size, size_t *size_written) 
     460yaml_emitter_set_string_writer(yaml_emitter_t *emitter, 
     461        unsigned char *buffer, size_t *length, size_t capacity) 
    453462{ 
    454463    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. */ 
    457  
    458     emitter->write_handler = yaml_string_write_handler; 
    459     emitter->write_handler_data = emitter; 
    460  
    461     emitter->output.string.buffer = output; 
    462     emitter->output.string.size = size; 
    463     emitter->output.string.size_written = size_written; 
    464     *size_written = 0; 
     464    assert(!emitter->writer);   /* You can set the output only once. */ 
     465    assert(buffer);     /* Non-NULL output string expected. */ 
     466 
     467    emitter->writer = yaml_string_writer; 
     468    emitter->writer_data = &(emitter->standard_writer_data); 
     469 
     470    emitter->standard_writer_data.string.buffer = buffer; 
     471    emitter->standard_writer_data.string.pointer = 0; 
     472    emitter->standard_writer_data.string.capacity = capacity; 
     473    emitter->standard_writer_data.length = length; 
     474 
     475    *length = 0; 
    465476} 
    466477 
     
    470481 
    471482YAML_DECLARE(void) 
    472 yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file) 
     483yaml_emitter_set_file_writer(yaml_emitter_t *emitter, FILE *file) 
    473484{ 
    474485    assert(emitter);    /* Non-NULL emitter object expected. */ 
    475     assert(!emitter->write_handler);    /* You can set the output only once. */ 
     486    assert(!emitter->writer);   /* You can set the output only once. */ 
    476487    assert(file);       /* Non-NULL file object expected. */ 
    477488 
    478     emitter->write_handler = yaml_file_write_handler; 
    479     emitter->write_handler_data = emitter; 
    480  
    481     emitter->output.file = file; 
     489    emitter->writer = yaml_string_writer; 
     490    emitter->writer_data = &(emitter->standard_writer_data); 
     491 
     492    emitter->standard_writer_data.file = file; 
    482493} 
    483494 
     
    487498 
    488499YAML_DECLARE(void) 
    489 yaml_emitter_set_output(yaml_emitter_t *emitter, 
    490         yaml_write_handler_t *handler, void *data) 
     500yaml_emitter_set_writer(yaml_emitter_t *emitter, 
     501        yaml_writer_t *writer, void *data) 
    491502{ 
    492503    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. */ 
    495  
    496     emitter->write_handler = handler; 
    497     emitter->write_handler_data = data; 
     504    assert(!emitter->writer);   /* You can set the output only once. */ 
     505    assert(writer); /* Non-NULL handler object expected. */ 
     506 
     507    emitter->writer = writer; 
     508    emitter->writer_data = data; 
    498509} 
    499510 
     
    516527 
    517528YAML_DECLARE(void) 
    518 yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical) 
     529yaml_emitter_set_canonical(yaml_emitter_t *emitter, int is_canonical) 
    519530{ 
    520531    assert(emitter);    /* Non-NULL emitter object expected. */ 
    521532 
    522     emitter->canonical = (canonical != 0); 
     533    emitter->is_canonical = (is_canonical != 0); 
    523534} 
    524535 
     
    552563 
    553564YAML_DECLARE(void) 
    554 yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode) 
     565yaml_emitter_set_unicode(yaml_emitter_t *emitter, int is_unicode) 
    555566{ 
    556567    assert(emitter);    /* Non-NULL emitter object expected. */ 
    557568 
    558     emitter->unicode = (unicode != 0); 
     569    emitter->is_unicode = (is_unicode != 0); 
    559570} 
    560571 
     
    572583 
    573584/* 
     585 * Allocate a token object. 
     586 */ 
     587 
     588YAML_DECLARE(yaml_token_t *) 
     589yaml_token_new(void) 
     590{ 
     591    yaml_token_t *token = yaml_malloc(sizeof(yaml_token_t)); 
     592 
     593    if (!token) 
     594        return NULL; 
     595 
     596    memset(token, 0, sizeof(yaml_token_t)); 
     597 
     598    return token; 
     599} 
     600 
     601/* 
     602 * Deallocate a token object. 
     603 */ 
     604 
     605YAML_DECLARE(void) 
     606yaml_token_delete(yaml_token_t *token) 
     607{ 
     608    assert(token);  /* Non-NULL token object expected. */ 
     609 
     610    yaml_token_destroy(token); 
     611    yaml_free(token); 
     612} 
     613 
     614/* 
     615 * Duplicate a token object. 
     616 */ 
     617 
     618YAML_DECLARE(int) 
     619yaml_token_duplicate(yaml_token_t *token, yaml_token_t *model) 
     620{ 
     621    assert(token);  /* Non-NULL token object is expected. */ 
     622    assert(model);  /* Non-NULL model token object is expected. */ 
     623 
     624    memset(token, 0, sizeof(yaml_token_t)); 
     625 
     626    token->type = model->type; 
     627    token->start_mark = model->start_mark; 
     628    token->end_mark = model->end_mark; 
     629 
     630    switch (token->type) 
     631    { 
     632        case YAML_STREAM_START_TOKEN: 
     633            token->data.stream_start.encoding = 
     634                model->data.stream_start.encoding; 
     635            break; 
     636 
     637        case YAML_VERSION_DIRECTIVE_TOKEN: 
     638            token->data.version_directive.major = 
     639                model->data.version_directive.major; 
     640            token->data.version_directive.minor = 
     641                model->data.version_directive.minor; 
     642            break; 
     643 
     644        case YAML_TAG_DIRECTIVE_TOKEN: 
     645            if (!(token->data.tag_directive.handle = 
     646                        yaml_strdup(model->data.tag_directive.handle))) 
     647                goto error; 
     648            if (!(token->data.tag_directive.prefix = 
     649                        yaml_strdup(model->data.tag_directive.prefix))) 
     650                goto error; 
     651            break; 
     652 
     653        case YAML_ALIAS_TOKEN: 
     654            if (!(token->data.alias.value = 
     655                        yaml_strdup(model->data.alias.value))) 
     656                goto error; 
     657            break; 
     658 
     659        case YAML_ANCHOR_TOKEN: 
     660            if (!(token->data.anchor.value = 
     661                        yaml_strdup(model->data.anchor.value))) 
     662                goto error; 
     663            break; 
     664 
     665        case YAML_TAG_TOKEN: 
     666            if (!(token->data.tag.handle = yaml_strdup(model->data.tag.handle))) 
     667                goto error; 
     668            if (!(token->data.tag.suffix = yaml_strdup(model->data.tag.suffix))) 
     669                goto error; 
     670            break; 
     671 
     672        case YAML_SCALAR_TOKEN: 
     673            if (!(token->data.scalar.value = 
     674                        yaml_malloc(model->data.scalar.length+1))) 
     675                goto error; 
     676            memcpy(token->data.scalar.value, model->data.scalar.value, 
     677                    model->data.scalar.length+1); 
     678            token->data.scalar.length = model->data.scalar.length; 
     679            break; 
     680 
     681        default: 
     682            break; 
     683    } 
     684 
     685    return 1; 
     686 
     687error: 
     688    yaml_token_destroy(token); 
     689 
     690    return 0; 
     691} 
     692 
     693/* 
    574694 * Destroy a token object. 
    575695 */ 
    576696 
    577697YAML_DECLARE(void) 
    578 yaml_token_delete(yaml_token_t *token) 
     698yaml_token_destroy(yaml_token_t *token) 
    579699{ 
    580700    assert(token);  /* Non-NULL token object expected. */ 
     
    618738 
    619739static int 
    620 yaml_check_utf8(yaml_char_t *start, size_t length) 
    621 { 
    622     yaml_char_t *end = start+length; 
    623     yaml_char_t *pointer = start; 
    624  
    625     while (pointer < end) { 
     740yaml_valid_utf8(const yaml_char_t *buffer, size_t length) 
     741{ 
     742    size_t pointer = 0; 
     743 
     744    while (pointer < length) { 
    626745        unsigned char octet; 
    627746        unsigned int width; 
     
    629748        size_t k; 
    630749 
    631         octet = pointer[0]; 
     750        octet = buffer[pointer]; 
    632751        width = (octet & 0x80) == 0x00 ? 1 : 
    633752                (octet & 0xE0) == 0xC0 ? 2 : 
     
    639758                (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; 
    640759        if (!width) return 0; 
    641         if (pointer+width > end) return 0; 
     760        if (pointer+width > length) return 0; 
    642761        for (k = 1; k < width; k ++) { 
    643             octet = pointer[k]; 
     762            octet = buffer[pointer+k]; 
    644763            if ((octet & 0xC0) != 0x80) return 0; 
    645764            value = (value << 6) + (octet & 0x3F); 
     
    657776 
    658777/* 
     778 * Allocate an event object. 
     779 */ 
     780 
     781YAML_DECLARE(yaml_event_t *) 
     782yaml_event_new(void) 
     783{ 
     784    yaml_event_t *event = yaml_malloc(sizeof(yaml_event_t)); 
     785 
     786    if (!event) 
     787        return NULL; 
     788 
     789    memset(event, 0, sizeof(yaml_event_t)); 
     790 
     791    return event; 
     792} 
     793 
     794/* 
     795 * Deallocate an event object. 
     796 */ 
     797 
     798YAML_DECLARE(void) 
     799yaml_event_delete(yaml_event_t *event) 
     800{ 
     801    assert(event);  /* Non-NULL event object expected. */ 
     802 
     803    yaml_event_destroy(event); 
     804    yaml_free(event); 
     805} 
     806 
     807/* 
     808 * Duplicate an event object. 
     809 */ 
     810 
     811YAML_DECLARE(int) 
     812yaml_event_duplicate(yaml_event_t *event, yaml_event_t *model) 
     813{ 
     814    struct { 
     815        yaml_error_t error; 
     816    } self; 
     817 
     818    assert(event);  /* Non-NULL event object is expected. */ 
     819    assert(model);  /* Non-NULL model event object is expected. */ 
     820 
     821    memset(event, 0, sizeof(yaml_event_t)); 
     822 
     823    event->type = model->type; 
     824    event->start_mark = model->start_mark; 
     825    event->end_mark = model->end_mark; 
     826 
     827    switch (event->type) 
     828    { 
     829        case YAML_STREAM_START_EVENT: 
     830            event->data.stream_start.encoding = 
     831                model->data.stream_start.encoding; 
     832            break; 
     833 
     834        case YAML_DOCUMENT_START_EVENT: 
     835            if (model->data.document_start.version_directive) { 
     836                if (!(event->data.document_start.version_directive = 
     837                            yaml_malloc(sizeof(yaml_version_directive_t)))) 
     838                    goto error; 
     839                *event->data.document_start.version_directive = 
     840                    *model->data.document_start.version_directive; 
     841            } 
     842            if (model->data.document_start.tag_directives.length) { 
     843                yaml_tag_directive_t *tag_directives = 
     844                    model->data.document_start.tag_directives.list; 
     845                if (!STACK_INIT(&self, event->data.document_start.tag_directives, 
     846                            model->data.document_start.tag_directives.capacity)) 
     847                    goto error; 
     848                while (event->data.document_start.tag_directives.length != 
     849                        model->data.document_start.tag_directives.length) { 
     850                    yaml_tag_directive_t value; 
     851                    value.handle = yaml_strdup(tag_directives->handle); 
     852                    value.prefix = yaml_strdup(tag_directives->prefix); 
     853                    PUSH(&self, event->data.document_start.tag_directives, value); 
     854                    if (!value.handle || !value.prefix) 
     855                        goto error; 
     856                    tag_directives ++; 
     857                } 
     858            } 
     859            event->data.document_start.is_implicit = 
     860                model->data.document_start.is_implicit; 
     861            break; 
     862 
     863        case YAML_DOCUMENT_END_EVENT: 
     864            event->data.document_end.is_implicit = 
     865                model->data.document_end.is_implicit; 
     866 
     867        case YAML_ALIAS_EVENT: 
     868            if (!(event->data.alias.anchor = 
     869                        yaml_strdup(model->data.alias.anchor))) 
     870                goto error; 
     871            break; 
     872 
     873        case YAML_SCALAR_EVENT: 
     874            if (model->data.scalar.anchor && 
     875                    !(event->data.scalar.anchor = 
     876                        yaml_strdup(model->data.scalar.anchor))) 
     877                goto error; 
     878            if (event->data.scalar.tag && 
     879                    !(event->data.scalar.tag = 
     880                        yaml_strdup(model->data.scalar.tag))) 
     881                goto error; 
     882            if (!(event->data.scalar.value = 
     883                        yaml_malloc(model->data.scalar.length+1))) 
     884                goto error; 
     885            memcpy(event->data.scalar.value, model->data.scalar.value, 
     886                    model->data.scalar.length+1); 
     887            event->data.scalar.length = model->data.scalar.length; 
     888            event->data.scalar.is_plain_implicit = 
     889                model->data.scalar.is_plain_implicit; 
     890            event->data.scalar.is_quoted_implicit = 
     891                model->data.scalar.is_quoted_implicit; 
     892            event->data.scalar.style = model->data.scalar.style; 
     893            break; 
     894 
     895        case YAML_SEQUENCE_START_EVENT: 
     896            if (model->data.sequence_start.anchor && 
     897                    !(event->data.sequence_start.anchor = 
     898                        yaml_strdup(model->data.sequence_start.anchor))) 
     899                goto error; 
     900            if (event->data.sequence_start.tag && 
     901                    !(event->data.sequence_start.tag = 
     902                        yaml_strdup(model->data.sequence_start.tag))) 
     903                goto error; 
     904            event->data.sequence_start.is_implicit = 
     905                model->data.sequence_start.is_implicit; 
     906            event->data.sequence_start.style = 
     907                model->data.sequence_start.style; 
     908            break; 
     909 
     910        case YAML_MAPPING_START_EVENT: 
     911            if (model->data.mapping_start.anchor && 
     912                    !(event->data.mapping_start.anchor = 
     913                        yaml_strdup(model->data.mapping_start.anchor))) 
     914                goto error; 
     915            if (event->data.mapping_start.tag && 
     916                    !(event->data.mapping_start.tag = 
     917                        yaml_strdup(model->data.mapping_start.tag))) 
     918                goto error; 
     919            event->data.mapping_start.is_implicit = 
     920                model->data.mapping_start.is_implicit; 
     921            event->data.mapping_start.style = 
     922                model->data.mapping_start.style; 
     923            break; 
     924 
     925        default: 
     926            break; 
     927    } 
     928 
     929    return 1; 
     930 
     931error: 
     932    yaml_event_destroy(event); 
     933 
     934    return 0; 
     935} 
     936 
     937/* 
    659938 * Create STREAM-START. 
    660939 */ 
    661940 
    662941YAML_DECLARE(int) 
    663 yaml_stream_start_event_initialize(yaml_event_t *event, 
     942yaml_event_create_stream_start(yaml_event_t *event, 
    664943        yaml_encoding_t encoding) 
    665944{ 
     
    678957 
    679958YAML_DECLARE(int) 
    680 yaml_stream_end_event_initialize(yaml_event_t *event) 
     959yaml_event_create_stream_end(yaml_event_t *event) 
    681960{ 
    682961    yaml_mark_t mark = { 0, 0, 0 }; 
     
    694973 
    695974YAML_DECLARE(int) 
    696 yaml_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) 
     975yaml_event_create_document_start(yaml_event_t *event, 
     976        const yaml_version_directive_t *version_directive, 
     977        const yaml_tag_directive_t *tag_directives, 
     978        int is_implicit) 
    701979{ 
    702980    struct { 
    703         yaml_error_type_t error; 
    704     } context; 
     981        yaml_error_t error; 
     982    } self; 
    705983    yaml_mark_t mark = { 0, 0, 0 }; 
    706984    yaml_version_directive_t *version_directive_copy = NULL; 
    707985    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 }; 
     986        yaml_tag_directive_t *list; 
     987        size_t length; 
     988        size_t capacity; 
     989    } tag_directives_copy = { NULL, 0, 0 }; 
    713990 
    714991    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. */ 
    718992 
    719993    if (version_directive) { 
    720994        version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t)); 
    721995        if (!version_directive_copy) goto error; 
    722         version_directive_copy->major = version_directive->major; 
    723         version_directive_copy->minor = version_directive->minor; 
    724     } 
    725  
    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)) 
     996        *version_directive_copy = *version_directive; 
     997    } 
     998 
     999    if (tag_directives && (tag_directives->handle || tag_directives->prefix)) { 
     1000        if (!STACK_INIT(&self, tag_directives_copy, INITIAL_STACK_CAPACITY)) 
    7291001            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; 
     1002        while (tag_directives->handle || tag_directives->prefix) { 
     1003            yaml_tag_directive_t value = *tag_directives; 
     1004            assert(value.handle); 
     1005            assert(value.prefix); 
     1006            if (!yaml_valid_utf8(value.handle, strlen((char *)value.handle))) 
     1007                goto error; 
     1008            if (!yaml_valid_utf8(value.prefix, strlen((char *)value.prefix))) 
     1009                goto error; 
     1010            if (!PUSH(&self, tag_directives_copy, value)) 
     1011                goto error; 
     1012            value.handle = yaml_strdup(value.handle); 
     1013            value.prefix = yaml_strdup(value.prefix); 
     1014            tag_directives_copy.list[tag_directives_copy.length-1] = value; 
     1015            if (!value.handle || !value.prefix) 
     1016                goto error; 
    7471017        } 
    7481018    } 
    7491019 
    7501020    DOCUMENT_START_EVENT_INIT(*event, version_directive_copy, 
    751             tag_directives_copy.start, tag_directives_copy.top, 
    752             implicit, mark, mark); 
     1021            tag_directives_copy.list, tag_directives_copy.length, 
     1022            tag_directives_copy.capacity, is_implicit, mark, mark); 
    7531023 
    7541024    return 1; 
     
    7561026error: 
    7571027    yaml_free(version_directive_copy); 
    758     while (!STACK_EMPTY(context, tag_directives_copy)) { 
    759         yaml_tag_directive_t value = POP(context, tag_directives_copy); 
     1028    while (!STACK_EMPTY(&self, tag_directives_copy)) { 
     1029        yaml_tag_directive_t value = POP(&self, tag_directives_copy); 
    7601030        yaml_free(value.handle); 
    7611031        yaml_free(value.prefix); 
    7621032    } 
    763     STACK_DEL(context, tag_directives_copy); 
    764     yaml_free(value.handle); 
    765     yaml_free(value.prefix); 
     1033    STACK_DEL(&self, tag_directives_copy); 
    7661034 
    7671035    return 0; 
     
    7731041 
    7741042YAML_DECLARE(int) 
    775 yaml_document_end_event_initialize(yaml_event_t *event, int implicit) 
     1043yaml_event_create_document_end(yaml_event_t *event, int is_implicit) 
    7761044{ 
    7771045    yaml_mark_t mark = { 0, 0, 0 }; 
     
    7791047    assert(event);      /* Non-NULL emitter object is expected. */ 
    7801048 
    781     DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark); 
     1049    DOCUMENT_END_EVENT_INIT(*event, is_implicit, mark, mark); 
    7821050 
    7831051    return 1; 
     
    7891057 
    7901058YAML_DECLARE(int) 
    791 yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor) 
     1059yaml_event_create_alias(yaml_event_t *event, const yaml_char_t *anchor) 
    7921060{ 
    7931061    yaml_mark_t mark = { 0, 0, 0 }; 
     
    7971065    assert(anchor);     /* Non-NULL anchor is expected. */ 
    7981066 
    799     if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0; 
     1067    if (!yaml_valid_utf8(anchor, strlen((char *)anchor))) return 0; 
    8001068 
    8011069    anchor_copy = yaml_strdup(anchor); 
     
    8131081 
    8141082YAML_DECLARE(int) 
    815 yaml_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, 
     1083yaml_event_create_scalar(yaml_event_t *event, 
     1084        const yaml_char_t *anchor, const yaml_char_t *tag, 
     1085        const yaml_char_t *value, size_t length, 
     1086        int is_plain_implicit, int is_quoted_implicit, 
    8191087        yaml_scalar_style_t style) 
    8201088{ 
     
    8281096 
    8291097    if (anchor) { 
    830         if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error; 
     1098        if (!yaml_valid_utf8(anchor, strlen((char *)anchor))) 
     1099            goto error; 
    8311100        anchor_copy = yaml_strdup(anchor); 
    832         if (!anchor_copy) goto error; 
     1101        if (!anchor_copy) 
     1102            goto error; 
    8331103    } 
    8341104 
    8351105    if (tag) { 
    836         if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; 
     1106        if (!yaml_valid_utf8(tag, strlen((char *)tag))) 
     1107            goto error; 
    8371108        tag_copy = yaml_strdup(tag); 
    838         if (!tag_copy) goto error; 
     1109        if (!tag_copy) 
     1110            goto error; 
    8391111    } 
    8401112 
     
    8431115    } 
    8441116 
    845     if (!yaml_check_utf8(value, length)) goto error; 
     1117    if (!yaml_valid_utf8(value, length)) 
     1118        goto error; 
    8461119    value_copy = yaml_malloc(length+1); 
    847     if (!value_copy) goto error; 
     1120    if (!value_copy) 
     1121        goto error; 
    8481122    memcpy(value_copy, value, length); 
    8491123    value_copy[length] = '\0'; 
    8501124 
    8511125    SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length, 
    852             plain_implicit, quoted_implicit, style, mark, mark); 
     1126            is_plain_implicit, is_quoted_implicit, style, mark, mark); 
    8531127 
    8541128    return 1; 
     
    8671141 
    8681142YAML_DECLARE(int) 
    869 yaml_sequence_start_event_initialize(yaml_event_t *event, 
    870         yaml_char_t *anchor, yaml_char_t *tag, int implicit, 
    871         yaml_sequence_style_t style) 
     1143yaml_event_create_sequence_start(yaml_event_t *event, 
     1144        const yaml_char_t *anchor, const yaml_char_t *tag, 
     1145        int is_implicit, yaml_sequence_style_t style) 
    8721146{ 
    8731147    yaml_mark_t mark = { 0, 0, 0 }; 
     
    8781152 
    8791153    if (anchor) { 
    880         if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error; 
     1154        if (!yaml_valid_utf8(anchor, strlen((char *)anchor))) 
     1155            goto error; 
    8811156        anchor_copy = yaml_strdup(anchor); 
    882         if (!anchor_copy) goto error; 
     1157        if (!anchor_copy) 
     1158            goto error; 
    8831159    } 
    8841160 
    8851161    if (tag) { 
    886         if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; 
     1162        if (!yaml_valid_utf8(tag, strlen((char *)tag))) 
     1163            goto error; 
    8871164        tag_copy = yaml_strdup(tag); 
    888         if (!tag_copy) goto error; 
     1165        if (!tag_copy) 
     1166            goto error; 
    8891167    } 
    8901168 
    8911169    SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy, 
    892             implicit, style, mark, mark); 
     1170            is_implicit, style, mark, mark); 
    8931171 
    8941172    return 1; 
     
    9061184 
    9071185YAML_DECLARE(int) 
    908 yaml_sequence_end_event_initialize(yaml_event_t *event) 
     1186yaml_event_create_sequence_end(yaml_event_t *event) 
    9091187{ 
    9101188    yaml_mark_t mark = { 0, 0, 0 }; 
     
    9221200 
    9231201YAML_DECLARE(int) 
    924 yaml_mapping_start_event_initialize(yaml_event_t *event, 
    925         yaml_char_t *anchor, yaml_char_t *tag, int implicit, 
    926         yaml_mapping_style_t style) 
     1202yaml_event_create_mapping_start(yaml_event_t *event, 
     1203        const yaml_char_t *anchor, const yaml_char_t *tag, 
     1204        int is_implicit, yaml_mapping_style_t style) 
    9271205{ 
    9281206    yaml_mark_t mark = { 0, 0, 0 }; 
     
    9331211 
    9341212    if (anchor) { 
    935         if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error; 
     1213        if (!yaml_valid_utf8(anchor, strlen((char *)anchor))) 
     1214            goto error; 
    9361215        anchor_copy = yaml_strdup(anchor); 
    937         if (!anchor_copy) goto error; 
     1216        if (!anchor_copy) 
     1217            goto error; 
    9381218    } 
    9391219 
    9401220    if (tag) { 
    941         if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; 
     1221        if (!yaml_valid_utf8(tag, strlen((char *)tag))) 
     1222            goto error; 
    9421223        tag_copy = yaml_strdup(tag); 
    943         if (!tag_copy) goto error; 
     1224        if (!tag_copy) 
     1225            goto error; 
    9441226    } 
    9451227 
    9461228    MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy, 
    947             implicit, style, mark, mark); 
     1229            is_implicit, style, mark, mark); 
    9481230 
    9491231    return 1; 
     
    9611243 
    9621244YAML_DECLARE(int) 
    963 yaml_mapping_end_event_initialize(yaml_event_t *event) 
     1245yaml_event_create_mapping_end(yaml_event_t *event) 
    9641246{ 
    9651247    yaml_mark_t mark = { 0, 0, 0 }; 
     
    9771259 
    9781260YAML_DECLARE(void) 
    979 yaml_event_delete(yaml_event_t *event) 
    980 { 
    981     yaml_tag_directive_t *tag_directive; 
     1261yaml_event_destroy(yaml_event_t *event) 
     1262{ 
     1263    struct { 
     1264        yaml_error_t error; 
     1265    } self; 
    9821266 
    9831267    assert(event);  /* Non-NULL event object expected. */ 
     
    9871271        case YAML_DOCUMENT_START_EVENT: 
    9881272            yaml_free(event->data.document_start.version_directive); 
    989             for (tag_directive = event->data.document_start.tag_directives.start; 
    990                     tag_directive != event->data.document_start.tag_directives.end; 
    991                     tag_directive++) { 
    992                 yaml_free(tag_directive->handle); 
    993                 yaml_free(tag_directive->prefix); 
     1273            while (!STACK_EMPTY(&self, event->data.document_start.tag_directives)) { 
     1274                yaml_tag_directive_t value = POP(&self, 
     1275                        event->data.document_start.tag_directives); 
     1276                yaml_free(value.handle); 
     1277                yaml_free(value.prefix); 
    9941278            } 
    995             yaml_free(event->data.document_start.tag_directives.start); 
     1279            STACK_DEL(&self, event->data.document_start.tag_directives); 
    9961280            break; 
    9971281 
     
    10221306    memset(event, 0, sizeof(yaml_event_t)); 
    10231307} 
     1308 
     1309#if 0 
    10241310 
    10251311/* 
     
    10731359            assert(tag_directive->handle); 
    10741360            assert(tag_directive->prefix); 
    1075             if (!yaml_check_utf8(tag_directive->handle, 
     1361            if (!yaml_valid_utf8(tag_directive->handle, 
    10761362                        strlen((char *)tag_directive->handle))) 
    10771363                goto error; 
    1078             if (!yaml_check_utf8(tag_directive->prefix, 
     1364            if (!yaml_valid_utf8(tag_directive->prefix, 
    10791365                        strlen((char *)tag_directive->prefix))) 
    10801366                goto error; 
     
    12111497    } 
    12121498 
    1213     if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; 
     1499    if (!yaml_valid_utf8(tag, strlen((char *)tag))) goto error; 
    12141500    tag_copy = yaml_strdup(tag); 
    12151501    if (!tag_copy) goto error; 
     
    12191505    } 
    12201506 
    1221     if (!yaml_check_utf8(value, length)) goto error; 
     1507    if (!yaml_valid_utf8(value, length)) goto error; 
    12221508    value_copy = yaml_malloc(length+1); 
    12231509    if (!value_copy) goto error; 
     
    12631549    } 
    12641550 
    1265     if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; 
     1551    if (!yaml_valid_utf8(tag, strlen((char *)tag))) goto error; 
    12661552    tag_copy = yaml_strdup(tag); 
    12671553    if (!tag_copy) goto error; 
     
    13081594    } 
    13091595 
    1310     if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error; 
     1596    if (!yaml_valid_utf8(tag, strlen((char *)tag))) goto error; 
    13111597    tag_copy = yaml_strdup(tag); 
    13121598    if (!tag_copy) goto error; 
     
    13861672} 
    13871673 
    1388  
     1674#endif 
     1675 
Note: See TracChangeset for help on using the changeset viewer.