Ignore:
Timestamp:
07/21/06 09:50:32 (8 years ago)
Author:
xi
Message:

Refactor internal and external API.

File:
1 edited

Legend:

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

    r203 r208  
    4040 */ 
    4141 
    42 #if HAVE_CONFIG_H 
    43 #include <config.h> 
    44 #endif 
    45  
    46 #include <yaml.h> 
    47  
    48 #include <assert.h> 
     42#include "yaml_private.h" 
     43 
     44/* 
     45 * Event initializers. 
     46 */ 
     47 
     48#define EVENT_INIT(event,event_type,event_start_mark,event_end_mark)            \ 
     49    (memset(&(event), 0, sizeof(yaml_event_t)),                                 \ 
     50     (event).type = (event_type),                                               \ 
     51     (event).start_mark = (event_start_mark),                                   \ 
     52     (event).end_mark = (event_end_mark)) 
     53 
     54#define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark)       \ 
     55    (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)),       \ 
     56     (event).data.stream_start.encoding = (event_encoding)) 
     57 
     58#define STREAM_END_EVENT_INIT(event,start_mark,end_mark)                        \ 
     59    (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) 
     60 
     61#define DOCUMENT_START_EVENT_INIT(event,event_version_directive,                \ 
     62        event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \ 
     63    (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)),     \ 
     64     (event).data.document_start.version_directive = (event_version_directive), \ 
     65     (event).data.document_start.tag_directives.start = (event_tag_directives_start),   \ 
     66     (event).data.document_start.tag_directives.end = (event_tag_directives_end),   \ 
     67     (event).data.document_start.implicit = (event_implicit)) 
     68 
     69#define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark)       \ 
     70    (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)),       \ 
     71     (event).data.document_end.implicit = (event_implicit)) 
     72 
     73#define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark)                \ 
     74    (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)),              \ 
     75     (event).data.alias.anchor = (event_anchor)) 
     76 
     77#define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length,    \ 
     78        event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark)    \ 
     79    (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)),             \ 
     80     (event).data.scalar.anchor = (event_anchor),                               \ 
     81     (event).data.scalar.tag = (event_tag),                                     \ 
     82     (event).data.scalar.value = (event_value),                                 \ 
     83     (event).data.scalar.length = (event_length),                               \ 
     84     (event).data.scalar.plain_implicit = (event_plain_implicit),               \ 
     85     (event).data.scalar.quoted_implicit = (event_quoted_implicit),             \ 
     86     (event).data.scalar.style = (event_style)) 
     87 
     88#define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag,                 \ 
     89        event_implicit,event_style,start_mark,end_mark)                         \ 
     90    (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)),     \ 
     91     (event).data.sequence_start.anchor = (event_anchor),                       \ 
     92     (event).data.sequence_start.tag = (event_tag),                             \ 
     93     (event).data.sequence_start.implicit = (event_implicit),                   \ 
     94     (event).data.sequence_start.style = (event_style)) 
     95 
     96#define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark)                      \ 
     97    (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) 
     98 
     99#define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag,                  \ 
     100        event_implicit,event_style,start_mark,end_mark)                         \ 
     101    (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)),      \ 
     102     (event).data.mapping_start.anchor = (event_anchor),                        \ 
     103     (event).data.mapping_start.tag = (event_tag),                              \ 
     104     (event).data.mapping_start.implicit = (event_implicit),                    \ 
     105     (event).data.mapping_start.style = (event_style)) 
     106 
     107#define MAPPING_END_EVENT_INIT(event,start_mark,end_mark)                       \ 
     108    (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) 
     109 
     110/* 
     111 * Peek the next token in the token queue. 
     112 */ 
     113 
     114#define PEEK_TOKEN(parser)                                                      \ 
     115    ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ?       \ 
     116        parser->tokens.head : NULL) 
     117 
     118/* 
     119 * Remove the next token from the queue (must be called after PEEK_TOKEN). 
     120 */ 
     121 
     122#define SKIP_TOKEN(parser)                                                      \ 
     123    (parser->token_available = 0,                                               \ 
     124     parser->tokens_parsed ++,                                                  \ 
     125     parser->stream_end_produced =                                              \ 
     126        (parser->tokens.head->type == YAML_STREAM_END_TOKEN),                   \ 
     127     parser->tokens.head ++) 
    49128 
    50129/* 
     
    52131 */ 
    53132 
    54 YAML_DECLARE(yaml_event_t *) 
    55 yaml_parser_get_event(yaml_parser_t *parser); 
    56  
    57 YAML_DECLARE(yaml_event_t *) 
    58 yaml_parser_peek_event(yaml_parser_t *parser); 
     133YAML_DECLARE(int) 
     134yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event); 
    59135 
    60136/* 
     
    72148 
    73149/* 
    74  * Buffers and lists. 
    75  */ 
    76  
    77 static int 
    78 yaml_parser_resize_list(yaml_parser_t *parser, void **buffer, size_t *size, 
    79         size_t item_size); 
     150 * State functions. 
     151 */ 
     152 
     153static int 
     154yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event); 
     155 
     156static int 
     157yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event); 
     158 
     159static int 
     160yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event, 
     161        int implicit); 
     162 
     163static int 
     164yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event); 
     165 
     166static int 
     167yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event); 
     168 
     169static int 
     170yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event, 
     171        int block, int indentless_sequence); 
     172 
     173static int 
     174yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser, 
     175        yaml_event_t *event, int first); 
     176 
     177static int 
     178yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser, 
     179        yaml_event_t *event); 
     180 
     181static int 
     182yaml_parser_parse_block_mapping_key(yaml_parser_t *parser, 
     183        yaml_event_t *event, int first); 
     184 
     185static int 
     186yaml_parser_parse_block_mapping_value(yaml_parser_t *parser, 
     187        yaml_event_t *event); 
     188 
     189static int 
     190yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser, 
     191        yaml_event_t *event, int first); 
     192 
     193static int 
     194yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser, 
     195        yaml_event_t *event); 
     196 
     197static int 
     198yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser, 
     199        yaml_event_t *event); 
     200 
     201static int 
     202yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser, 
     203        yaml_event_t *event); 
     204 
     205static int 
     206yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser, 
     207        yaml_event_t *event, int first); 
     208 
     209static int 
     210yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, 
     211        yaml_event_t *event, int empty); 
     212 
     213/* 
     214 * Utility functions. 
     215 */ 
     216 
     217static int 
     218yaml_parser_process_empty_scalar(yaml_parser_t *parser, 
     219        yaml_event_t *event, yaml_mark_t mark); 
     220 
     221static int 
     222yaml_parser_process_directives(yaml_parser_t *parser, 
     223        yaml_version_directive_t **version_directive_ref, 
     224        yaml_tag_directive_t **tag_directives_start_ref, 
     225        yaml_tag_directive_t **tag_directives_end_ref); 
    80226 
    81227static int 
    82228yaml_parser_append_tag_directive(yaml_parser_t *parser, 
    83         yaml_tag_directive_t *tag_directive); 
    84  
    85 static int 
    86 yaml_parser_append_state(yaml_parser_t *parser, yaml_parser_state_t state); 
    87  
    88 static int 
    89 yaml_parser_append_mark(yaml_parser_t *parser, yaml_mark_t mark); 
    90  
    91 /* 
    92  * State functions. 
    93  */ 
    94  
    95 static yaml_event_t * 
    96 yaml_parser_state_machine(yaml_parser_t *parser); 
    97  
    98 static yaml_event_t * 
    99 yaml_parser_parse_stream_start(yaml_parser_t *parser); 
    100  
    101 static yaml_event_t * 
    102 yaml_parser_parse_document_start(yaml_parser_t *parser, int implicit); 
    103  
    104 static yaml_event_t * 
    105 yaml_parser_parse_document_content(yaml_parser_t *parser); 
    106  
    107 static yaml_event_t * 
    108 yaml_parser_parse_document_end(yaml_parser_t *parser); 
    109  
    110 static yaml_event_t * 
    111 yaml_parser_parse_node(yaml_parser_t *parser, 
    112         int block, int indentless_sequence); 
    113  
    114 static yaml_event_t * 
    115 yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser, int first); 
    116  
    117 static yaml_event_t * 
    118 yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser); 
    119  
    120 static yaml_event_t * 
    121 yaml_parser_parse_block_mapping_key(yaml_parser_t *parser, int first); 
    122  
    123 static yaml_event_t * 
    124 yaml_parser_parse_block_mapping_value(yaml_parser_t *parser); 
    125  
    126 static yaml_event_t * 
    127 yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser, int first); 
    128  
    129 static yaml_event_t * 
    130 yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser); 
    131  
    132 static yaml_event_t * 
    133 yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser); 
    134  
    135 static yaml_event_t * 
    136 yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser); 
    137  
    138 static yaml_event_t * 
    139 yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser, int first); 
    140  
    141 static yaml_event_t * 
    142 yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, int empty); 
    143  
    144 /* 
    145  * Utility functions. 
    146  */ 
    147  
    148 static yaml_event_t * 
    149 yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_mark_t mark); 
    150  
    151 static int 
    152 yaml_parser_process_directives(yaml_parser_t *parser); 
    153  
    154 /* 
    155  * Get the next event and advance the parser. 
    156  */ 
    157  
    158 YAML_DECLARE(yaml_event_t *) 
    159 yaml_parser_get_event(yaml_parser_t *parser) 
    160 { 
    161     yaml_event_t *value; 
    162  
    163     /* Update the current event if needed. */ 
    164      
    165     if (!parser->current_event) { 
    166         parser->current_event = yaml_parser_state_machine(parser); 
    167     } 
    168  
    169     /* Return and clear the current event. */ 
    170  
    171     value = parser->current_event; 
    172     parser->current_event = NULL; 
    173     return value; 
    174 } 
    175  
    176 /* 
    177  * Peek the next event. 
    178  */ 
    179  
    180 YAML_DECLARE(yaml_event_t *) 
    181 yaml_parser_peek_event(yaml_parser_t *parser) 
    182 { 
    183     yaml_event_t *value; 
    184  
    185     /* Update the current event if needed. */ 
    186      
    187     if (!parser->current_event) { 
    188         parser->current_event = yaml_parser_state_machine(parser); 
    189     } 
    190  
    191     /* Return the current event. */ 
    192  
    193     return parser->current_event; 
     229        yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark); 
     230 
     231/* 
     232 * Get the next event. 
     233 */ 
     234 
     235YAML_DECLARE(int) 
     236yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event) 
     237{ 
     238    assert(parser);     /* Non-NULL parser object is expected. */ 
     239    assert(event);      /* Non-NULL event object is expected. */ 
     240 
     241    /* No events after the end of the stream or error. */ 
     242 
     243    if (parser->stream_end_produced || parser->error || 
     244            parser->state == YAML_PARSE_END_STATE) { 
     245        memset(event, 0, sizeof(yaml_event_t)); 
     246 
     247        return 1; 
     248    } 
     249 
     250    /* Generate the next event. */ 
     251 
     252    return yaml_parser_state_machine(parser, event); 
    194253} 
    195254 
     
    223282} 
    224283 
    225 /* 
    226  * Double a list. 
    227  */ 
    228  
    229 static int 
    230 yaml_parser_resize_list(yaml_parser_t *parser, void **buffer, size_t *size, 
    231         size_t item_size) 
    232 { 
    233     void *new_buffer = yaml_realloc(*buffer, item_size*(*size)*2); 
    234  
    235     if (!new_buffer) { 
    236         parser->error = YAML_MEMORY_ERROR; 
    237         return 0; 
    238     } 
    239  
    240     memset(new_buffer+item_size*(*size), 0, item_size*(*size)); 
    241  
    242     *buffer = new_buffer; 
    243     *size *= 2; 
    244  
    245     return 1; 
    246 } 
    247  
    248 /* 
    249  * Push a tag directive to the directive list. 
    250  */ 
    251  
    252 static int 
    253 yaml_parser_append_tag_directive(yaml_parser_t *parser, 
    254         yaml_tag_directive_t *tag_directive) 
    255 { 
    256     if (parser->tag_directives_length == parser->tag_directives_size-1) { 
    257         if (!yaml_parser_resize_list(parser, (void **)&parser->tag_directives, 
    258                     &parser->tag_directives_size, sizeof(yaml_tag_directive_t))) 
    259             return 0; 
    260     } 
    261  
    262     parser->tag_directives[parser->tag_directives_length++] = tag_directive; 
    263     parser->tag_directives[parser->tag_directives_length] = NULL; 
    264     return 1; 
    265 } 
    266  
    267 /* 
    268  * Push a state to the state stack. 
    269  */ 
    270  
    271 static int 
    272 yaml_parser_append_state(yaml_parser_t *parser, yaml_parser_state_t state) 
    273 { 
    274     if (parser->states_length == parser->states_size-1) { 
    275         if (!yaml_parser_resize_list(parser, (void **)&parser->states, 
    276                     &parser->states_size, sizeof(yaml_parser_state_t))) 
    277             return 0; 
    278     } 
    279  
    280     parser->states[parser->states_length++] = state; 
    281     return 1; 
    282 } 
    283  
    284 /* 
    285  * Push a mark to the mark stack. 
    286  */ 
    287  
    288 static int 
    289 yaml_parser_append_mark(yaml_parser_t *parser, yaml_mark_t mark) 
    290 { 
    291     if (parser->marks_length == parser->marks_size-1) { 
    292         if (!yaml_parser_resize_list(parser, (void **)&parser->marks, 
    293                     &parser->marks_size, sizeof(yaml_mark_t))) 
    294             return 0; 
    295     } 
    296  
    297     parser->marks[parser->marks_length++] = mark; 
    298     return 1; 
    299 } 
    300284 
    301285/* 
     
    303287 */ 
    304288 
    305 static yaml_event_t * 
    306 yaml_parser_state_machine(yaml_parser_t *parser) 
    307 { 
    308     assert (parser->state != YAML_PARSE_END_STATE); 
    309  
     289static int 
     290yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event) 
     291{ 
    310292    switch (parser->state) 
    311293    { 
    312294        case YAML_PARSE_STREAM_START_STATE: 
    313             return yaml_parser_parse_stream_start(parser); 
     295            return yaml_parser_parse_stream_start(parser, event); 
    314296 
    315297        case YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE: 
    316             return yaml_parser_parse_document_start(parser, 1); 
     298            return yaml_parser_parse_document_start(parser, event, 1); 
    317299 
    318300        case YAML_PARSE_DOCUMENT_START_STATE: 
    319             return yaml_parser_parse_document_start(parser, 0); 
     301            return yaml_parser_parse_document_start(parser, event, 0); 
    320302 
    321303        case YAML_PARSE_DOCUMENT_CONTENT_STATE: 
    322             return yaml_parser_parse_document_content(parser); 
     304            return yaml_parser_parse_document_content(parser, event); 
    323305 
    324306        case YAML_PARSE_DOCUMENT_END_STATE: 
    325             return yaml_parser_parse_document_end(parser); 
     307            return yaml_parser_parse_document_end(parser, event); 
    326308 
    327309        case YAML_PARSE_BLOCK_NODE_STATE: 
    328             return yaml_parser_parse_node(parser, 1, 0); 
     310            return yaml_parser_parse_node(parser, event, 1, 0); 
    329311 
    330312        case YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: 
    331             return yaml_parser_parse_node(parser, 1, 1); 
     313            return yaml_parser_parse_node(parser, event, 1, 1); 
    332314 
    333315        case YAML_PARSE_FLOW_NODE_STATE: 
    334             return yaml_parser_parse_node(parser, 0, 0); 
     316            return yaml_parser_parse_node(parser, event, 0, 0); 
    335317 
    336318        case YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: 
    337             return yaml_parser_parse_block_sequence_entry(parser, 1); 
     319            return yaml_parser_parse_block_sequence_entry(parser, event, 1); 
    338320 
    339321        case YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: 
    340             return yaml_parser_parse_block_sequence_entry(parser, 0); 
     322            return yaml_parser_parse_block_sequence_entry(parser, event, 0); 
    341323 
    342324        case YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: 
    343             return yaml_parser_parse_indentless_sequence_entry(parser); 
     325            return yaml_parser_parse_indentless_sequence_entry(parser, event); 
    344326 
    345327        case YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: 
    346             return yaml_parser_parse_block_mapping_key(parser, 1); 
     328            return yaml_parser_parse_block_mapping_key(parser, event, 1); 
    347329 
    348330        case YAML_PARSE_BLOCK_MAPPING_KEY_STATE: 
    349             return yaml_parser_parse_block_mapping_key(parser, 0); 
     331            return yaml_parser_parse_block_mapping_key(parser, event, 0); 
    350332 
    351333        case YAML_PARSE_BLOCK_MAPPING_VALUE_STATE: 
    352             return yaml_parser_parse_block_mapping_value(parser); 
     334            return yaml_parser_parse_block_mapping_value(parser, event); 
    353335 
    354336        case YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: 
    355             return yaml_parser_parse_flow_sequence_entry(parser, 1); 
     337            return yaml_parser_parse_flow_sequence_entry(parser, event, 1); 
    356338 
    357339        case YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE: 
    358             return yaml_parser_parse_flow_sequence_entry(parser, 0); 
     340            return yaml_parser_parse_flow_sequence_entry(parser, event, 0); 
    359341 
    360342        case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: 
    361             return yaml_parser_parse_flow_sequence_entry_mapping_key(parser); 
     343            return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event); 
    362344 
    363345        case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: 
    364             return yaml_parser_parse_flow_sequence_entry_mapping_value(parser); 
     346            return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event); 
    365347 
    366348        case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: 
    367             return yaml_parser_parse_flow_sequence_entry_mapping_end(parser); 
     349            return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event); 
    368350 
    369351        case YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: 
    370             return yaml_parser_parse_flow_mapping_key(parser, 1); 
     352            return yaml_parser_parse_flow_mapping_key(parser, event, 1); 
    371353 
    372354        case YAML_PARSE_FLOW_MAPPING_KEY_STATE: 
    373             return yaml_parser_parse_flow_mapping_key(parser, 0); 
     355            return yaml_parser_parse_flow_mapping_key(parser, event, 0); 
    374356 
    375357        case YAML_PARSE_FLOW_MAPPING_VALUE_STATE: 
    376             return yaml_parser_parse_flow_mapping_value(parser, 0); 
     358            return yaml_parser_parse_flow_mapping_value(parser, event, 0); 
    377359 
    378360        case YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: 
    379             return yaml_parser_parse_flow_mapping_value(parser, 1); 
    380     } 
    381     assert(1); 
     361            return yaml_parser_parse_flow_mapping_value(parser, event, 1); 
     362 
     363        default: 
     364            assert(1);      /* Invalid state. */ 
     365    } 
    382366} 
    383367 
     
    388372 */ 
    389373 
    390 static yaml_event_t * 
    391 yaml_parser_parse_stream_start(yaml_parser_t *parser) 
    392 { 
    393     yaml_token_t *token; 
    394     yaml_event_t *event; 
    395  
    396     token = yaml_parser_get_token(parser); 
    397     if (!token) return NULL; 
    398  
    399     assert(token->type == YAML_STREAM_START_TOKEN); 
    400  
    401     event = yaml_stream_start_event_new(token->data.stream_start.encoding, 
     374static int 
     375yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event) 
     376{ 
     377    yaml_token_t *token; 
     378 
     379    token = PEEK_TOKEN(parser); 
     380    if (!token) return 0; 
     381 
     382    if (token->type != YAML_STREAM_START_TOKEN) { 
     383        return yaml_parser_set_parser_error(parser, 
     384                "did not found expected <stream-start>", token->start_mark); 
     385    } 
     386 
     387    parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE; 
     388    STREAM_START_EVENT_INIT(*event, token->data.stream_start.encoding, 
    402389            token->start_mark, token->start_mark); 
    403     yaml_token_delete(token); 
    404     if (!event) { 
    405         parser->error = YAML_MEMORY_ERROR; 
    406         return NULL; 
    407     } 
    408  
    409     parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE; 
    410  
    411     return event; 
     390    SKIP_TOKEN(parser); 
     391 
     392    return 1; 
    412393} 
    413394 
     
    420401 */ 
    421402 
    422 static yaml_event_t * 
    423 yaml_parser_parse_document_start(yaml_parser_t *parser, int implicit) 
    424 { 
    425     yaml_token_t *token; 
    426     yaml_event_t *event; 
    427  
    428     token = yaml_parser_peek_token(parser); 
    429     if (!token) return NULL; 
     403static int 
     404yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event, 
     405        int implicit) 
     406{ 
     407    yaml_token_t *token; 
     408    yaml_version_directive_t *version_directive = NULL; 
     409    struct { 
     410        yaml_tag_directive_t *start; 
     411        yaml_tag_directive_t *end; 
     412    } tag_directives = { NULL, NULL }; 
     413 
     414    token = PEEK_TOKEN(parser); 
     415    if (!token) return 0; 
    430416 
    431417    /* Parse an implicit document. */ 
     
    436422            token->type != YAML_STREAM_END_TOKEN) 
    437423    { 
    438         if (!yaml_parser_process_directives(parser)) return NULL; 
    439         if (!yaml_parser_append_state(parser, YAML_PARSE_DOCUMENT_END_STATE)) 
    440             return NULL; 
     424        if (!yaml_parser_process_directives(parser, NULL, NULL, NULL)) 
     425            return 0; 
     426        if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE)) 
     427            return 0; 
    441428        parser->state = YAML_PARSE_BLOCK_NODE_STATE; 
    442         event = yaml_document_start_event_new( 
    443                 parser->version_directive, parser->tag_directives, 1, 
     429        DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1, 
    444430                token->start_mark, token->start_mark); 
    445         if (!event) { 
    446             parser->error = YAML_MEMORY_ERROR; 
    447             return NULL; 
    448         } 
    449         return event; 
     431        return 1; 
    450432    } 
    451433 
     
    456438        yaml_mark_t start_mark, end_mark; 
    457439        start_mark = token->start_mark; 
    458         if (!yaml_parser_process_directives(parser)) return NULL; 
    459         token = yaml_parser_peek_token(parser); 
    460         if (!token) return NULL; 
     440        if (!yaml_parser_process_directives(parser, &version_directive, 
     441                    &tag_directives.start, &tag_directives.end)) 
     442            return 0; 
     443        token = PEEK_TOKEN(parser); 
     444        if (!token) goto error; 
    461445        if (token->type != YAML_DOCUMENT_START_TOKEN) { 
    462446            yaml_parser_set_parser_error(parser, 
    463447                    "did not found expected <document start>", token->start_mark); 
    464             return NULL; 
    465         } 
    466         token = yaml_parser_get_token(parser); 
     448            goto error; 
     449        } 
     450        if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE)) 
     451            goto error; 
     452        parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE; 
    467453        end_mark = token->end_mark; 
    468         yaml_token_delete(token); 
    469         if (!yaml_parser_append_state(parser, YAML_PARSE_DOCUMENT_END_STATE)) 
    470             return NULL; 
    471         parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE; 
    472         event = yaml_document_start_event_new( 
    473                 parser->version_directive, parser->tag_directives, 0, 
     454        DOCUMENT_START_EVENT_INIT(*event, version_directive, 
     455                tag_directives.start, tag_directives.end, 0, 
    474456                start_mark, end_mark); 
    475         if (!event) { 
    476             parser->error = YAML_MEMORY_ERROR; 
    477             return NULL; 
    478         } 
    479         return event; 
     457        SKIP_TOKEN(parser); 
     458        version_directive = NULL; 
     459        tag_directives.start = tag_directives.end = NULL; 
     460        return 1; 
    480461    } 
    481462 
     
    484465    else 
    485466    { 
    486         token = yaml_parser_get_token(parser); 
    487467        parser->state = YAML_PARSE_END_STATE; 
    488         event = yaml_stream_end_event_new(token->start_mark, token->end_mark); 
    489         yaml_token_delete(token); 
    490         if (!event) { 
    491             parser->error = YAML_MEMORY_ERROR; 
    492             return NULL; 
    493         } 
    494         return event; 
    495     } 
     468        STREAM_END_EVENT_INIT(*event, token->start_mark, token->end_mark); 
     469        SKIP_TOKEN(parser); 
     470        return 1; 
     471    } 
     472 
     473error: 
     474    yaml_free(version_directive); 
     475    while (tag_directives.start != tag_directives.end) { 
     476        yaml_free(tag_directives.end[-1].handle); 
     477        yaml_free(tag_directives.end[-1].prefix); 
     478        tag_directives.end --; 
     479    } 
     480    yaml_free(tag_directives.start); 
     481    return 0; 
    496482} 
    497483 
     
    502488 */ 
    503489 
    504 static yaml_event_t * 
    505 yaml_parser_parse_document_content(yaml_parser_t *parser) 
    506 { 
    507     yaml_token_t *token; 
    508  
    509     token = yaml_parser_peek_token(parser); 
    510     if (!token) return NULL; 
     490static int 
     491yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event) 
     492{ 
     493    yaml_token_t *token; 
     494 
     495    token = PEEK_TOKEN(parser); 
     496    if (!token) return 0; 
    511497 
    512498    if (token->type == YAML_VERSION_DIRECTIVE_TOKEN || 
     
    515501            token->type == YAML_DOCUMENT_END_TOKEN || 
    516502            token->type == YAML_STREAM_END_TOKEN) { 
    517         parser->state = parser->states[--parser->states_length]; 
    518         return yaml_parser_process_empty_scalar(parser, token->start_mark); 
     503        parser->state = POP(parser, parser->states); 
     504        return yaml_parser_process_empty_scalar(parser, event, 
     505                token->start_mark); 
    519506    } 
    520507    else { 
    521         return yaml_parser_parse_node(parser, 1, 0); 
     508        return yaml_parser_parse_node(parser, event, 1, 0); 
    522509    } 
    523510} 
     
    531518 */ 
    532519 
    533 static yaml_event_t * 
    534 yaml_parser_parse_document_end(yaml_parser_t *parser) 
    535 { 
    536     yaml_token_t *token; 
    537     yaml_event_t *event; 
     520static int 
     521yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event) 
     522{ 
     523    yaml_token_t *token; 
    538524    yaml_mark_t start_mark, end_mark; 
    539525    int implicit = 1; 
    540526 
    541     token = yaml_parser_peek_token(parser); 
    542     if (!token) return NULL; 
     527    token = PEEK_TOKEN(parser); 
     528    if (!token) return 0; 
    543529 
    544530    start_mark = end_mark = token->start_mark; 
     
    546532    while (token->type == YAML_DOCUMENT_END_TOKEN) { 
    547533        end_mark = token->end_mark; 
    548         yaml_token_delete(yaml_parser_get_token(parser)); 
    549         token = yaml_parser_peek_token(parser); 
    550         if (!token) return NULL; 
     534        SKIP_TOKEN(parser); 
     535        token = PEEK_TOKEN(parser); 
     536        if (!token) return 0; 
    551537        implicit = 0; 
    552538    } 
    553539 
    554     parser->version_directive = NULL; 
    555     parser->tag_directives = NULL; 
    556     parser->tag_directives = yaml_malloc(YAML_DEFAULT_SIZE*sizeof(yaml_tag_directive_t *)); 
    557     if (!parser->tag_directives) { 
    558         parser->error = YAML_MEMORY_ERROR; 
    559         return NULL; 
    560     } 
    561     memset(parser->tag_directives, 0, YAML_DEFAULT_SIZE*sizeof(yaml_tag_directive_t *)); 
    562     parser->tag_directives_size = YAML_DEFAULT_SIZE; 
    563     parser->tag_directives_length = 0; 
    564  
    565  
    566  
    567     event = yaml_document_end_event_new(implicit, start_mark, end_mark); 
    568     if (!event) { 
    569         parser->error = YAML_MEMORY_ERROR; 
    570         return NULL; 
    571     } 
     540    while (!STACK_EMPTY(parser, parser->tag_directives)) { 
     541        yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives); 
     542        yaml_free(tag_directive.handle); 
     543        yaml_free(tag_directive.prefix); 
     544    } 
     545 
    572546    parser->state = YAML_PARSE_DOCUMENT_START_STATE; 
    573  
    574     return event; 
     547    DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark); 
     548 
     549    return 1; 
    575550} 
    576551 
     
    604579 */ 
    605580 
    606 static yaml_event_t * 
    607 yaml_parser_parse_node(yaml_parser_t *parser, 
     581static int 
     582yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event, 
    608583        int block, int indentless_sequence) 
    609584{ 
    610585    yaml_token_t *token; 
    611     yaml_event_t *event; 
    612586    yaml_char_t *anchor = NULL; 
    613587    yaml_char_t *tag_handle = NULL; 
     
    617591    int implicit; 
    618592 
    619     token = yaml_parser_peek_token(parser); 
    620     if (!token) return NULL; 
     593    token = PEEK_TOKEN(parser); 
     594    if (!token) return 0; 
    621595 
    622596    if (token->type == YAML_ALIAS_TOKEN) 
    623597    { 
    624         parser->state = parser->states[--parser->states_length]; 
    625         token = yaml_parser_get_token(parser); 
    626         event = yaml_alias_event_new(token->data.alias.value, 
     598        parser->state = POP(parser, parser->states); 
     599        ALIAS_EVENT_INIT(*event, token->data.alias.value, 
    627600                token->start_mark, token->end_mark); 
    628         if (!event) { 
    629             yaml_token_delete(token); 
    630             parser->error = YAML_MEMORY_ERROR; 
    631             return NULL; 
    632         } 
    633         yaml_free(token); 
    634         return event; 
     601        SKIP_TOKEN(parser); 
     602        return 1; 
    635603    } 
    636604 
     
    641609        if (token->type == YAML_ANCHOR_TOKEN) 
    642610        { 
    643             token = yaml_parser_get_token(parser); 
    644611            anchor = token->data.anchor.value; 
    645612            start_mark = token->start_mark; 
    646613            end_mark = token->end_mark; 
    647             yaml_free(token); 
    648             token = yaml_parser_peek_token(parser); 
     614            SKIP_TOKEN(parser); 
     615            token = PEEK_TOKEN(parser); 
    649616            if (!token) goto error; 
    650617            if (token->type == YAML_TAG_TOKEN) 
    651618            { 
    652                 token = yaml_parser_get_token(parser); 
    653619                tag_handle = token->data.tag.handle; 
    654620                tag_suffix = token->data.tag.suffix; 
    655621                tag_mark = token->start_mark; 
    656622                end_mark = token->end_mark; 
    657                 yaml_free(token); 
    658                 token = yaml_parser_peek_token(parser); 
     623                SKIP_TOKEN(parser); 
     624                token = PEEK_TOKEN(parser); 
    659625                if (!token) goto error; 
    660626            } 
     
    662628        else if (token->type == YAML_TAG_TOKEN) 
    663629        { 
    664             token = yaml_parser_get_token(parser); 
    665630            tag_handle = token->data.tag.handle; 
    666631            tag_suffix = token->data.tag.suffix; 
    667632            start_mark = tag_mark = token->start_mark; 
    668633            end_mark = token->end_mark; 
    669             yaml_free(token); 
    670             token = yaml_parser_peek_token(parser); 
     634            SKIP_TOKEN(parser); 
     635            token = PEEK_TOKEN(parser); 
    671636            if (!token) goto error; 
    672637            if (token->type == YAML_ANCHOR_TOKEN) 
    673638            { 
    674                 token = yaml_parser_get_token(parser); 
    675639                anchor = token->data.anchor.value; 
    676640                end_mark = token->end_mark; 
    677                 yaml_free(token); 
    678                 token = yaml_parser_peek_token(parser); 
     641                SKIP_TOKEN(parser); 
     642                token = PEEK_TOKEN(parser); 
    679643                if (!token) goto error; 
    680644            } 
     
    688652            } 
    689653            else { 
    690                 yaml_tag_directive_t **tag_directive = parser->tag_directives; 
    691                 for (tag_directive = parser->tag_directives; 
    692                         *tag_directive; tag_directive++) { 
    693                     if (strcmp((char *)(*tag_directive)->handle, (char *)tag_handle) == 0) { 
    694                         size_t prefix_len = strlen((char *)(*tag_directive)->prefix); 
     654                yaml_tag_directive_t *tag_directive; 
     655                for (tag_directive = parser->tag_directives.start; 
     656                        tag_directive != parser->tag_directives.top; 
     657                        tag_directive ++) { 
     658                    if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) { 
     659                        size_t prefix_len = strlen((char *)tag_directive->prefix); 
    695660                        size_t suffix_len = strlen((char *)tag_suffix); 
    696661                        tag = yaml_malloc(prefix_len+suffix_len+1); 
     
    699664                            goto error; 
    700665                        } 
    701                         memcpy(tag, (*tag_directive)->prefix, prefix_len); 
     666                        memcpy(tag, tag_directive->prefix, prefix_len); 
    702667                        memcpy(tag+prefix_len, tag_suffix, suffix_len); 
    703668                        tag[prefix_len+suffix_len] = '\0'; 
     
    708673                    } 
    709674                } 
    710                 if (!*tag_directive) { 
     675                if (!tag) { 
    711676                    yaml_parser_set_parser_error_context(parser, 
    712677                            "while parsing a node", start_mark, 
     
    721686            end_mark = token->end_mark; 
    722687            parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE; 
    723             event = yaml_sequence_start_event_new(anchor, tag, implicit, 
     688            SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, 
    724689                    YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark); 
    725             if (!event) goto error; 
    726             return event; 
     690            return 1; 
    727691        } 
    728692        else { 
     
    730694                int plain_implicit = 0; 
    731695                int quoted_implicit = 0; 
    732                 token = yaml_parser_get_token(parser); 
    733696                end_mark = token->end_mark; 
    734697                if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag) 
     
    739702                    quoted_implicit = 1; 
    740703                } 
    741                 parser->state = parser->states[--parser->states_length]; 
    742                 event = yaml_scalar_event_new(anchor, tag, 
     704                parser->state = POP(parser, parser->states); 
     705                SCALAR_EVENT_INIT(*event, anchor, tag, 
    743706                        token->data.scalar.value, token->data.scalar.length, 
    744707                        plain_implicit, quoted_implicit, 
    745708                        token->data.scalar.style, start_mark, end_mark); 
    746                 if (!event) { 
    747                     parser->error = YAML_MEMORY_ERROR; 
    748                     yaml_token_delete(token); 
    749                     goto error; 
    750                 } 
    751                 yaml_free(token); 
     709                SKIP_TOKEN(parser); 
     710                return 1; 
    752711            } 
    753712            else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) { 
    754713                end_mark = token->end_mark; 
    755714                parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE; 
    756                 event = yaml_sequence_start_event_new(anchor, tag, implicit, 
     715                SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, 
    757716                        YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark); 
    758                 if (!event) { 
    759                     parser->error = YAML_MEMORY_ERROR; 
    760                     goto error; 
    761                 } 
     717                return 1; 
    762718            } 
    763719            else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) { 
    764720                end_mark = token->end_mark; 
    765721                parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE; 
    766                 event = yaml_mapping_start_event_new(anchor, tag, implicit, 
     722                MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit, 
    767723                        YAML_FLOW_MAPPING_STYLE, start_mark, end_mark); 
    768                 if (!event) { 
    769                     parser->error = YAML_MEMORY_ERROR; 
    770                     goto error; 
    771                 } 
     724                return 1; 
    772725            } 
    773726            else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) { 
    774727                end_mark = token->end_mark; 
    775728                parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE; 
    776                 event = yaml_sequence_start_event_new(anchor, tag, implicit, 
     729                SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit, 
    777730                        YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark); 
    778                 if (!event) { 
    779                     parser->error = YAML_MEMORY_ERROR; 
    780                     goto error; 
    781                 } 
     731                return 1; 
    782732            } 
    783733            else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) { 
    784734                end_mark = token->end_mark; 
    785735                parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE; 
    786                 event = yaml_mapping_start_event_new(anchor, tag, implicit, 
     736                MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit, 
    787737                        YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark); 
    788                 if (!event) { 
    789                     parser->error = YAML_MEMORY_ERROR; 
    790                     goto error; 
    791                 } 
     738                return 1; 
    792739            } 
    793740            else if (anchor || tag) { 
     
    798745                } 
    799746                value[0] = '\0'; 
    800                 parser->state = parser->states[--parser->states_length]; 
    801                 event = yaml_scalar_event_new(anchor, tag, value, 0, 
     747                parser->state = POP(parser, parser->states); 
     748                SCALAR_EVENT_INIT(*event, anchor, tag, value, 0, 
    802749                        implicit, 0, YAML_PLAIN_SCALAR_STYLE, 
    803750                        start_mark, end_mark); 
    804                 if (!event) { 
    805                     yaml_free(value); 
    806                     parser->error = YAML_MEMORY_ERROR; 
    807                     goto error; 
    808                 } 
     751                return 1; 
    809752            } 
    810753            else { 
     
    815758                goto error; 
    816759            } 
    817             return event; 
    818760        } 
    819761    } 
     
    825767    yaml_free(tag); 
    826768 
    827     return NULL; 
     769    return 0; 
    828770} 
    829771 
     
    834776 */ 
    835777 
    836 static yaml_event_t * 
    837 yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser, int first) 
    838 { 
    839     yaml_token_t *token; 
    840     yaml_event_t *event; 
     778static int 
     779yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser, 
     780        yaml_event_t *event, int first) 
     781{ 
     782    yaml_token_t *token; 
    841783 
    842784    if (first) { 
    843         token = yaml_parser_get_token(parser); 
    844         if (!yaml_parser_append_mark(parser, token->start_mark)) { 
    845             yaml_token_delete(token); 
    846             return NULL; 
    847         } 
    848         yaml_token_delete(token); 
    849     } 
    850  
    851     token = yaml_parser_get_token(parser); 
    852     if (!token) return NULL; 
     785        token = PEEK_TOKEN(parser); 
     786        if (!PUSH(parser, parser->marks, token->start_mark)) 
     787            return 0; 
     788        SKIP_TOKEN(parser); 
     789    } 
     790 
     791    token = PEEK_TOKEN(parser); 
     792    if (!token) return 0; 
    853793 
    854794    if (token->type == YAML_BLOCK_ENTRY_TOKEN) 
    855795    { 
    856796        yaml_mark_t mark = token->end_mark; 
    857         yaml_token_delete(token); 
    858         token = yaml_parser_peek_token(parser); 
    859         if (!token) return NULL; 
     797        SKIP_TOKEN(parser); 
     798        token = PEEK_TOKEN(parser); 
     799        if (!token) return 0; 
    860800        if (token->type != YAML_BLOCK_ENTRY_TOKEN && 
    861801                token->type != YAML_BLOCK_END_TOKEN) { 
    862             if (!yaml_parser_append_state(parser, 
     802            if (!PUSH(parser, parser->states, 
    863803                        YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE)) 
    864                 return NULL; 
    865             return yaml_parser_parse_node(parser, 1, 0); 
     804                return 0; 
     805            return yaml_parser_parse_node(parser, event, 1, 0); 
    866806        } 
    867807        else { 
    868808            parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE; 
    869             return yaml_parser_process_empty_scalar(parser, mark); 
     809            return yaml_parser_process_empty_scalar(parser, event, mark); 
    870810        } 
    871811    } 
     
    873813    else if (token->type == YAML_BLOCK_END_TOKEN) 
    874814    { 
    875         parser->state = parser->states[--parser->states_length]; 
    876         parser->marks_length --; 
    877         event = yaml_sequence_end_event_new(token->start_mark, token->end_mark); 
    878         yaml_token_delete(token); 
    879         if (!event) { 
    880             parser->error = YAML_MEMORY_ERROR; 
    881             return NULL; 
    882         } 
    883         return event; 
     815        parser->state = POP(parser, parser->states); 
     816        POP(parser, parser->marks); 
     817        SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark); 
     818        SKIP_TOKEN(parser); 
     819        return 1; 
    884820    } 
    885821 
    886822    else 
    887823    { 
    888         yaml_parser_set_parser_error_context(parser, 
    889                 "while parsing a block collection", parser->marks[parser->marks_length-1], 
     824        return yaml_parser_set_parser_error_context(parser, 
     825                "while parsing a block collection", POP(parser, parser->marks), 
    890826                "did not found expected '-' indicator", token->start_mark); 
    891         yaml_token_delete(token); 
    892         return NULL; 
    893827    } 
    894828} 
     
    900834 */ 
    901835 
    902 static yaml_event_t * 
    903 yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser) 
    904 { 
    905     yaml_token_t *token; 
    906     yaml_event_t *event; 
    907  
    908     token = yaml_parser_peek_token(parser); 
    909     if (!token) return NULL; 
     836static int 
     837yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser, 
     838        yaml_event_t *event) 
     839{ 
     840    yaml_token_t *token; 
     841 
     842    token = PEEK_TOKEN(parser); 
     843    if (!token) return 0; 
    910844 
    911845    if (token->type == YAML_BLOCK_ENTRY_TOKEN) 
    912846    { 
    913847        yaml_mark_t mark = token->end_mark; 
    914         yaml_token_delete(yaml_parser_get_token(parser)); 
    915         token = yaml_parser_peek_token(parser); 
     848        SKIP_TOKEN(parser); 
     849        token = PEEK_TOKEN(parser); 
     850        if (!token) return 0; 
    916851        if (token->type != YAML_BLOCK_ENTRY_TOKEN && 
     852                token->type != YAML_KEY_TOKEN && 
     853                token->type != YAML_VALUE_TOKEN && 
    917854                token->type != YAML_BLOCK_END_TOKEN) { 
    918             if (!yaml_parser_append_state(parser, 
     855            if (!PUSH(parser, parser->states, 
    919856                        YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE)) 
    920                 return NULL; 
    921             return yaml_parser_parse_node(parser, 1, 0); 
     857                return 0; 
     858            return yaml_parser_parse_node(parser, event, 1, 0); 
    922859        } 
    923860        else { 
    924861            parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE; 
    925             return yaml_parser_process_empty_scalar(parser, mark); 
     862            return yaml_parser_process_empty_scalar(parser, event, mark); 
    926863        } 
    927864    } 
     
    929866    else 
    930867    { 
    931         parser->state = parser->states[--parser->states_length]; 
    932         event = yaml_sequence_end_event_new(token->start_mark, token->start_mark); 
    933         if (!event) { 
    934             parser->error = YAML_MEMORY_ERROR; 
    935             return NULL; 
    936         } 
    937         return event; 
     868        parser->state = POP(parser, parser->states); 
     869        SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->start_mark); 
     870        return 1; 
    938871    } 
    939872} 
     
    951884 */ 
    952885 
    953 static yaml_event_t * 
    954 yaml_parser_parse_block_mapping_key(yaml_parser_t *parser, int first) 
    955 { 
    956     yaml_token_t *token; 
    957     yaml_event_t *event; 
     886static int 
     887yaml_parser_parse_block_mapping_key(yaml_parser_t *parser, 
     888        yaml_event_t *event, int first) 
     889{ 
     890    yaml_token_t *token; 
    958891 
    959892    if (first) { 
    960         token = yaml_parser_get_token(parser); 
    961         if (!yaml_parser_append_mark(parser, token->start_mark)) { 
    962             yaml_token_delete(token); 
    963             return NULL; 
    964         } 
    965         yaml_token_delete(token); 
    966     } 
    967  
    968     token = yaml_parser_get_token(parser); 
    969     if (!token) return NULL; 
     893        token = PEEK_TOKEN(parser); 
     894        if (!PUSH(parser, parser->marks, token->start_mark)) 
     895            return 0; 
     896        SKIP_TOKEN(parser); 
     897    } 
     898 
     899    token = PEEK_TOKEN(parser); 
     900    if (!token) return 0; 
    970901 
    971902    if (token->type == YAML_KEY_TOKEN) 
    972903    { 
    973904        yaml_mark_t mark = token->end_mark; 
    974         yaml_token_delete(token); 
    975         token = yaml_parser_peek_token(parser); 
    976         if (!token) return NULL; 
     905        SKIP_TOKEN(parser); 
     906        token = PEEK_TOKEN(parser); 
     907        if (!token) return 0; 
    977908        if (token->type != YAML_KEY_TOKEN && 
    978909                token->type != YAML_VALUE_TOKEN && 
    979910                token->type != YAML_BLOCK_END_TOKEN) { 
    980             if (!yaml_parser_append_state(parser, 
     911            if (!PUSH(parser, parser->states, 
    981912                        YAML_PARSE_BLOCK_MAPPING_VALUE_STATE)) 
    982                 return NULL; 
    983             return yaml_parser_parse_node(parser, 1, 1); 
     913                return 0; 
     914            return yaml_parser_parse_node(parser, event, 1, 1); 
    984915        } 
    985916        else { 
    986917            parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE; 
    987             return yaml_parser_process_empty_scalar(parser, mark); 
     918            return yaml_parser_process_empty_scalar(parser, event, mark); 
    988919        } 
    989920    } 
     
    991922    else if (token->type == YAML_BLOCK_END_TOKEN) 
    992923    { 
    993         parser->state = parser->states[--parser->states_length]; 
    994         parser->marks_length --; 
    995         event = yaml_mapping_end_event_new(token->start_mark, token->end_mark); 
    996         yaml_token_delete(token); 
    997         if (!event) { 
    998             parser->error = YAML_MEMORY_ERROR; 
    999             return NULL; 
    1000         } 
    1001         return event; 
     924        parser->state = POP(parser, parser->states); 
     925        POP(parser, parser->marks); 
     926        MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark); 
     927        SKIP_TOKEN(parser); 
     928        return 1; 
    1002929    } 
    1003930 
    1004931    else 
    1005932    { 
    1006         yaml_parser_set_parser_error_context(parser, 
    1007                 "while parsing a block mapping", parser->marks[parser->marks_length-1], 
     933        return yaml_parser_set_parser_error_context(parser, 
     934                "while parsing a block mapping", POP(parser, parser->marks), 
    1008935                "did not found expected key", token->start_mark); 
    1009         yaml_token_delete(token); 
    1010         return NULL; 
    1011936    } 
    1012937} 
     
    1024949 */ 
    1025950 
    1026 static yaml_event_t * 
    1027 yaml_parser_parse_block_mapping_value(yaml_parser_t *parser) 
    1028 { 
    1029     yaml_token_t *token; 
    1030     yaml_event_t *event; 
    1031  
    1032     token = yaml_parser_peek_token(parser); 
    1033     if (!token) return NULL; 
     951static int 
     952yaml_parser_parse_block_mapping_value(yaml_parser_t *parser, 
     953        yaml_event_t *event) 
     954{ 
     955    yaml_token_t *token; 
     956 
     957    token = PEEK_TOKEN(parser); 
     958    if (!token) return 0; 
    1034959 
    1035960    if (token->type == YAML_VALUE_TOKEN) 
    1036961    { 
    1037962        yaml_mark_t mark = token->end_mark; 
    1038         yaml_token_delete(yaml_parser_get_token(parser)); 
    1039         token = yaml_parser_peek_token(parser); 
    1040         if (!token) return NULL; 
     963        SKIP_TOKEN(parser); 
     964        token = PEEK_TOKEN(parser); 
     965        if (!token) return 0; 
    1041966        if (token->type != YAML_KEY_TOKEN && 
    1042967                token->type != YAML_VALUE_TOKEN && 
    1043968                token->type != YAML_BLOCK_END_TOKEN) { 
    1044             if (!yaml_parser_append_state(parser, 
     969            if (!PUSH(parser, parser->states, 
    1045970                        YAML_PARSE_BLOCK_MAPPING_KEY_STATE)) 
    1046                 return NULL; 
    1047             return yaml_parser_parse_node(parser, 1, 1); 
     971                return 0; 
     972            return yaml_parser_parse_node(parser, event, 1, 1); 
    1048973        } 
    1049974        else { 
    1050975            parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE; 
    1051             return yaml_parser_process_empty_scalar(parser, mark); 
     976            return yaml_parser_process_empty_scalar(parser, event, mark); 
    1052977        } 
    1053978    } 
     
    1056981    { 
    1057982        parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE; 
    1058         return yaml_parser_process_empty_scalar(parser, token->start_mark); 
     983        return yaml_parser_process_empty_scalar(parser, event, token->start_mark); 
    1059984    } 
    1060985} 
     
    1074999 */ 
    10751000 
    1076 static yaml_event_t * 
    1077 yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser, int first) 
    1078 { 
    1079     yaml_token_t *token; 
    1080     yaml_event_t *event; 
     1001static int 
     1002yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser, 
     1003        yaml_event_t *event, int first) 
     1004{ 
     1005    yaml_token_t *token; 
    10811006 
    10821007    if (first) { 
    1083         token = yaml_parser_get_token(parser); 
    1084         if (!yaml_parser_append_mark(parser, token->start_mark)) { 
    1085             yaml_token_delete(token); 
    1086             return NULL; 
    1087         } 
    1088         yaml_token_delete(token); 
    1089     } 
    1090  
    1091     token = yaml_parser_peek_token(parser); 
    1092     if (!token) return NULL; 
     1008        token = PEEK_TOKEN(parser); 
     1009        if (!PUSH(parser, parser->marks, token->start_mark)) 
     1010            return 0; 
     1011        SKIP_TOKEN(parser); 
     1012    } 
     1013 
     1014    token = PEEK_TOKEN(parser); 
     1015    if (!token) return 0; 
    10931016 
    10941017    if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) 
     
    10961019        if (!first) { 
    10971020            if (token->type == YAML_FLOW_ENTRY_TOKEN) { 
    1098                 yaml_token_delete(yaml_parser_get_token(parser)); 
    1099                 token = yaml_parser_peek_token(parser); 
    1100                 if (!token) return NULL; 
     1021                SKIP_TOKEN(parser); 
     1022                token = PEEK_TOKEN(parser); 
     1023                if (!token) return 0; 
    11011024            } 
    11021025            else { 
    1103                 yaml_parser_set_parser_error_context(parser, 
    1104                         "while parsing a flow sequence", parser->marks[parser->marks_length-1], 
     1026                return yaml_parser_set_parser_error_context(parser, 
     1027                        "while parsing a flow sequence", POP(parser, parser->marks), 
    11051028                        "did not found expected ',' or ']'", token->start_mark); 
    1106                 return NULL; 
    11071029            } 
    11081030        } 
    11091031 
    11101032        if (token->type == YAML_KEY_TOKEN) { 
    1111             token = yaml_parser_get_token(parser); 
    11121033            parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE; 
    1113             event = yaml_mapping_start_event_new(NULL, NULL, 
     1034            MAPPING_START_EVENT_INIT(*event, NULL, NULL, 
    11141035                    1, YAML_FLOW_MAPPING_STYLE, 
    11151036                    token->start_mark, token->end_mark); 
    1116             yaml_token_delete(token); 
    1117             return event; 
     1037            SKIP_TOKEN(parser); 
     1038            return 1; 
    11181039        } 
    11191040 
    11201041        else if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { 
    1121             if (!yaml_parser_append_state(parser, 
     1042            if (!PUSH(parser, parser->states, 
    11221043                        YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE)) 
    1123                 return NULL; 
    1124             return yaml_parser_parse_node(parser, 0, 0); 
    1125         } 
    1126     } 
    1127  
    1128     parser->state = parser->states[--parser->states_length]; 
    1129     parser->marks_length --; 
    1130     token = yaml_parser_get_token(parser); 
    1131     event = yaml_sequence_end_event_new(token->start_mark, token->end_mark); 
    1132     yaml_token_delete(token); 
    1133     return event; 
     1044                return 0; 
     1045            return yaml_parser_parse_node(parser, event, 0, 0); 
     1046        } 
     1047    } 
     1048 
     1049    parser->state = POP(parser, parser->states); 
     1050    POP(parser, parser->marks); 
     1051    SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark); 
     1052    SKIP_TOKEN(parser); 
     1053    return 1; 
    11341054} 
    11351055 
     
    11401060 */ 
    11411061 
    1142 static yaml_event_t * 
    1143 yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser) 
    1144 { 
    1145     yaml_token_t *token; 
    1146     yaml_event_t *event; 
    1147  
    1148     token = yaml_parser_peek_token(parser); 
    1149     if (!token) return NULL; 
     1062static int 
     1063yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser, 
     1064        yaml_event_t *event) 
     1065{ 
     1066    yaml_token_t *token; 
     1067 
     1068    token = PEEK_TOKEN(parser); 
     1069    if (!token) return 0; 
    11501070 
    11511071    if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN 
    11521072            && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { 
    1153         if (!yaml_parser_append_state(parser, 
     1073        if (!PUSH(parser, parser->states, 
    11541074                    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)) 
    1155             return NULL; 
    1156         return yaml_parser_parse_node(parser, 0, 0); 
     1075            return 0; 
     1076        return yaml_parser_parse_node(parser, event, 0, 0); 
    11571077    } 
    11581078    else { 
     1079        yaml_mark_t mark = token->end_mark; 
     1080        SKIP_TOKEN(parser); 
    11591081        parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE; 
    1160         event = yaml_parser_process_empty_scalar(parser, token->end_mark); 
    1161         yaml_token_delete(token); 
    1162         return event; 
     1082        return yaml_parser_process_empty_scalar(parser, event, mark); 
    11631083    } 
    11641084} 
     
    11701090 */ 
    11711091 
    1172 static yaml_event_t * 
    1173 yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser) 
    1174 { 
    1175     yaml_token_t *token; 
    1176  
    1177     token = yaml_parser_peek_token(parser); 
    1178     if (!token) return NULL; 
     1092static int 
     1093yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser, 
     1094        yaml_event_t *event) 
     1095{ 
     1096    yaml_token_t *token; 
     1097 
     1098    token = PEEK_TOKEN(parser); 
     1099    if (!token) return 0; 
    11791100 
    11801101    if (token->type == YAML_VALUE_TOKEN) { 
    1181         yaml_token_delete(yaml_parser_get_token(parser)); 
    1182         token = yaml_parser_peek_token(parser); 
    1183         if (!token) return NULL; 
     1102        SKIP_TOKEN(parser); 
     1103        token = PEEK_TOKEN(parser); 
     1104        if (!token) return 0; 
    11841105        if (token->type != YAML_FLOW_ENTRY_TOKEN 
    11851106                && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { 
    1186             if (!yaml_parser_append_state(parser, 
     1107            if (!PUSH(parser, parser->states, 
    11871108                        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)) 
    1188                 return NULL; 
    1189             return yaml_parser_parse_node(parser, 0, 0); 
     1109                return 0; 
     1110            return yaml_parser_parse_node(parser, event, 0, 0); 
    11901111        } 
    11911112    } 
    11921113    parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE; 
    1193     return yaml_parser_process_empty_scalar(parser, token->start_mark); 
     1114    return yaml_parser_process_empty_scalar(parser, event, token->start_mark); 
    11941115} 
    11951116 
     
    12001121 */ 
    12011122 
    1202 static yaml_event_t * 
    1203 yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser) 
    1204 { 
    1205     yaml_token_t *token; 
    1206  
    1207     token = yaml_parser_peek_token(parser); 
    1208     if (!token) return NULL; 
     1123static int 
     1124yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser, 
     1125        yaml_event_t *event) 
     1126{ 
     1127    yaml_token_t *token; 
     1128 
     1129    token = PEEK_TOKEN(parser); 
     1130    if (!token) return 0; 
    12091131 
    12101132    parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE; 
    12111133 
    1212     return yaml_mapping_end_event_new(token->start_mark, token->start_mark); 
     1134    MAPPING_END_EVENT_INIT(*event, token->start_mark, token->start_mark); 
     1135    return 1; 
    12131136} 
    12141137 
     
    12271150 */ 
    12281151 
    1229 static yaml_event_t * 
    1230 yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser, int first) 
    1231 { 
    1232     yaml_token_t *token; 
    1233     yaml_event_t *event; 
     1152static int 
     1153yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser, 
     1154        yaml_event_t *event, int first) 
     1155{ 
     1156    yaml_token_t *token; 
    12341157 
    12351158    if (first) { 
    1236         token = yaml_parser_get_token(parser); 
    1237         if (!yaml_parser_append_mark(parser, token->start_mark)) { 
    1238             yaml_token_delete(token); 
    1239             return NULL; 
    1240         } 
    1241         yaml_token_delete(token); 
    1242     } 
    1243  
    1244     token = yaml_parser_peek_token(parser); 
    1245     if (!token) return; 
     1159        token = PEEK_TOKEN(parser); 
     1160        if (!PUSH(parser, parser->marks, token->start_mark)) 
     1161            return 0; 
     1162        SKIP_TOKEN(parser); 
     1163    } 
     1164 
     1165    token = PEEK_TOKEN(parser); 
     1166    if (!token) return 0; 
    12461167 
    12471168    if (token->type != YAML_FLOW_MAPPING_END_TOKEN) 
     
    12491170        if (!first) { 
    12501171            if (token->type == YAML_FLOW_ENTRY_TOKEN) { 
    1251                 yaml_token_delete(yaml_parser_get_token(parser)); 
    1252                 token = yaml_parser_peek_token(parser); 
    1253                 if (!token) return; 
     1172                SKIP_TOKEN(parser); 
     1173                token = PEEK_TOKEN(parser); 
     1174                if (!token) return 0; 
    12541175            } 
    12551176            else { 
    1256                 yaml_parser_set_parser_error_context(parser, 
    1257                         "while parsing a flow mapping", parser->marks[parser->marks_length-1], 
     1177                return yaml_parser_set_parser_error_context(parser, 
     1178                        "while parsing a flow mapping", POP(parser, parser->marks), 
    12581179                        "did not found expected ',' or '}'", token->start_mark); 
    1259                 return NULL; 
    12601180            } 
    12611181        } 
    12621182 
    12631183        if (token->type == YAML_KEY_TOKEN) { 
    1264             yaml_token_delete(yaml_parser_get_token(parser)); 
    1265             token = yaml_parser_peek_token(parser); 
    1266             if (!token) return NULL; 
     1184            SKIP_TOKEN(parser); 
     1185            token = PEEK_TOKEN(parser); 
     1186            if (!token) return 0; 
    12671187            if (token->type != YAML_VALUE_TOKEN 
    12681188                    && token->type != YAML_FLOW_ENTRY_TOKEN 
    12691189                    && token->type != YAML_FLOW_MAPPING_END_TOKEN) { 
    1270                 if (!yaml_parser_append_state(parser, 
     1190                if (!PUSH(parser, parser->states, 
    12711191                            YAML_PARSE_FLOW_MAPPING_VALUE_STATE)) 
    1272                     return NULL; 
    1273                 return yaml_parser_parse_node(parser, 0, 0); 
     1192                    return 0; 
     1193                return yaml_parser_parse_node(parser, event, 0, 0); 
    12741194            } 
    12751195            else { 
    12761196                parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE; 
    1277                 return yaml_parser_process_empty_scalar(parser, token->start_mark); 
     1197                return yaml_parser_process_empty_scalar(parser, event, 
     1198                        token->start_mark); 
    12781199            } 
    12791200        } 
    12801201        else if (token->type != YAML_FLOW_MAPPING_END_TOKEN) { 
    1281             if (!yaml_parser_append_state(parser, 
     1202            if (!PUSH(parser, parser->states, 
    12821203                        YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)) 
    1283                 return NULL; 
    1284             return yaml_parser_parse_node(parser, 0, 0); 
    1285         } 
    1286     } 
    1287  
    1288     parser->state = parser->states[--parser->states_length]; 
    1289     parser->marks_length --; 
    1290     token = yaml_parser_get_token(parser); 
    1291     event = yaml_mapping_end_event_new(token->start_mark, token->end_mark); 
    1292     yaml_token_delete(token); 
    1293     return event; 
     1204                return 0; 
     1205            return yaml_parser_parse_node(parser, event, 0, 0); 
     1206        } 
     1207    } 
     1208 
     1209    parser->state = POP(parser, parser->states); 
     1210    POP(parser, parser->marks); 
     1211    MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark); 
     1212    SKIP_TOKEN(parser); 
     1213    return 1; 
    12941214} 
    12951215 
     
    13001220 */ 
    13011221 
    1302 static yaml_event_t * 
    1303 yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, int empty) 
    1304 { 
    1305     yaml_token_t *token; 
    1306     yaml_event_t *event; 
    1307  
    1308     token = yaml_parser_peek_token(parser); 
    1309     if (!token) return; 
     1222static int 
     1223yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, 
     1224        yaml_event_t *event, int empty) 
     1225{ 
     1226    yaml_token_t *token; 
     1227 
     1228    token = PEEK_TOKEN(parser); 
     1229    if (!token) return 0; 
    13101230 
    13111231    if (empty) { 
    13121232        parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; 
    1313         return yaml_parser_process_empty_scalar(parser, token->start_mark); 
     1233        return yaml_parser_process_empty_scalar(parser, event, 
     1234                token->start_mark); 
    13141235    } 
    13151236 
    13161237    if (token->type == YAML_VALUE_TOKEN) { 
    1317         yaml_token_delete(yaml_parser_get_token(parser)); 
    1318         token = yaml_parser_peek_token(parser); 
    1319         if (!token) return NULL; 
     1238        SKIP_TOKEN(parser); 
     1239        token = PEEK_TOKEN(parser); 
     1240        if (!token) return 0; 
    13201241        if (token->type != YAML_FLOW_ENTRY_TOKEN 
    13211242                && token->type != YAML_FLOW_MAPPING_END_TOKEN) { 
    1322             if (!yaml_parser_append_state(parser, 
     1243            if (!PUSH(parser, parser->states, 
    13231244                        YAML_PARSE_FLOW_MAPPING_KEY_STATE)) 
    1324                 return NULL; 
    1325             return yaml_parser_parse_node(parser, 0, 0); 
     1245                return 0; 
     1246            return yaml_parser_parse_node(parser, event, 0, 0); 
    13261247        } 
    13271248    } 
    13281249 
    13291250    parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; 
    1330     return yaml_parser_process_empty_scalar(parser, token->start_mark); 
     1251    return yaml_parser_process_empty_scalar(parser, event, token->start_mark); 
    13311252} 
    13321253 
     
    13351256 */ 
    13361257 
    1337 static yaml_event_t * 
    1338 yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_mark_t mark) 
    1339 { 
    1340     yaml_event_t *event; 
     1258static int 
     1259yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event, 
     1260        yaml_mark_t mark) 
     1261{ 
    13411262    yaml_char_t *value; 
    13421263 
     
    13441265    if (!value) { 
    13451266        parser->error = YAML_MEMORY_ERROR; 
    1346         return NULL; 
     1267        return 0; 
    13471268    } 
    13481269    value[0] = '\0'; 
    13491270 
    1350     event = yaml_scalar_event_new(NULL, NULL, value, 0, 
     1271    SCALAR_EVENT_INIT(*event, NULL, NULL, value, 0, 
    13511272            1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark); 
    1352     if (!event) { 
    1353         yaml_free(value); 
    1354         parser->error = YAML_MEMORY_ERROR; 
    1355         return NULL; 
    1356     } 
    1357  
    1358     return event; 
     1273 
     1274    return 1; 
    13591275} 
    13601276 
     
    13641280 
    13651281static int 
    1366 yaml_parser_process_directives(yaml_parser_t *parser) 
     1282yaml_parser_process_directives(yaml_parser_t *parser, 
     1283        yaml_version_directive_t **version_directive_ref, 
     1284        yaml_tag_directive_t **tag_directives_start_ref, 
     1285        yaml_tag_directive_t **tag_directives_end_ref) 
    13671286{ 
    13681287    yaml_tag_directive_t default_tag_directives[] = { 
     
    13711290        {NULL, NULL} 
    13721291    }; 
    1373     yaml_tag_directive_t *ref; 
    13741292    yaml_tag_directive_t *default_tag_directive; 
    1375     yaml_tag_directive_t **tag_directive; 
    1376     yaml_token_t *token; 
    1377  
    1378     token = yaml_parser_peek_token(parser); 
    1379     if (!token) return 0; 
     1293    yaml_version_directive_t *version_directive = NULL; 
     1294    struct { 
     1295        yaml_tag_directive_t *start; 
     1296        yaml_tag_directive_t *end; 
     1297        yaml_tag_directive_t *top; 
     1298    } tag_directives = { NULL, NULL, NULL }; 
     1299    yaml_token_t *token; 
     1300 
     1301    if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE)) 
     1302        goto error; 
     1303 
     1304    token = PEEK_TOKEN(parser); 
     1305    if (!token) goto error; 
    13801306 
    13811307    while (token->type == YAML_VERSION_DIRECTIVE_TOKEN || 
     
    13831309    { 
    13841310        if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) { 
    1385             if (parser->version_directive) { 
    1386                 return yaml_parser_set_parser_error(parser, 
     1311            if (version_directive) { 
     1312                yaml_parser_set_parser_error(parser, 
    13871313                        "found duplicate %YAML directive", token->start_mark); 
     1314                goto error; 
    13881315            } 
    13891316            if (token->data.version_directive.major != 1 
    13901317                    && token->data.version_directive.minor != 1) { 
    1391                 return yaml_parser_set_parser_error(parser, 
     1318                yaml_parser_set_parser_error(parser, 
    13921319                        "found incompatible YAML document", token->start_mark); 
    1393             } 
    1394             parser->version_directive = yaml_malloc(sizeof(yaml_version_directive_t)); 
    1395             if (!parser->version_directive) { 
     1320                goto error; 
     1321            } 
     1322            version_directive = yaml_malloc(sizeof(yaml_version_directive_t)); 
     1323            if (!version_directive) { 
    13961324                parser->error = YAML_MEMORY_ERROR; 
    1397                 return 0; 
    1398             } 
    1399             parser->version_directive->major = token->data.version_directive.major; 
    1400             parser->version_directive->minor = token->data.version_directive.minor; 
     1325                goto error; 
     1326            } 
     1327            version_directive->major = token->data.version_directive.major; 
     1328            version_directive->minor = token->data.version_directive.minor; 
    14011329        } 
    14021330 
     
    14061334                token->data.tag_directive.prefix 
    14071335            }; 
    1408             for (tag_directive = parser->tag_directives; 
    1409                     *tag_directive; tag_directive++) { 
    1410                 if (strcmp((char *)value.handle, 
    1411                             (char *)(*tag_directive)->handle) == 0) { 
    1412                     return yaml_parser_set_parser_error(parser, 
    1413                             "found duplicate %TAG directive", token->start_mark); 
    1414                 } 
    1415             } 
    1416             ref = yaml_malloc(sizeof(yaml_tag_directive_t)); 
    1417             if (!ref) { 
    1418                 parser->error = YAML_MEMORY_ERROR; 
    1419                 return 0; 
    1420             } 
    1421             *ref = value; 
    1422             if (!yaml_parser_append_tag_directive(parser, ref)) { 
    1423                 yaml_free(ref); 
    1424                 return 0; 
    1425             } 
    1426         } 
    1427         yaml_free(yaml_parser_get_token(parser)); 
    1428         token = yaml_parser_peek_token(parser); 
    1429         if (!token) return 0; 
    1430     } 
    1431  
     1336            if (!yaml_parser_append_tag_directive(parser, value, 0, 
     1337                        token->start_mark)) 
     1338                goto error; 
     1339            if (!PUSH(parser, tag_directives, value)) 
     1340                goto error; 
     1341        } 
     1342 
     1343        SKIP_TOKEN(parser); 
     1344        token = PEEK_TOKEN(parser); 
     1345        if (!token) goto error; 
     1346    } 
     1347     
    14321348    for (default_tag_directive = default_tag_directives; 
    14331349            default_tag_directive->handle; default_tag_directive++) { 
    1434         int found = 0; 
    1435         for (tag_directive = parser->tag_directives; 
    1436                 *tag_directive; tag_directive++) { 
    1437             if (strcmp((char *)default_tag_directive->handle, 
    1438                         (char *)(*tag_directive)->handle) == 0) { 
    1439                 found = 1; 
    1440                 break; 
    1441             } 
    1442         } 
    1443         if (!found) { 
    1444             ref = yaml_malloc(sizeof(yaml_tag_directive_t)); 
    1445             if (!ref) { 
    1446                 parser->error = YAML_MEMORY_ERROR; 
    1447                 return 0; 
    1448             } 
    1449             ref->handle = yaml_malloc(strlen((char *)default_tag_directive->handle)+1); 
    1450             if (!ref->handle) { 
    1451                 yaml_free(ref); 
    1452                 parser->error = YAML_MEMORY_ERROR; 
    1453                 return 0; 
    1454             } 
    1455             ref->prefix = yaml_malloc(strlen((char *)default_tag_directive->prefix)+1); 
    1456             if (!ref->prefix) { 
    1457                 yaml_free(ref->handle); 
    1458                 yaml_free(ref); 
    1459                 parser->error = YAML_MEMORY_ERROR; 
    1460                 return 0; 
    1461             } 
    1462             memcpy(ref->handle, default_tag_directive->handle, 
    1463                     strlen((char *)default_tag_directive->handle)+1); 
    1464             memcpy(ref->prefix, default_tag_directive->prefix, 
    1465                     strlen((char *)default_tag_directive->prefix)+1); 
    1466             if (!yaml_parser_append_tag_directive(parser, ref)) { 
    1467                 yaml_free(ref); 
    1468                 return 0; 
    1469             } 
    1470         } 
    1471     } 
     1350        if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1, 
     1351                    token->start_mark)) 
     1352            goto error; 
     1353    } 
     1354 
     1355    if (version_directive_ref) { 
     1356        *version_directive_ref = version_directive; 
     1357    } 
     1358    if (tag_directives_start_ref) { 
     1359        if (STACK_EMPTY(parser, tag_directives)) { 
     1360            *tag_directives_start_ref = *tag_directives_end_ref = NULL; 
     1361        } 
     1362        else { 
     1363            *tag_directives_start_ref = tag_directives.start; 
     1364            *tag_directives_end_ref = tag_directives.end; 
     1365        } 
     1366    } 
     1367 
    14721368    return 1; 
    1473 } 
    1474  
     1369 
     1370error: 
     1371    yaml_free(version_directive); 
     1372    while (!STACK_EMPTY(parser, tag_directives)) { 
     1373        yaml_tag_directive_t tag_directive = POP(parser, tag_directives); 
     1374        yaml_free(tag_directive.handle); 
     1375        yaml_free(tag_directive.prefix); 
     1376    } 
     1377    STACK_DEL(parser, tag_directives); 
     1378    return 0; 
     1379} 
     1380 
     1381static int 
     1382yaml_parser_append_tag_directive(yaml_parser_t *parser, 
     1383        yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark) 
     1384{ 
     1385    yaml_tag_directive_t *tag_directive; 
     1386    yaml_tag_directive_t copy = { NULL, NULL }; 
     1387    int length; 
     1388 
     1389    for (tag_directive = parser->tag_directives.start; 
     1390            tag_directive != parser->tag_directives.top; tag_directive ++) { 
     1391        if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) { 
     1392            if (allow_duplicates) 
     1393                return 1; 
     1394            return yaml_parser_set_parser_error(parser, 
     1395                    "found duplicate %TAG directive", mark); 
     1396        } 
     1397    } 
     1398 
     1399    copy.handle = (yaml_char_t *)yaml_strdup((char *)value.handle); 
     1400    copy.prefix = (yaml_char_t *)yaml_strdup((char *)value.prefix); 
     1401    if (!copy.handle || !copy.prefix) { 
     1402        parser->error = YAML_MEMORY_ERROR; 
     1403        goto error; 
     1404    } 
     1405 
     1406    if (!PUSH(parser, parser->tag_directives, copy)) 
     1407        goto error; 
     1408 
     1409    return 1; 
     1410 
     1411error: 
     1412    yaml_free(copy.handle); 
     1413    yaml_free(copy.prefix); 
     1414    return 0; 
     1415} 
     1416 
Note: See TracChangeset for help on using the changeset viewer.