Changeset 208


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

Refactor internal and external API.

Location:
libyaml/trunk
Files:
3 added
8 edited

Legend:

Unmodified
Added
Removed
  • libyaml/trunk/include/yaml.h

    r202 r208  
    148148} yaml_scalar_style_t; 
    149149 
    150  
    151150/** Sequence styles. */ 
    152151typedef enum { 
     
    162161 
    163162    YAML_BLOCK_MAPPING_STYLE, 
    164     YAML_FLOW_MAPPING_STYLE 
     163    YAML_FLOW_MAPPING_STYLE, 
     164    YAML_FLOW_SET_MAPPING_STYLE 
    165165} yaml_mapping_style_t; 
    166166 
     
    174174/** Token types. */ 
    175175typedef enum { 
     176    YAML_NO_TOKEN, 
     177 
    176178    YAML_STREAM_START_TOKEN, 
    177179    YAML_STREAM_END_TOKEN, 
     
    233235            /** The tag handle. */ 
    234236            yaml_char_t *handle; 
    235  
    236237            /** The tag suffix. */ 
    237238            yaml_char_t *suffix; 
     
    240241        /** The scalar value (for @c YAML_SCALAR_TOKEN). */ 
    241242        struct { 
    242  
    243243            /** The scalar value. */ 
    244244            yaml_char_t *value; 
    245  
    246245            /** The length of the scalar value. */ 
    247246            size_t length; 
    248  
    249247            /** The scalar style. */ 
    250248            yaml_scalar_style_t style; 
     
    255253            /** The major version number. */ 
    256254            int major; 
    257  
    258255            /** The minor version number. */ 
    259256            int minor; 
     
    264261            /** The tag handle. */ 
    265262            yaml_char_t *handle; 
    266  
    267263            /** The tag prefix. */ 
    268264            yaml_char_t *prefix; 
    269265        } tag_directive; 
     266 
    270267    } data; 
    271268 
    272269    /** The beginning of the token. */ 
    273270    yaml_mark_t start_mark; 
    274  
    275271    /** The end of the token. */ 
    276272    yaml_mark_t end_mark; 
     
    279275 
    280276/** 
    281  * Create a new token without assigning any data. 
    282  * 
    283  * This function can be used for constructing indicator tokens: 
    284  * @c YAML_DOCUMENT_START, @c YAML_DOCUMENT_END, 
    285  * @c YAML_BLOCK_SEQUENCE_START_TOKEN, @c YAML_BLOCK_MAPPING_START_TOKEN, 
    286  * @c YAML_BLOCK_END_TOKEN, 
    287  * @c YAML_FLOW_SEQUENCE_START_TOKEN, @c YAML_FLOW_SEQUENCE_END_TOKEN, 
    288  * @c YAML_FLOW_MAPPING_START_TOKEN, @c YAML_FLOW_MAPPING_END_TOKEN, 
    289  * @c YAML_BLOCK_ENTRY_TOKEN, @c YAML_FLOW_ENTRY_TOKEN, 
    290  * @c YAML_KEY_TOKEN, @c YAML_VALUE_TOKEN. 
    291  * 
    292  * @param[in]   type        The token type. 
    293  * @param[in]   start_mark  The beginning of the token. 
    294  * @param[in]   end_mark    The end of the token. 
    295  * 
    296  * @returns A new token object, or @c NULL on error. 
    297  */ 
    298  
    299 YAML_DECLARE(yaml_token_t *) 
    300 yaml_token_new(yaml_token_type_t type, 
    301         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    302  
    303 /** 
    304  * Create a new @c YAML_STREAM_START_TOKEN token with the specified encoding. 
    305  * 
    306  * @param[in]   encoding    The stream encoding. 
    307  * @param[in]   start_mark  The beginning of the token. 
    308  * @param[in]   end_mark    The end of the token. 
    309  * 
    310  * @returns A new token object, or @c NULL on error. 
    311  */ 
    312  
    313 YAML_DECLARE(yaml_token_t *) 
    314 yaml_stream_start_token_new(yaml_encoding_t encoding, 
    315         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    316  
    317 /** 
    318  * Create a new @c YAML_STREAM_END_TOKEN token. 
    319  * 
    320  * @param[in]   start_mark  The beginning of the token. 
    321  * @param[in]   end_mark    The end of the token. 
    322  * 
    323  * @returns A new token object, or @c NULL on error. 
    324  */ 
    325  
    326 YAML_DECLARE(yaml_token_t *) 
    327 yaml_stream_end_token_new(yaml_mark_t start_mark, yaml_mark_t end_mark); 
    328  
    329 /** 
    330  * Create a new @c YAML_VERSION_DIRECTIVE_TOKEN token with the specified 
    331  * version numbers. 
    332  * 
    333  * @param[in]   major       The major version number. 
    334  * @param[in]   minor       The minor version number. 
    335  * @param[in]   start_mark  The beginning of the token. 
    336  * @param[in]   end_mark    The end of the token. 
    337  * 
    338  * @returns A new token object, or @c NULL on error. 
    339  */ 
    340  
    341 YAML_DECLARE(yaml_token_t *) 
    342 yaml_version_directive_token_new(int major, int minor, 
    343         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    344  
    345 /** 
    346  * Create a new @c YAML_TAG_DIRECTIVE_TOKEN token with the specified tag 
    347  * handle and prefix. 
    348  * 
    349  * Note that the @a handle and the @a prefix pointers will be freed by 
    350  * the token descructor. 
    351  * 
    352  * @param[in]   handle      The tag handle. 
    353  * @param[in]   prefix      The tag prefix. 
    354  * @param[in]   start_mark  The beginning of the token. 
    355  * @param[in]   end_mark    The end of the token. 
    356  * 
    357  * @returns A new token object, or @c NULL on error. 
    358  */ 
    359  
    360 YAML_DECLARE(yaml_token_t *) 
    361 yaml_tag_directive_token_new(yaml_char_t *handle, yaml_char_t *prefix, 
    362         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    363  
    364 /** 
    365  * Create a new @c YAML_ALIAS_TOKEN token with the specified anchor. 
    366  * 
    367  * Note that the @a anchor pointer will be freed by the token descructor. 
    368  * 
    369  * @param[in]   anchor      The anchor. 
    370  * @param[in]   start_mark  The beginning of the token. 
    371  * @param[in]   end_mark    The end of the token. 
    372  * 
    373  * @returns A new token object, or @c NULL on error. 
    374  */ 
    375  
    376 YAML_DECLARE(yaml_token_t *) 
    377 yaml_alias_token_new(yaml_char_t *anchor, 
    378         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    379  
    380 /** 
    381  * Create a new @c YAML_ANCHOR_TOKEN token with the specified anchor. 
    382  * 
    383  * Note that the @a anchor pointer will be freed by the token descructor. 
    384  * 
    385  * @param[in]   anchor      The anchor. 
    386  * @param[in]   start_mark  The beginning of the token. 
    387  * @param[in]   end_mark    The end of the token. 
    388  * 
    389  * @returns A new token object, or @c NULL on error. 
    390  */ 
    391  
    392 YAML_DECLARE(yaml_token_t *) 
    393 yaml_anchor_token_new(yaml_char_t *anchor, 
    394         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    395  
    396 /** 
    397  * Create a new @c YAML_TAG_TOKEN token with the specified tag handle and 
    398  * suffix. 
    399  * 
    400  * Note that the @a handle and the @a suffix pointers will be freed by 
    401  * the token descructor. 
    402  * 
    403  * @param[in]   handle      The tag handle. 
    404  * @param[in]   suffix      The tag suffix. 
    405  * @param[in]   start_mark  The beginning of the token. 
    406  * @param[in]   end_mark    The end of the token. 
    407  * 
    408  * @returns A new token object, or @c NULL on error. 
    409  */ 
    410  
    411 YAML_DECLARE(yaml_token_t *) 
    412 yaml_tag_token_new(yaml_char_t *handle, yaml_char_t *suffix, 
    413         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    414  
    415 /** 
    416  * Create a new @c YAML_SCALAR_TOKEN token with the specified scalar value, 
    417  * length, and style. 
    418  * 
    419  * Note that the scalar value may contain the @c NUL character, therefore 
    420  * the value length is also required.  The scalar value always ends with 
    421  * @c NUL. 
    422  * 
    423  * Note that the @a value pointer will be freed by the token descructor. 
    424  * 
    425  * @param[in]   value       The scalar value. 
    426  * @param[in]   length      The value length. 
    427  * @param[in]   style       The scalar style. 
    428  * @param[in]   start_mark  The beginning of the token. 
    429  * @param[in]   end_mark    The end of the token. 
    430  * 
    431  * @returns A new token object, or @c NULL on error. 
    432  */ 
    433  
    434 YAML_DECLARE(yaml_token_t *) 
    435 yaml_scalar_token_new(yaml_char_t *value, size_t length, 
    436         yaml_scalar_style_t style, 
    437         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    438  
    439 /** 
    440  * Destroy a token object. 
     277 * Free any memory allocated for a token object. 
    441278 * 
    442279 * @param[in]   token   A token object. 
     
    455292/** Event types. */ 
    456293typedef enum { 
     294    YAML_NO_EVENT, 
     295 
    457296    YAML_STREAM_START_EVENT, 
    458297    YAML_STREAM_END_EVENT, 
     
    490329            /** The version directive. */ 
    491330            yaml_version_directive_t *version_directive; 
     331 
    492332            /** The list of tag directives. */ 
    493             yaml_tag_directive_t **tag_directives; 
     333            struct { 
     334                /** The beginning of the tag directives list. */ 
     335                yaml_tag_directive_t *start; 
     336                /** The end of the tag directives list. */ 
     337                yaml_tag_directive_t *end; 
     338            } tag_directives; 
     339 
    494340            /** Is the document indicator implicit? */ 
    495341            int implicit; 
     
    554400    /** The beginning of the token. */ 
    555401    yaml_mark_t start_mark; 
    556  
    557402    /** The end of the token. */ 
    558403    yaml_mark_t end_mark; 
     404 
    559405} yaml_event_t; 
    560406 
    561407/** 
    562  * Create a new @c YAML_STREAM_START_EVENT event. 
    563  * 
    564  * @param[in]   encoding    The stream encoding. 
    565  * @param[in]   start_mark  The beginning of the event. 
    566  * @param[in]   end_mark    The end of the event. 
    567  * 
    568  * @returns A new event object, or @c NULL on error. 
    569  */ 
    570  
    571 YAML_DECLARE(yaml_event_t *) 
    572 yaml_stream_start_event_new(yaml_encoding_t encoding, 
    573         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    574  
    575 /** 
    576  * Create a new @c YAML_STREAM_END_TOKEN event. 
    577  * 
    578  * @param[in]   start_mark  The beginning of the event. 
    579  * @param[in]   end_mark    The end of the event. 
    580  * 
    581  * @returns A new event object, or @c NULL on error. 
    582  */ 
    583  
    584 YAML_DECLARE(yaml_event_t *) 
    585 yaml_stream_end_event_new(yaml_mark_t start_mark, yaml_mark_t end_mark); 
    586  
    587 /** 
    588  * Create a new @c YAML_DOCUMENT_START_EVENT event. 
    589  * 
    590  * @param[in]   version_directive   The version directive or @c NULL. 
    591  * @param[in]   tag_directives      A list of tag directives or @c NULL. 
    592  * @param[in]   implicit            Is the document indicator present? 
    593  * @param[in]   start_mark          The beginning of the event. 
    594  * @param[in]   end_mark            The end of the event. 
    595  * 
    596  * @returns A new event object, or @c NULL on error. 
    597  */ 
    598  
    599 YAML_DECLARE(yaml_event_t *) 
    600 yaml_document_start_event_new(yaml_version_directive_t *version_directive, 
    601         yaml_tag_directive_t **tag_directives, int implicit, 
    602         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    603  
    604 /** 
    605  * Create a new @c YAML_DOCUMENT_END_EVENT event. 
    606  * 
    607  * @param[in]   implicit    Is the document end indicator present? 
    608  * @param[in]   start_mark  The beginning of the event. 
    609  * @param[in]   end_mark    The end of the event. 
    610  * 
    611  * @returns A new event object, or @c NULL on error. 
    612  */ 
    613  
    614 YAML_DECLARE(yaml_event_t *) 
    615 yaml_document_end_event_new(int implicit, 
    616         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    617  
    618 /** 
    619  * Create a new @c YAML_ALIAS_EVENT event. 
    620  * 
    621  * @param[in]   anchor      The anchor value. 
    622  * @param[in]   start_mark  The beginning of the event. 
    623  * @param[in]   end_mark    The end of the event. 
    624  * 
    625  * @returns A new event object, or @c NULL on error. 
    626  */ 
    627  
    628 YAML_DECLARE(yaml_event_t *) 
    629 yaml_alias_event_new(yaml_char_t *anchor, 
    630         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    631  
    632 /** 
    633  * Create a new @c YAML_SCALAR_EVENT event. 
    634  * 
    635  * @param[in]   anchor          The anchor value or @c NULL. 
    636  * @param[in]   tag             The tag value or @c NULL. 
    637  * @param[in]   value           The scalar value. 
    638  * @param[in]   length          The length of the scalar value. 
    639  * @param[in]   plain_implicit  Is the tag optional for the plain style? 
    640  * @param[in]   quoted_implicit Is the tag optional for any non-plain style? 
    641  * @param[in]   style           The scalar style. 
    642  * @param[in]   start_mark      The beginning of the event. 
    643  * @param[in]   end_mark        The end of the event. 
    644  * 
    645  * @returns A new event object, or @c NULL on error. 
    646  */ 
    647  
    648 YAML_DECLARE(yaml_event_t *) 
    649 yaml_scalar_event_new(yaml_char_t *anchor, yaml_char_t *tag, 
    650         yaml_char_t *value, size_t length, 
    651         int plain_implicit, int quoted_implicit, 
    652         yaml_scalar_style_t style, 
    653         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    654  
    655 /** 
    656  * Create a new @c YAML_SEQUENCE_START_EVENT event. 
    657  * 
    658  * @param[in]   anchor      The anchor value or @c NULL. 
    659  * @param[in]   tag         The tag value or @c NULL. 
    660  * @param[in]   implicit    Is the tag optional? 
    661  * @param[in]   style       The sequence style. 
    662  * @param[in]   start_mark  The beginning of the event. 
    663  * @param[in]   end_mark    The end of the event. 
    664  * 
    665  * @returns A new event object, or @c NULL on error. 
    666  */ 
    667  
    668 YAML_DECLARE(yaml_event_t *) 
    669 yaml_sequence_start_event_new(yaml_char_t *anchor, yaml_char_t *tag, 
    670         int implicit, yaml_sequence_style_t style, 
    671         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    672  
    673 /** 
    674  * Create a new @c YAML_SEQUENCE_END_EVENT event. 
    675  * 
    676  * @param[in]   start_mark  The beginning of the event. 
    677  * @param[in]   end_mark    The end of the event. 
    678  * 
    679  * @returns A new event object, or @c NULL on error. 
    680  */ 
    681  
    682 YAML_DECLARE(yaml_event_t *) 
    683 yaml_sequence_end_event_new(yaml_mark_t start_mark, yaml_mark_t end_mark); 
    684  
    685 /** 
    686  * Create a new @c YAML_MAPPING_START_EVENT event. 
    687  * 
    688  * @param[in]   anchor      The anchor value or @c NULL. 
    689  * @param[in]   tag         The tag value or @c NULL. 
    690  * @param[in]   implicit    Is the tag optional? 
    691  * @param[in]   style       The mapping style. 
    692  * @param[in]   start_mark  The beginning of the event. 
    693  * @param[in]   end_mark    The end of the event. 
    694  * 
    695  * @returns A new event object, or @c NULL on error. 
    696  */ 
    697  
    698 YAML_DECLARE(yaml_event_t *) 
    699 yaml_mapping_start_event_new(yaml_char_t *anchor, yaml_char_t *tag, 
    700         int implicit, yaml_mapping_style_t style, 
    701         yaml_mark_t start_mark, yaml_mark_t end_mark); 
    702  
    703 /** 
    704  * Create a new @c YAML_MAPPING_END_EVENT event. 
    705  * 
    706  * @param[in]   start_mark  The beginning of the event. 
    707  * @param[in]   end_mark    The end of the event. 
    708  * 
    709  * @returns A new event object, or @c NULL on error. 
    710  */ 
    711  
    712 YAML_DECLARE(yaml_event_t *) 
    713 yaml_mapping_end_event_new(yaml_mark_t start_mark, yaml_mark_t end_mark); 
    714  
    715 /** 
    716  * Destroy an event object. 
     408 * Free any memory allocated for an event object. 
    717409 * 
    718410 * @param[in]   event   An event object. 
     
    751443 
    752444/** 
    753  * This structure holds a string input specified by 
    754  * @c yaml_parser_set_input_string. 
     445 * This structure holds information about a potential simple key. 
    755446 */ 
    756447 
    757448typedef struct { 
    758     /** The string start pointer. */ 
    759     unsigned char *start; 
    760  
    761     /** The string end pointer. */ 
    762     unsigned char *end; 
    763  
    764     /** The string current position. */ 
    765     unsigned char *current; 
    766 } yaml_string_input_t; 
    767  
    768 /** 
    769  * This structure holds information about a potential simple key. 
    770  */ 
    771  
    772 typedef struct { 
     449    /** Is a simple key possible? */ 
     450    int possible; 
     451 
    773452    /** Is a simple key required? */ 
    774453    int required; 
     
    776455    /** The number of the token. */ 
    777456    size_t token_number; 
    778  
    779     /** The position index. */ 
    780     size_t index; 
    781  
    782     /** The position line. */ 
    783     size_t line; 
    784  
    785     /** The position column. */ 
    786     size_t column; 
    787457 
    788458    /** The position mark. */ 
     
    794464 */ 
    795465typedef enum { 
    796     YAML_PARSE_END_STATE, 
    797466    YAML_PARSE_STREAM_START_STATE, 
    798467    YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE, 
     
    817486    YAML_PARSE_FLOW_MAPPING_KEY_STATE, 
    818487    YAML_PARSE_FLOW_MAPPING_VALUE_STATE, 
    819     YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE 
     488    YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE, 
     489    YAML_PARSE_END_STATE 
    820490} yaml_parser_state_t; 
    821491 
     
    836506    /** Error type. */ 
    837507    yaml_error_type_t error; 
    838  
    839508    /** Error description. */ 
    840509    const char *problem; 
    841  
    842510    /** The byte about which the problem occured. */ 
    843511    size_t problem_offset; 
    844  
    845512    /** The problematic value (@c -1 is none). */ 
    846513    int problem_value; 
    847  
    848514    /** The problem position. */ 
    849515    yaml_mark_t problem_mark; 
    850  
    851516    /** The error context. */ 
    852517    const char *context; 
    853  
    854518    /** The context position. */ 
    855519    yaml_mark_t context_mark; 
     
    870534    void *read_handler_data; 
    871535 
     536    /** Standard (string or file) input data. */ 
     537    union { 
     538        /** String input data. */ 
     539        struct { 
     540            /** The string start pointer. */ 
     541            unsigned char *start; 
     542            /** The string end pointer. */ 
     543            unsigned char *end; 
     544            /** The string current position. */ 
     545            unsigned char *current; 
     546        } string; 
     547 
     548        /** File input data. */ 
     549        FILE *file; 
     550    } input; 
     551 
    872552    /** EOF flag */ 
    873553    int eof; 
    874554 
    875     /** The pointer to the beginning of the working buffer. */ 
    876     yaml_char_t *buffer; 
    877  
    878     /** The pointer to the end of the working buffer. */ 
    879     yaml_char_t *buffer_end; 
    880  
    881     /** The pointer to the current character in the working buffer. */ 
    882     yaml_char_t *pointer; 
    883  
    884     /** The number of unread characters in the working buffer. */ 
     555    /** The working buffer. */ 
     556    struct { 
     557        /* The beginning of the buffer. */ 
     558        yaml_char_t *start; 
     559        /* The end of the buffer. */ 
     560        yaml_char_t *end; 
     561        /* The current position of the buffer. */ 
     562        yaml_char_t *pointer; 
     563        /* The last filled position of the buffer. */ 
     564        yaml_char_t *last; 
     565    } buffer; 
     566 
     567    /* The number of unread characters in the buffer. */ 
    885568    size_t unread; 
    886569 
    887     /** The pointer to the beginning of the raw buffer. */ 
    888     unsigned char *raw_buffer; 
    889  
    890     /** The pointer to the current character in the raw buffer. */ 
    891     unsigned char *raw_pointer; 
    892  
    893     /** The number of unread bytes in the raw buffer. */ 
    894     size_t raw_unread; 
     570    /** The raw buffer. */ 
     571    struct { 
     572        /** The beginning of the buffer. */ 
     573        unsigned char *start; 
     574        /** The end of the buffer. */ 
     575        unsigned char *end; 
     576        /** The current position of the buffer. */ 
     577        unsigned char *pointer; 
     578        /** The last filled position of the buffer. */ 
     579        unsigned char *last; 
     580    } raw_buffer; 
    895581 
    896582    /** The input encoding. */ 
     
    900586    size_t offset; 
    901587 
    902     /** The index of the current position (in characters). */ 
    903     size_t index; 
    904  
    905     /** The line of the current position (starting from @c 0). */ 
    906     size_t line; 
    907  
    908     /** The column of the current position (starting from @c 0). */ 
    909     size_t column; 
    910  
    911     /* String input structure. */ 
    912     yaml_string_input_t string_input; 
     588    /** The mark of the current position. */ 
     589    yaml_mark_t mark; 
    913590 
    914591    /** 
     
    930607    int flow_level; 
    931608 
    932     /** The tokens queue, which contains the current produced tokens. */ 
    933     yaml_token_t **tokens; 
    934  
    935     /** The size of the tokens queue. */ 
    936     size_t tokens_size; 
    937  
    938     /** The head of the tokens queue. */ 
    939     size_t tokens_head; 
    940  
    941     /** The tail of the tokens queue. */ 
    942     size_t tokens_tail; 
    943  
    944     /** The number of tokens fetched from the tokens queue. */ 
     609    /** The tokens queue. */ 
     610    struct { 
     611        /** The beginning of the tokens queue. */ 
     612        yaml_token_t *start; 
     613        /** The end of the tokens queue. */ 
     614        yaml_token_t *end; 
     615        /** The head of the tokens queue. */ 
     616        yaml_token_t *head; 
     617        /** The tail of the tokens queue. */ 
     618        yaml_token_t *tail; 
     619    } tokens; 
     620 
     621    /** The number of tokens fetched from the queue. */ 
    945622    size_t tokens_parsed; 
    946623 
    947     /** The stack of indentation levels. */ 
    948     int *indents; 
    949  
    950     /** The size of the indents stack. */ 
    951     size_t indents_size; 
    952  
    953     /** The number of items in the indents stack. */ 
    954     size_t indents_length; 
     624    /* Does the tokens queue contain a token ready for dequeueing. */ 
     625    int token_available; 
     626 
     627    /** The indentation levels stack. */ 
     628    struct { 
     629        /** The beginning of the stack. */ 
     630        int *start; 
     631        /** The end of the stack. */ 
     632        int *end; 
     633        /** The top of the stack. */ 
     634        int *top; 
     635    } indents; 
    955636 
    956637    /** The current indentation level. */ 
     
    960641    int simple_key_allowed; 
    961642 
    962     /** The stack of potential simple keys. */ 
    963     yaml_simple_key_t **simple_keys; 
    964  
    965     /** The size of the simple keys stack. */ 
    966     size_t simple_keys_size; 
     643    /** The stack of simple keys. */ 
     644    struct { 
     645        /** The beginning of the stack. */ 
     646        yaml_simple_key_t *start; 
     647        /** The end of the stack. */ 
     648        yaml_simple_key_t *end; 
     649        /** The top of the stack. */ 
     650        yaml_simple_key_t *top; 
     651    } simple_keys; 
    967652 
    968653    /** 
     
    976661 
    977662    /** The parser states stack. */ 
    978     yaml_parser_state_t *states; 
    979  
    980     /** The size of the parser states stack. */ 
    981     size_t states_size; 
    982  
    983     /** The number of items in the parser states stack. */ 
    984     size_t states_length; 
     663    struct { 
     664        /** The beginning of the stack. */ 
     665        yaml_parser_state_t *start; 
     666        /** The end of the stack. */ 
     667        yaml_parser_state_t *end; 
     668        /** The top of the stack. */ 
     669        yaml_parser_state_t *top; 
     670    } states; 
    985671 
    986672    /** The current parser state. */ 
     
    988674 
    989675    /** The stack of marks. */ 
    990     yaml_mark_t *marks; 
    991  
    992     /** The size of the marks stack. */ 
    993     size_t marks_size; 
    994  
    995     /** The number of items in the marks stack. */ 
    996     size_t marks_length; 
    997  
    998     /** The current event. */ 
    999     yaml_event_t *current_event; 
    1000  
    1001     /** The YAML version directive. */ 
    1002     yaml_version_directive_t *version_directive; 
     676    struct { 
     677        /** The beginning of the stack. */ 
     678        yaml_mark_t *start; 
     679        /** The end of the stack. */ 
     680        yaml_mark_t *end; 
     681        /** The top of the stack. */ 
     682        yaml_mark_t *top; 
     683    } marks; 
    1003684 
    1004685    /** The list of TAG directives. */ 
    1005     yaml_tag_directive_t **tag_directives; 
    1006  
    1007     /** The size of the TAG directives list. */ 
    1008     size_t tag_directives_size; 
    1009  
    1010     /** The number of items in the TAG directives list. */ 
    1011     size_t tag_directives_length; 
     686    struct { 
     687        /** The beginning of the list. */ 
     688        yaml_tag_directive_t *start; 
     689        /** The end of the list. */ 
     690        yaml_tag_directive_t *end; 
     691        /** The top of the list. */ 
     692        yaml_tag_directive_t *top; 
     693    } tag_directives; 
    1012694 
    1013695    /** 
     
    1018700 
    1019701/** 
    1020  * Create a new parser. 
     702 * Initialize a parser. 
    1021703 * 
    1022704 * This function creates a new parser object.  An application is responsible 
    1023705 * for destroying the object using the @c yaml_parser_delete function. 
    1024706 * 
    1025  * @returns A new parser object; @c NULL on error. 
    1026  */ 
    1027  
    1028 YAML_DECLARE(yaml_parser_t *) 
    1029 yaml_parser_new(void); 
     707 * @param[in]   parser  An empty parser object. 
     708 * 
     709 * @returns #c 1 if the function succeeded, @c 0 on error. 
     710 */ 
     711 
     712YAML_DECLARE(int) 
     713yaml_parser_initialize(yaml_parser_t *parser); 
    1030714 
    1031715/** 
     
    1091775 
    1092776/** 
    1093  * Get the next token. 
    1094  * 
    1095  * The token is removed from the internal token queue and the application is 
    1096  * responsible for destroing the token object. 
     777 * Scan the input stream and produce the next token. 
     778 * 
     779 * Call the function subsequently to produce a sequence of tokens corresponding 
     780 * to the input stream.  The initial token has the type 
     781 * @c YAML_STREAM_START_TOKEN while the ending token has the type 
     782 * @c YAML_STREAM_END_TOKEN. 
     783 * 
     784 * An application is responsible for freeing any buffers associated with the 
     785 * produced token object using the @c yaml_token_delete function. 
     786 * 
     787 * An application must not alternate the calls of @c yaml_parser_scan with the 
     788 * calls of @c yaml_parser_parse. Doing this will break the parser. 
    1097789 * 
    1098790 * @param[in]   parser      A parser object. 
    1099  * 
    1100  * @returns A token object, or @c NULL on error. 
    1101  */ 
    1102  
    1103 YAML_DECLARE(yaml_token_t *) 
    1104 yaml_parser_get_token(yaml_parser_t *parser); 
    1105  
    1106 /** 
    1107  * Peek the next token. 
    1108  * 
    1109  * The token is not removed from the internal token queue and will be returned 
    1110  * again on a subsequent call of @c yaml_parser_get_token or 
    1111  * @c yaml_parser_peek_token. The application should not destroy the token 
    1112  * object. 
     791 * @param[in]   token       An empty token object. 
     792 * 
     793 * @returns @c 1 if the function succeeded, @c 0 on error. 
     794 */ 
     795 
     796YAML_DECLARE(int) 
     797yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token); 
     798 
     799/** 
     800 * Parse the input stream and produce the next parsing event. 
     801 * 
     802 * Call the function subsequently to produce a sequence of events corresponding 
     803 * to the input stream.  The initial event has the type 
     804 * @c YAML_STREAM_START_EVENT while the ending event has the type 
     805 * @c YAML_STREAM_END_EVENT. 
     806 * 
     807 * An application is responsible for freeing any buffers associated with the 
     808 * produced event object using the @c yaml_event_delete function. 
     809 * 
     810 * An application must not alternate the calls of @c yaml_parser_scan with the 
     811 * calls of @c yaml_parser_parse. Doing this will break the parser. 
    1113812 * 
    1114813 * @param[in]   parser      A parser object. 
    1115  * 
    1116  * @returns A token object, or @c NULL on error. 
    1117  */ 
    1118  
    1119 YAML_DECLARE(yaml_token_t *) 
    1120 yaml_parser_peek_token(yaml_parser_t *parser); 
    1121  
    1122 /** 
    1123  * Get the next event. 
    1124  * 
    1125  * The application is responsible for destroing the event object. 
    1126  * 
    1127  * @param[in]   parser      A parser object. 
    1128  * 
    1129  * @returns An event object, or @c NULL on error. 
    1130  */ 
    1131  
    1132 YAML_DECLARE(yaml_event_t *) 
    1133 yaml_parser_get_event(yaml_parser_t *parser); 
    1134  
    1135 /** 
    1136  * Peek the next event. 
    1137  * 
    1138  * The event will be returned again on a subsequent call of 
    1139  * @c yaml_parser_get_event or @c yaml_parser_peek_event.  The application 
    1140  * should not destroy the event object. 
    1141  * 
    1142  * @param[in]   parser      A parser object. 
    1143  * 
    1144  * @returns An event object, or @c NULL on error. 
    1145  */ 
    1146  
    1147 YAML_DECLARE(yaml_event_t *) 
    1148 yaml_parser_peek_event(yaml_parser_t *parser); 
     814 * @param[in]   event       An empty event object. 
     815 * 
     816 * @returns @c 1 if the function succeeded, @c 0 on error. 
     817 */ 
     818 
     819YAML_DECLARE(int) 
     820yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event); 
    1149821 
    1150822/** @} */ 
     
    1153825typedef struct { 
    1154826} yaml_emitter_t; 
     827 
     828YAML_DECLARE(int) 
     829yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event); 
     830 
     831YAML_DECLARE(int) 
     832yaml_emitter_emit_stream_start(yaml_emitter_t *emitter, 
     833        yaml_encoding_t encoding); 
     834 
    1155835*/ 
    1156  
    1157 /** 
    1158  * @defgroup internal Internal Definitions 
    1159  * @{ 
    1160  */ 
    1161  
    1162 /** 
    1163  * Allocate a dynamic memory block. 
    1164  * 
    1165  * @param[in]   size    Size of a memory block, \c 0 is valid. 
    1166  * 
    1167  * @returns @c yaml_malloc returns a pointer to a newly allocated memory block, 
    1168  * or @c NULL if it failed. 
    1169  */ 
    1170  
    1171 YAML_DECLARE(void *) 
    1172 yaml_malloc(size_t size); 
    1173  
    1174 /** 
    1175  * Reallocate a dynamic memory block. 
    1176  * 
    1177  * @param[in]   ptr     A pointer to an existing memory block, \c NULL is 
    1178  *                      valid. 
    1179  * @param[in]   size    A size of a new block, \c 0 is valid. 
    1180  * 
    1181  * @returns @c yaml_realloc returns a pointer to a reallocated memory block, 
    1182  * or @c NULL if it failed. 
    1183  */ 
    1184  
    1185 YAML_DECLARE(void *) 
    1186 yaml_realloc(void *ptr, size_t size); 
    1187  
    1188 /** 
    1189  * Free a dynamic memory block. 
    1190  * 
    1191  * @param[in]   ptr     A pointer to an existing memory block, \c NULL is 
    1192  *                      valid. 
    1193  */ 
    1194  
    1195 YAML_DECLARE(void) 
    1196 yaml_free(void *ptr); 
    1197  
    1198 /** The initial size for various buffers. */ 
    1199  
    1200 #define YAML_DEFAULT_SIZE   16 
    1201  
    1202 /** The size of the raw buffer. */ 
    1203  
    1204 #define YAML_RAW_BUFFER_SIZE 16384 
    1205  
    1206 /** 
    1207  * The size of the buffer. 
    1208  * 
    1209  * We allocate enough space for decoding the whole raw buffer. 
    1210  */ 
    1211  
    1212 #define YAML_BUFFER_SIZE    (YAML_RAW_BUFFER_SIZE*3) 
    1213  
    1214 /** 
    1215  * Ensure that the buffer contains at least @a length characters. 
    1216  * 
    1217  * @param[in]   parser  A parser object. 
    1218  * @param[in]   length  The number of characters in the buffer. 
    1219  * 
    1220  * @returns @c 1 on success, @c 0 on error. 
    1221  */ 
    1222  
    1223 YAML_DECLARE(int) 
    1224 yaml_parser_update_buffer(yaml_parser_t *parser, size_t length); 
    1225  
    1226 /** @} */ 
    1227  
    1228836 
    1229837#ifdef __cplusplus 
  • libyaml/trunk/src/api.c

    r203 r208  
    11 
    2 #if HAVE_CONFIG_H 
    3 #include <config.h> 
    4 #endif 
    5  
    6 #include <yaml.h> 
    7  
    8 #include <assert.h> 
     2#include "yaml_private.h" 
     3 
     4/* 
     5 * Get the library version. 
     6 */ 
    97 
    108YAML_DECLARE(const char *) 
     
    1311    return YAML_VERSION_STRING; 
    1412} 
     13 
     14/* 
     15 * Get the library version numbers. 
     16 */ 
    1517 
    1618YAML_DECLARE(void) 
     
    5355 
    5456/* 
     57 * Duplicate a string. 
     58 */ 
     59 
     60YAML_DECLARE(char *) 
     61yaml_strdup(const char *str) 
     62{ 
     63    return strdup(str); 
     64} 
     65 
     66/* 
     67 * Extend a string. 
     68 */ 
     69 
     70YAML_DECLARE(int) 
     71yaml_string_extend(yaml_char_t **start, 
     72        yaml_char_t **pointer, yaml_char_t **end) 
     73{ 
     74    void *new_start = yaml_realloc(*start, (*end - *start)*2); 
     75 
     76    if (!new_start) return 0; 
     77 
     78    memset(new_start + (*end - *start), 0, *end - *start); 
     79 
     80    *pointer = new_start + (*pointer - *start); 
     81    *end = new_start + (*end - *start)*2; 
     82    *start = new_start; 
     83 
     84    return 1; 
     85} 
     86 
     87/* 
     88 * Append a string B to a string A. 
     89 */ 
     90 
     91YAML_DECLARE(int) 
     92yaml_string_join( 
     93        yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end, 
     94        yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end) 
     95{ 
     96    if (*b_start == *b_pointer) 
     97        return 1; 
     98 
     99    while (*a_end - *a_pointer <= *b_pointer - *b_start) { 
     100        if (!yaml_string_extend(a_start, a_pointer, a_end)) 
     101            return 0; 
     102    } 
     103 
     104    memcpy(*a_pointer, *b_start, *b_pointer - *b_start); 
     105    *a_pointer += *b_pointer - *b_start; 
     106 
     107    return 1; 
     108} 
     109 
     110/* 
     111 * Extend a stack. 
     112 */ 
     113 
     114YAML_DECLARE(int) 
     115yaml_stack_extend(void **start, void **top, void **end) 
     116{ 
     117    void *new_start = yaml_realloc(*start, (*end - *start)*2); 
     118 
     119    if (!new_start) return 0; 
     120 
     121    *top = new_start + (*top - *start); 
     122    *end = new_start + (*end - *start)*2; 
     123    *start = new_start; 
     124 
     125    return 1; 
     126} 
     127 
     128/* 
     129 * Extend or move a queue. 
     130 */ 
     131 
     132YAML_DECLARE(int) 
     133yaml_queue_extend(void **start, void **head, void **tail, void **end) 
     134{ 
     135    /* Check if we need to resize the queue. */ 
     136 
     137    if (*start == *head && *tail == *end) { 
     138        void *new_start = yaml_realloc(*start, (*end - *start)*2); 
     139 
     140        if (!new_start) return 0; 
     141 
     142        *head = new_start + (*head - *start); 
     143        *tail = new_start + (*tail - *start); 
     144        *end = new_start + (*end - *start)*2; 
     145        *start = new_start; 
     146    } 
     147 
     148    /* Check if we need to move the queue at the beginning of the buffer. */ 
     149 
     150    if (*tail == *end) { 
     151        if (*head != *tail) { 
     152            memmove(*start, *head, *tail - *head); 
     153        } 
     154        *tail -= *head - *start; 
     155        *head = *start; 
     156    } 
     157 
     158    return 1; 
     159} 
     160 
     161 
     162/* 
    55163 * Create a new parser object. 
    56164 */ 
    57165 
    58 YAML_DECLARE(yaml_parser_t *) 
    59 yaml_parser_new(void) 
    60 { 
    61     yaml_parser_t *parser; 
    62  
    63     /* Allocate the parser structure. */ 
    64  
    65     parser = yaml_malloc(sizeof(yaml_parser_t)); 
    66     if (!parser) goto error; 
     166YAML_DECLARE(int) 
     167yaml_parser_initialize(yaml_parser_t *parser) 
     168{ 
     169    assert(parser);     /* Non-NULL parser object expected. */ 
    67170 
    68171    memset(parser, 0, sizeof(yaml_parser_t)); 
    69  
    70     /* Allocate the raw buffer. */ 
    71  
    72     parser->raw_buffer = yaml_malloc(YAML_RAW_BUFFER_SIZE); 
    73     if (!parser->raw_buffer) goto error; 
    74     memset(parser->raw_buffer, 0, YAML_RAW_BUFFER_SIZE); 
    75  
    76     parser->raw_pointer = parser->raw_buffer; 
    77     parser->raw_unread = 0; 
    78  
    79     /* Allocate the character buffer. */ 
    80  
    81     parser->buffer = yaml_malloc(YAML_BUFFER_SIZE); 
    82     if (!parser->buffer) goto error; 
    83     memset(parser->buffer, 0, YAML_BUFFER_SIZE); 
    84  
    85     parser->buffer_end = parser->buffer; 
    86     parser->pointer = parser->buffer; 
    87     parser->unread = 0; 
    88  
    89     /* Allocate the tokens queue. */ 
    90  
    91     parser->tokens = yaml_malloc(YAML_DEFAULT_SIZE*sizeof(yaml_token_t *)); 
    92     if (!parser->tokens) goto error; 
    93     memset(parser->tokens, 0, YAML_DEFAULT_SIZE*sizeof(yaml_token_t *)); 
    94  
    95     parser->tokens_size = YAML_DEFAULT_SIZE; 
    96     parser->tokens_head = 0; 
    97     parser->tokens_tail = 0; 
    98     parser->tokens_parsed = 0; 
    99  
    100     /* Allocate the indents stack. */ 
    101  
    102     parser->indents = yaml_malloc(YAML_DEFAULT_SIZE*sizeof(int)); 
    103     if (!parser->indents) goto error; 
    104     memset(parser->indents, 0, YAML_DEFAULT_SIZE*sizeof(int)); 
    105  
    106     parser->indents_size = YAML_DEFAULT_SIZE; 
    107     parser->indents_length = 0; 
    108  
    109     /* Allocate the stack of potential simple keys. */ 
    110  
    111     parser->simple_keys = yaml_malloc(YAML_DEFAULT_SIZE*sizeof(yaml_simple_key_t *)); 
    112     if (!parser->simple_keys) goto error; 
    113     memset(parser->simple_keys, 0, YAML_DEFAULT_SIZE*sizeof(yaml_simple_key_t *)); 
    114  
    115     parser->simple_keys_size = YAML_DEFAULT_SIZE; 
    116  
    117     /* Allocate the stack of parser states. */ 
    118  
    119     parser->states = yaml_malloc(YAML_DEFAULT_SIZE*sizeof(yaml_parser_state_t)); 
    120     if (!parser->states) goto error; 
    121     memset(parser->states, 0, YAML_DEFAULT_SIZE*sizeof(yaml_parser_state_t)); 
    122  
    123     parser->states_size = YAML_DEFAULT_SIZE; 
    124  
    125     /* Set the initial state. */ 
    126  
    127     parser->state = YAML_PARSE_STREAM_START_STATE; 
    128  
    129     /* Allocate the stack of marks. */ 
    130  
    131     parser->marks = yaml_malloc(YAML_DEFAULT_SIZE*sizeof(yaml_mark_t)); 
    132     if (!parser->marks) goto error; 
    133     memset(parser->marks, 0, YAML_DEFAULT_SIZE*sizeof(yaml_mark_t)); 
    134  
    135     parser->marks_size = YAML_DEFAULT_SIZE; 
    136  
    137     /* Allocate the list of TAG directives. */ 
    138  
    139     parser->tag_directives = yaml_malloc(YAML_DEFAULT_SIZE*sizeof(yaml_tag_directive_t *)); 
    140     if (!parser->tag_directives) goto error; 
    141     memset(parser->tag_directives, 0, YAML_DEFAULT_SIZE*sizeof(yaml_tag_directive_t *)); 
    142  
    143     parser->tag_directives_size = YAML_DEFAULT_SIZE; 
    144  
    145     /* Done. */ 
    146  
    147     return parser; 
    148  
    149     /* On error, free allocated buffers. */ 
     172    if (!BUFFER_INIT(parser, parser->raw_buffer, RAW_BUFFER_SIZE)) 
     173        goto error; 
     174    if (!BUFFER_INIT(parser, parser->buffer, BUFFER_SIZE)) 
     175        goto error; 
     176    if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE)) 
     177        goto error; 
     178    if (!STACK_INIT(parser, parser->indents, INITIAL_STACK_SIZE)) 
     179        goto error; 
     180    if (!STACK_INIT(parser, parser->simple_keys, INITIAL_STACK_SIZE)) 
     181        goto error; 
     182    if (!STACK_INIT(parser, parser->states, INITIAL_STACK_SIZE)) 
     183        goto error; 
     184    if (!STACK_INIT(parser, parser->marks, INITIAL_STACK_SIZE)) 
     185        goto error; 
     186    if (!STACK_INIT(parser, parser->tag_directives, INITIAL_STACK_SIZE)) 
     187        goto error; 
     188 
     189    return 1; 
    150190 
    151191error: 
    152192 
    153     if (!parser) return NULL; 
    154  
    155     yaml_free(parser->tag_directives); 
    156     yaml_free(parser->marks); 
    157     yaml_free(parser->states); 
    158     yaml_free(parser->simple_keys); 
    159     yaml_free(parser->indents); 
    160     yaml_free(parser->tokens); 
    161     yaml_free(parser->buffer); 
    162     yaml_free(parser->raw_buffer); 
    163  
    164     yaml_free(parser); 
    165  
    166     return NULL; 
     193    BUFFER_DEL(parser, parser->raw_buffer); 
     194    BUFFER_DEL(parser, parser->buffer); 
     195    QUEUE_DEL(parser, parser->tokens); 
     196    STACK_DEL(parser, parser->indents); 
     197    STACK_DEL(parser, parser->simple_keys); 
     198    STACK_DEL(parser, parser->states); 
     199    STACK_DEL(parser, parser->marks); 
     200    STACK_DEL(parser, parser->tag_directives); 
     201 
     202    return 0; 
    167203} 
    168204 
     
    176212    assert(parser); /* Non-NULL parser object expected. */ 
    177213 
    178     /*yaml_free(parser->tag_directives);*/ 
    179     yaml_free(parser->marks); 
    180     yaml_free(parser->states); 
    181     yaml_free(parser->simple_keys); 
    182     yaml_free(parser->indents); 
    183     yaml_free(parser->tokens); 
    184     yaml_free(parser->buffer); 
    185     yaml_free(parser->raw_buffer); 
     214    BUFFER_DEL(parser, parser->raw_buffer); 
     215    BUFFER_DEL(parser, parser->buffer); 
     216    while (!QUEUE_EMPTY(parser, parser->tokens)) { 
     217        yaml_token_delete(&DEQUEUE(parser, parser->tokens)); 
     218    } 
     219    QUEUE_DEL(parser, parser->tokens); 
     220    STACK_DEL(parser, parser->indents); 
     221    STACK_DEL(parser, parser->simple_keys); 
     222    STACK_DEL(parser, parser->states); 
     223    STACK_DEL(parser, parser->marks); 
     224    while (!STACK_EMPTY(parser, parser->tag_directives)) { 
     225        yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives); 
     226        yaml_free(tag_directive.handle); 
     227        yaml_free(tag_directive.prefix); 
     228    } 
     229    STACK_DEL(parser, parser->tag_directives); 
    186230 
    187231    memset(parser, 0, sizeof(yaml_parser_t)); 
    188  
    189     yaml_free(parser); 
    190232} 
    191233 
     
    198240        size_t *size_read) 
    199241{ 
    200     yaml_string_input_t *input = data; 
    201  
    202     if (input->current == input->end) { 
     242    yaml_parser_t *parser = data; 
     243 
     244    if (parser->input.string.current == parser->input.string.end) { 
    203245        *size_read = 0; 
    204246        return 1; 
    205247    } 
    206248 
    207     if (size > (input->end - input->current)) { 
    208         size = input->end - input->current; 
    209     } 
    210  
    211     memcpy(buffer, input->current, size); 
    212     input->current += size; 
     249    if (size > (parser->input.string.end - parser->input.string.current)) { 
     250        size = parser->input.string.end - parser->input.string.current; 
     251    } 
     252 
     253    memcpy(buffer, parser->input.string.current, size); 
     254    parser->input.string.current += size; 
    213255    *size_read = size; 
    214256    return 1; 
     
    223265        size_t *size_read) 
    224266{ 
    225     *size_read = fread(buffer, 1, size, (FILE *)data); 
    226     return !ferror((FILE *)data); 
     267    yaml_parser_t *parser = data; 
     268 
     269    *size_read = fread(buffer, 1, size, parser->input.file); 
     270    return !ferror(parser->input.file); 
    227271} 
    228272 
     
    239283    assert(input);  /* Non-NULL input string expected. */ 
    240284 
    241     parser->string_input.start = input; 
    242     parser->string_input.current = input; 
    243     parser->string_input.end = input+size; 
    244  
    245285    parser->read_handler = yaml_string_read_handler; 
    246     parser->read_handler_data = &parser->string_input; 
     286    parser->read_handler_data = parser; 
     287 
     288    parser->input.string.start = input; 
     289    parser->input.string.current = input; 
     290    parser->input.string.end = input+size; 
    247291} 
    248292 
     
    259303 
    260304    parser->read_handler = yaml_file_read_handler; 
    261     parser->read_handler_data = file; 
     305    parser->read_handler_data = parser; 
     306 
     307    parser->input.file = file; 
    262308} 
    263309 
     
    289335 
    290336    parser->encoding = encoding; 
    291 } 
    292  
    293 /* 
    294  * Create a token. 
    295  */ 
    296  
    297 YAML_DECLARE(yaml_token_t *) 
    298 yaml_token_new(yaml_token_type_t type, 
    299         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    300 { 
    301     yaml_token_t *token = yaml_malloc(sizeof(yaml_token_t)); 
    302  
    303     if (!token) return NULL; 
    304  
    305     memset(token, 0, sizeof(yaml_token_t)); 
    306  
    307     token->type = type; 
    308     token->start_mark = start_mark; 
    309     token->end_mark = end_mark; 
    310  
    311     return token; 
    312 } 
    313  
    314 /* 
    315  * Create a STREAM-START token. 
    316  */ 
    317  
    318 YAML_DECLARE(yaml_token_t *) 
    319 yaml_stream_start_token_new(yaml_encoding_t encoding, 
    320         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    321 { 
    322     yaml_token_t *token = yaml_token_new(YAML_STREAM_START_TOKEN, 
    323             start_mark, end_mark); 
    324  
    325     if (!token) return NULL; 
    326  
    327     token->data.stream_start.encoding = encoding; 
    328  
    329     return token; 
    330 } 
    331  
    332 /* 
    333  * Create a STREAM-END token. 
    334  */ 
    335  
    336 YAML_DECLARE(yaml_token_t *) 
    337 yaml_stream_end_token_new(yaml_mark_t start_mark, yaml_mark_t end_mark) 
    338 { 
    339     yaml_token_t *token = yaml_token_new(YAML_STREAM_END_TOKEN, 
    340             start_mark, end_mark); 
    341  
    342     if (!token) return NULL; 
    343  
    344     return token; 
    345 } 
    346  
    347 /* 
    348  * Create a VERSION-DIRECTIVE token. 
    349  */ 
    350  
    351 YAML_DECLARE(yaml_token_t *) 
    352 yaml_version_directive_token_new(int major, int minor, 
    353         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    354 { 
    355     yaml_token_t *token = yaml_token_new(YAML_VERSION_DIRECTIVE_TOKEN, 
    356             start_mark, end_mark); 
    357  
    358     if (!token) return NULL; 
    359  
    360     token->data.version_directive.major = major; 
    361     token->data.version_directive.minor = minor; 
    362  
    363     return token; 
    364 } 
    365  
    366 /* 
    367  * Create a TAG-DIRECTIVE token. 
    368  */ 
    369  
    370 YAML_DECLARE(yaml_token_t *) 
    371 yaml_tag_directive_token_new(yaml_char_t *handle, yaml_char_t *prefix, 
    372         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    373 { 
    374     yaml_token_t *token = yaml_token_new(YAML_TAG_DIRECTIVE_TOKEN, 
    375             start_mark, end_mark); 
    376  
    377     if (!token) return NULL; 
    378  
    379     token->data.tag_directive.handle = handle; 
    380     token->data.tag_directive.prefix = prefix; 
    381  
    382     return token; 
    383 } 
    384  
    385 /* 
    386  * Create an ALIAS token. 
    387  */ 
    388  
    389 YAML_DECLARE(yaml_token_t *) 
    390 yaml_alias_token_new(yaml_char_t *anchor, 
    391         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    392 { 
    393     yaml_token_t *token = yaml_token_new(YAML_ALIAS_TOKEN, 
    394             start_mark, end_mark); 
    395  
    396     if (!token) return NULL; 
    397  
    398     token->data.alias.value = anchor; 
    399  
    400     return token; 
    401 } 
    402  
    403 /* 
    404  * Create an ANCHOR token. 
    405  */ 
    406  
    407 YAML_DECLARE(yaml_token_t *) 
    408 yaml_anchor_token_new(yaml_char_t *anchor, 
    409         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    410 { 
    411     yaml_token_t *token = yaml_token_new(YAML_ANCHOR_TOKEN, 
    412             start_mark, end_mark); 
    413  
    414     if (!token) return NULL; 
    415  
    416     token->data.anchor.value = anchor; 
    417  
    418     return token; 
    419 } 
    420  
    421 /* 
    422  * Create a TAG token. 
    423  */ 
    424  
    425 YAML_DECLARE(yaml_token_t *) 
    426 yaml_tag_token_new(yaml_char_t *handle, yaml_char_t *suffix, 
    427         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    428 { 
    429     yaml_token_t *token = yaml_token_new(YAML_TAG_TOKEN, 
    430             start_mark, end_mark); 
    431  
    432     if (!token) return NULL; 
    433  
    434     token->data.tag.handle = handle; 
    435     token->data.tag.suffix = suffix; 
    436  
    437     return token; 
    438 } 
    439  
    440 /* 
    441  * Create a SCALAR token. 
    442  */ 
    443  
    444 YAML_DECLARE(yaml_token_t *) 
    445 yaml_scalar_token_new(yaml_char_t *value, size_t length, 
    446         yaml_scalar_style_t style, 
    447         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    448 { 
    449     yaml_token_t *token = yaml_token_new(YAML_SCALAR_TOKEN, 
    450             start_mark, end_mark); 
    451  
    452     if (!token) return NULL; 
    453  
    454     token->data.scalar.value = value; 
    455     token->data.scalar.length = length; 
    456     token->data.scalar.style = style; 
    457  
    458     return token; 
    459337} 
    460338 
     
    494372 
    495373    memset(token, 0, sizeof(yaml_token_t)); 
    496  
    497     yaml_free(token); 
    498 } 
    499  
    500 /* 
    501  * Create an event. 
    502  */ 
    503  
    504 static yaml_event_t * 
    505 yaml_event_new(yaml_event_type_t type, 
    506         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    507 { 
    508     yaml_event_t *event = yaml_malloc(sizeof(yaml_event_t)); 
    509  
    510     if (!event) return NULL; 
    511  
    512     memset(event, 0, sizeof(yaml_event_t)); 
    513  
    514     event->type = type; 
    515     event->start_mark = start_mark; 
    516     event->end_mark = end_mark; 
    517  
    518     return event; 
    519 } 
    520  
    521 /* 
    522  * Create a STREAM-START event. 
    523  */ 
    524  
    525 YAML_DECLARE(yaml_event_t *) 
    526 yaml_stream_start_event_new(yaml_encoding_t encoding, 
    527         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    528 { 
    529     yaml_event_t *event = yaml_event_new(YAML_STREAM_START_EVENT, 
    530             start_mark, end_mark); 
    531  
    532     if (!event) return NULL; 
    533  
    534     event->data.stream_start.encoding = encoding; 
    535  
    536     return event; 
    537 } 
    538  
    539 /* 
    540  * Create a STREAM-END event. 
    541  */ 
    542  
    543 YAML_DECLARE(yaml_event_t *) 
    544 yaml_stream_end_event_new(yaml_mark_t start_mark, yaml_mark_t end_mark) 
    545 { 
    546     return yaml_event_new(YAML_STREAM_END_EVENT, start_mark, end_mark); 
    547 } 
    548  
    549 /* 
    550  * Create a DOCUMENT-START event. 
    551  */ 
    552  
    553 YAML_DECLARE(yaml_event_t *) 
    554 yaml_document_start_event_new(yaml_version_directive_t *version_directive, 
    555         yaml_tag_directive_t **tag_directives, int implicit, 
    556         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    557 { 
    558     yaml_event_t *event = yaml_event_new(YAML_DOCUMENT_START_EVENT, 
    559             start_mark, end_mark); 
    560  
    561     if (!event) return NULL; 
    562  
    563     event->data.document_start.version_directive = version_directive; 
    564     event->data.document_start.tag_directives = tag_directives; 
    565     event->data.document_start.implicit = implicit; 
    566  
    567     return event; 
    568 } 
    569  
    570 /* 
    571  * Create a DOCUMENT-END event. 
    572  */ 
    573  
    574 YAML_DECLARE(yaml_event_t *) 
    575 yaml_document_end_event_new(int implicit, 
    576         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    577 { 
    578     yaml_event_t *event = yaml_event_new(YAML_DOCUMENT_END_EVENT, 
    579             start_mark, end_mark); 
    580  
    581     if (!event) return NULL; 
    582  
    583     event->data.document_end.implicit = implicit; 
    584  
    585     return event; 
    586 } 
    587  
    588 /* 
    589  * Create an ALIAS event. 
    590  */ 
    591  
    592 YAML_DECLARE(yaml_event_t *) 
    593 yaml_alias_event_new(yaml_char_t *anchor, 
    594         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    595 { 
    596     yaml_event_t *event = yaml_event_new(YAML_ALIAS_EVENT, 
    597             start_mark, end_mark); 
    598  
    599     if (!event) return NULL; 
    600  
    601     event->data.alias.anchor = anchor; 
    602  
    603     return event; 
    604 } 
    605  
    606 /* 
    607  * Create a SCALAR event. 
    608  */ 
    609  
    610 YAML_DECLARE(yaml_event_t *) 
    611 yaml_scalar_event_new(yaml_char_t *anchor, yaml_char_t *tag, 
    612         yaml_char_t *value, size_t length, 
    613         int plain_implicit, int quoted_implicit, 
    614         yaml_scalar_style_t style, 
    615         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    616 { 
    617     yaml_event_t *event = yaml_event_new(YAML_SCALAR_EVENT, 
    618             start_mark, end_mark); 
    619  
    620     if (!event) return NULL; 
    621  
    622     event->data.scalar.anchor = anchor; 
    623     event->data.scalar.tag = tag; 
    624     event->data.scalar.value = value; 
    625     event->data.scalar.length = length; 
    626     event->data.scalar.plain_implicit = plain_implicit; 
    627     event->data.scalar.quoted_implicit = quoted_implicit; 
    628     event->data.scalar.style = style; 
    629  
    630     return event; 
    631 } 
    632  
    633 /* 
    634  * Create a SEQUENCE-START event. 
    635  */ 
    636  
    637 YAML_DECLARE(yaml_event_t *) 
    638 yaml_sequence_start_event_new(yaml_char_t *anchor, yaml_char_t *tag, 
    639         int implicit, yaml_sequence_style_t style, 
    640         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    641 { 
    642     yaml_event_t *event = yaml_event_new(YAML_SEQUENCE_START_EVENT, 
    643             start_mark, end_mark); 
    644  
    645     if (!event) return NULL; 
    646  
    647     event->data.sequence_start.anchor = anchor; 
    648     event->data.sequence_start.tag = tag; 
    649     event->data.sequence_start.implicit = implicit; 
    650     event->data.sequence_start.style = style; 
    651  
    652     return event; 
    653 } 
    654  
    655 /* 
    656  * Create a SEQUENCE-END event. 
    657  */ 
    658  
    659 YAML_DECLARE(yaml_event_t *) 
    660 yaml_sequence_end_event_new(yaml_mark_t start_mark, yaml_mark_t end_mark) 
    661 { 
    662     return yaml_event_new(YAML_SEQUENCE_END_EVENT, start_mark, end_mark); 
    663 } 
    664  
    665 /* 
    666  * Create a MAPPING-START event. 
    667  */ 
    668  
    669 YAML_DECLARE(yaml_event_t *) 
    670 yaml_mapping_start_event_new(yaml_char_t *anchor, yaml_char_t *tag, 
    671         int implicit, yaml_mapping_style_t style, 
    672         yaml_mark_t start_mark, yaml_mark_t end_mark) 
    673 { 
    674     yaml_event_t *event = yaml_event_new(YAML_MAPPING_START_EVENT, 
    675             start_mark, end_mark); 
    676  
    677     if (!event) return NULL; 
    678  
    679     event->data.mapping_start.anchor = anchor; 
    680     event->data.mapping_start.tag = tag; 
    681     event->data.mapping_start.implicit = implicit; 
    682     event->data.mapping_start.style = style; 
    683  
    684     return event; 
    685 } 
    686  
    687 /* 
    688  * Create a MAPPING-END event. 
    689  */ 
    690  
    691 YAML_DECLARE(yaml_event_t *) 
    692 yaml_mapping_end_event_new(yaml_mark_t start_mark, yaml_mark_t end_mark) 
    693 { 
    694     return yaml_event_new(YAML_MAPPING_END_EVENT, start_mark, end_mark); 
    695374} 
    696375 
     
    702381yaml_event_delete(yaml_event_t *event) 
    703382{ 
     383    yaml_tag_directive_t *tag_directive; 
     384 
    704385    assert(event);  /* Non-NULL event object expected. */ 
    705386 
     
    707388    { 
    708389        case YAML_DOCUMENT_START_EVENT: 
    709             /*yaml_free(event->data.document_start.version_directive); 
    710             if (event->data.document_start.tag_directives) { 
    711                 yaml_tag_directive_t **tag_directive; 
    712                 for (tag_directive = event->data.document_start.tag_directives; 
    713                         *tag_directive; tag_directive++) { 
    714                     yaml_free((*tag_directive)->handle); 
    715                     yaml_free((*tag_directive)->prefix); 
    716                     yaml_free(*tag_directive); 
    717                 } 
    718                 yaml_free(event->data.document_start.tag_directives); 
    719             }*/ 
     390            yaml_free(event->data.document_start.version_directive); 
     391            for (tag_directive = event->data.document_start.tag_directives.start; 
     392                    tag_directive != event->data.document_start.tag_directives.end; 
     393                    tag_directive++) { 
     394                yaml_free(tag_directive->handle); 
     395                yaml_free(tag_directive->prefix); 
     396            } 
     397            yaml_free(event->data.document_start.tag_directives.start); 
    720398            break; 
    721399 
     
    742420 
    743421    memset(event, 0, sizeof(yaml_event_t)); 
    744  
    745     yaml_free(event); 
    746 } 
    747  
     422} 
     423 
  • 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 
  • libyaml/trunk/src/reader.c

    r200 r208  
    11 
    2 #if HAVE_CONFIG_H 
    3 #include <config.h> 
    4 #endif 
    5  
    6 #include <yaml.h> 
    7  
    8 #include <assert.h> 
     2#include "yaml_private.h" 
     3 
     4/* 
     5 * Declarations. 
     6 */ 
     7 
     8static int 
     9yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem, 
     10        size_t offset, int value); 
     11 
     12static int 
     13yaml_parser_update_raw_buffer(yaml_parser_t *parser); 
     14 
     15static int 
     16yaml_parser_determine_encoding(yaml_parser_t *parser); 
     17 
     18YAML_DECLARE(int) 
     19yaml_parser_update_buffer(yaml_parser_t *parser, size_t length); 
    920 
    1021/* 
     
    2536 
    2637/* 
     38 * Byte order marks. 
     39 */ 
     40 
     41#define BOM_UTF8    "\xef\xbb\xbf" 
     42#define BOM_UTF16LE "\xff\xfe" 
     43#define BOM_UTF16BE "\xfe\xff" 
     44 
     45/* 
     46 * Determine the input stream encoding by checking the BOM symbol. If no BOM is 
     47 * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure. 
     48 */ 
     49 
     50static int 
     51yaml_parser_determine_encoding(yaml_parser_t *parser) 
     52{ 
     53    /* Ensure that we had enough bytes in the raw buffer. */ 
     54 
     55    while (!parser->eof  
     56            && parser->raw_buffer.last - parser->raw_buffer.pointer < 3) { 
     57        if (!yaml_parser_update_raw_buffer(parser)) { 
     58            return 0; 
     59        } 
     60    } 
     61 
     62    /* Determine the encoding. */ 
     63 
     64    if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 
     65            && !memcmp(parser->raw_buffer.pointer, BOM_UTF16LE, 2)) { 
     66        parser->encoding = YAML_UTF16LE_ENCODING; 
     67        parser->raw_buffer.pointer += 2; 
     68        parser->offset += 2; 
     69    } 
     70    else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 
     71            && !memcmp(parser->raw_buffer.pointer, BOM_UTF16BE, 2)) { 
     72        parser->encoding = YAML_UTF16BE_ENCODING; 
     73        parser->raw_buffer.pointer += 2; 
     74        parser->offset += 2; 
     75    } 
     76    else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 3 
     77            && !memcmp(parser->raw_buffer.pointer, BOM_UTF8, 3)) { 
     78        parser->encoding = YAML_UTF8_ENCODING; 
     79        parser->raw_buffer.pointer += 3; 
     80        parser->offset += 3; 
     81    } 
     82    else { 
     83        parser->encoding = YAML_UTF8_ENCODING; 
     84    } 
     85 
     86    return 1; 
     87} 
     88 
     89/* 
    2790 * Update the raw buffer. 
    2891 */ 
     
    3598    /* Return if the raw buffer is full. */ 
    3699 
    37     if (parser->raw_unread == YAML_RAW_BUFFER_SIZE) return 1; 
     100    if (parser->raw_buffer.start == parser->raw_buffer.pointer 
     101            && parser->raw_buffer.last == parser->raw_buffer.end) 
     102        return 1; 
    38103 
    39104    /* Return on EOF. */ 
     
    43108    /* Move the remaining bytes in the raw buffer to the beginning. */ 
    44109 
    45     if (parser->raw_unread && parser->raw_buffer < parser->raw_pointer) { 
    46         memmove(parser->raw_buffer, parser->raw_pointer, parser->raw_unread); 
    47     } 
    48     parser->raw_pointer = parser->raw_buffer; 
     110    if (parser->raw_buffer.start < parser->raw_buffer.pointer 
     111            && parser->raw_buffer.pointer < parser->raw_buffer.last) { 
     112        memmove(parser->raw_buffer.start, parser->raw_buffer.pointer, 
     113                parser->raw_buffer.last - parser->raw_buffer.pointer); 
     114    } 
     115    parser->raw_buffer.last -= 
     116        parser->raw_buffer.pointer - parser->raw_buffer.start; 
     117    parser->raw_buffer.pointer = parser->raw_buffer.start; 
    49118 
    50119    /* Call the read handler to fill the buffer. */ 
    51120 
    52     if (!parser->read_handler(parser->read_handler_data, 
    53                 parser->raw_buffer + parser->raw_unread, 
    54                 YAML_RAW_BUFFER_SIZE - parser->raw_unread, 
    55                 &size_read)) { 
     121    if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last, 
     122                parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) { 
    56123        return yaml_parser_set_reader_error(parser, "Input error", 
    57124                parser->offset, -1); 
    58125    } 
    59     parser->raw_unread += size_read; 
     126    parser->raw_buffer.last += size_read; 
    60127    if (!size_read) { 
    61128        parser->eof = 1; 
     
    66133 
    67134/* 
    68  * Determine the input stream encoding by checking the BOM symbol. If no BOM is 
    69  * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure. 
    70  */ 
    71  
    72 #define BOM_UTF8    "\xef\xbb\xbf" 
    73 #define BOM_UTF16LE "\xff\xfe" 
    74 #define BOM_UTF16BE "\xfe\xff" 
    75  
    76 static int 
    77 yaml_parser_determine_encoding(yaml_parser_t *parser) 
    78 { 
    79     /* Ensure that we had enough bytes in the raw buffer. */ 
    80  
    81     while (!parser->eof && parser->raw_unread < 3) { 
    82         if (!yaml_parser_update_raw_buffer(parser)) { 
    83             return 0; 
    84         } 
    85     } 
    86  
    87     /* Determine the encoding. */ 
    88  
    89     if (parser->raw_unread >= 2 
    90             && !memcmp(parser->raw_pointer, BOM_UTF16LE, 2)) { 
    91         parser->encoding = YAML_UTF16LE_ENCODING; 
    92         parser->raw_pointer += 2; 
    93         parser->raw_unread -= 2; 
    94         parser->offset += 2; 
    95     } 
    96     else if (parser->raw_unread >= 2 
    97             && !memcmp(parser->raw_pointer, BOM_UTF16BE, 2)) { 
    98         parser->encoding = YAML_UTF16BE_ENCODING; 
    99         parser->raw_pointer += 2; 
    100         parser->raw_unread -= 2; 
    101         parser->offset += 2; 
    102     } 
    103     else if (parser->raw_unread >= 3 
    104             && !memcmp(parser->raw_pointer, BOM_UTF8, 3)) { 
    105         parser->encoding = YAML_UTF8_ENCODING; 
    106         parser->raw_pointer += 3; 
    107         parser->raw_unread -= 3; 
    108         parser->offset += 3; 
    109     } 
    110     else { 
    111         parser->encoding = YAML_UTF8_ENCODING; 
    112     } 
    113  
    114     return 1; 
    115 } 
    116  
    117 /* 
    118  * Ensure that the buffer contains at least length characters. 
     135 * Ensure that the buffer contains at least `length` characters. 
    119136 * Return 1 on success, 0 on failure. 
    120137 * 
     
    125142yaml_parser_update_buffer(yaml_parser_t *parser, size_t length) 
    126143{ 
     144    assert(parser->read_handler);   /* Read handler must be set. */ 
     145 
    127146    /* If the EOF flag is set and the raw buffer is empty, do nothing. */ 
    128147 
    129     if (parser->eof && !parser->raw_unread) 
     148    if (parser->eof && parser->raw_buffer.pointer == parser->raw_buffer.last) 
    130149        return 1; 
    131150 
     
    144163    /* Move the unread characters to the beginning of the buffer. */ 
    145164 
    146     if (parser->buffer < parser->pointer 
    147             && parser->pointer < parser->buffer_end) { 
    148         size_t size = parser->buffer_end - parser->pointer; 
    149         memmove(parser->buffer, parser->pointer, size); 
    150         parser->pointer = parser->buffer; 
    151         parser->buffer_end = parser->buffer + size; 
    152     } 
    153     else if (parser->pointer == parser->buffer_end) { 
    154         parser->pointer = parser->buffer; 
    155         parser->buffer_end = parser->buffer; 
     165    if (parser->buffer.start < parser->buffer.pointer 
     166            && parser->buffer.pointer < parser->buffer.last) { 
     167        size_t size = parser->buffer.last - parser->buffer.pointer; 
     168        memmove(parser->buffer.start, parser->buffer.pointer, size); 
     169        parser->buffer.pointer = parser->buffer.start; 
     170        parser->buffer.last = parser->buffer.start + size; 
     171    } 
     172    else if (parser->buffer.pointer == parser->buffer.last) { 
     173        parser->buffer.pointer = parser->buffer.start; 
     174        parser->buffer.last = parser->buffer.start; 
    156175    } 
    157176 
     
    166185        /* Decode the raw buffer. */ 
    167186 
    168         while (parser->raw_unread) 
     187        while (parser->raw_buffer.pointer != parser->raw_buffer.last) 
    169188        { 
    170189            unsigned int value, value2; 
     
    173192            unsigned int width; 
    174193            int k, low, high; 
     194            int raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer; 
    175195 
    176196            /* Decode the next character. */ 
     
    202222                    /* Determine the length of the UTF-8 sequence. */ 
    203223 
    204                     octet = parser->raw_pointer[0]; 
     224                    octet = parser->raw_buffer.pointer[0]; 
    205225                    width = (octet & 0x80) == 0x00 ? 1 : 
    206226                            (octet & 0xE0) == 0xC0 ? 2 : 
     
    217237                    /* Check if the raw buffer contains an incomplete character. */ 
    218238 
    219                     if (width > parser->raw_unread) { 
     239                    if (width > raw_unread) { 
    220240                        if (parser->eof) { 
    221241                            return yaml_parser_set_reader_error(parser, 
     
    238258                    for (k = 1; k < width; k ++) 
    239259                    { 
    240                         octet = parser->raw_pointer[k]; 
     260                        octet = parser->raw_buffer.pointer[k]; 
    241261 
    242262                        /* Check if the octet is valid. */ 
     
    305325                    /* Check for incomplete UTF-16 character. */ 
    306326 
    307                     if (parser->raw_unread < 2) { 
     327                    if (raw_unread < 2) { 
    308328                        if (parser->eof) { 
    309329                            return yaml_parser_set_reader_error(parser, 
     
    317337                    /* Get the character. */ 
    318338 
    319                     value = parser->raw_pointer[low] 
    320                         + (parser->raw_pointer[high] << 8); 
     339                    value = parser->raw_buffer.pointer[low] 
     340                        + (parser->raw_buffer.pointer[high] << 8); 
    321341 
    322342                    /* Check for unexpected low surrogate area. */ 
     
    335355                        /* Check for incomplete surrogate pair. */ 
    336356 
    337                         if (parser->raw_unread < 4) { 
     357                        if (raw_unread < 4) { 
    338358                            if (parser->eof) { 
    339359                                return yaml_parser_set_reader_error(parser, 
     
    347367                        /* Get the next character. */ 
    348368 
    349                         unsigned int value2 = parser->raw_pointer[low+2] 
    350                             + (parser->raw_pointer[high+2] << 8); 
     369                        unsigned int value2 = parser->raw_buffer.pointer[low+2] 
     370                            + (parser->raw_buffer.pointer[high+2] << 8); 
    351371 
    352372                        /* Check for a low surrogate area. */ 
     
    391411            /* Move the raw pointers. */ 
    392412 
    393             parser->raw_pointer += width; 
    394             parser->raw_unread -= width; 
     413            parser->raw_buffer.pointer += width; 
    395414            parser->offset += width; 
    396415 
     
    399418            /* 0000 0000-0000 007F -> 0xxxxxxx */ 
    400419            if (value <= 0x7F) { 
    401                 *(parser->buffer_end++) = value; 
     420                *(parser->buffer.last++) = value; 
    402421            } 
    403422            /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */ 
    404423            else if (value <= 0x7FF) { 
    405                 *(parser->buffer_end++) = 0xC0 + (value >> 6); 
    406                 *(parser->buffer_end++) = 0x80 + (value & 0x3F); 
     424                *(parser->buffer.last++) = 0xC0 + (value >> 6); 
     425                *(parser->buffer.last++) = 0x80 + (value & 0x3F); 
    407426            } 
    408427            /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */ 
    409428            else if (value <= 0xFFFF) { 
    410                 *(parser->buffer_end++) = 0xE0 + (value >> 12); 
    411                 *(parser->buffer_end++) = 0x80 + ((value >> 6) & 0x3F); 
    412                 *(parser->buffer_end++) = 0x80 + (value & 0x3F); 
     429                *(parser->buffer.last++) = 0xE0 + (value >> 12); 
     430                *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); 
     431                *(parser->buffer.last++) = 0x80 + (value & 0x3F); 
    413432            } 
    414433            /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 
    415434            else { 
    416                 *(parser->buffer_end++) = 0xF0 + (value >> 18); 
    417                 *(parser->buffer_end++) = 0x80 + ((value >> 12) & 0x3F); 
    418                 *(parser->buffer_end++) = 0x80 + ((value >> 6) & 0x3F); 
    419                 *(parser->buffer_end++) = 0x80 + (value & 0x3F); 
     435                *(parser->buffer.last++) = 0xF0 + (value >> 18); 
     436                *(parser->buffer.last++) = 0x80 + ((value >> 12) & 0x3F); 
     437                *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); 
     438                *(parser->buffer.last++) = 0x80 + (value & 0x3F); 
    420439            } 
    421440 
     
    426445 
    427446        if (parser->eof) { 
    428             *(parser->buffer_end++) = '\0'; 
     447            *(parser->buffer.last++) = '\0'; 
    429448            parser->unread ++; 
    430449            return 1; 
  • libyaml/trunk/src/scanner.c

    r203 r208  
    476476 */ 
    477477 
    478 #if HAVE_CONFIG_H 
    479 #include <config.h> 
    480 #endif 
    481  
    482 #include <yaml.h> 
    483  
    484 #include <assert.h> 
     478#include "yaml_private.h" 
    485479 
    486480/* 
     
    489483 */ 
    490484 
    491 #define UPDATE(parser,length)   \ 
    492     (parser->unread >= (length) \ 
    493         ? 1                     \ 
     485#define CACHE(parser,length)                                                    \ 
     486    (parser->unread >= (length)                                                 \ 
     487        ? 1                                                                     \ 
    494488        : yaml_parser_update_buffer(parser, (length))) 
    495489 
     
    498492 */ 
    499493 
    500 #define CHECK_AT(parser,octet,offset)   \ 
    501     (parser->pointer[offset] == (yaml_char_t)(octet)) 
     494#define CHECK_AT(parser,octet,offset)                                           \ 
     495    (parser->buffer.pointer[offset] == (yaml_char_t)(octet)) 
    502496 
    503497/* 
     
    512506 */ 
    513507 
    514 #define IS_ALPHA_AT(parser,offset)  \ 
    515      ((parser->pointer[offset] >= (yaml_char_t) '0' &&      \ 
    516        parser->pointer[offset] <= (yaml_char_t) '9') ||     \ 
    517       (parser->pointer[offset] >= (yaml_char_t) 'A' &&      \ 
    518        parser->pointer[offset] <= (yaml_char_t) 'Z') ||     \ 
    519       (parser->pointer[offset] >= (yaml_char_t) 'a' &&      \ 
    520        parser->pointer[offset] <= (yaml_char_t) 'z') ||     \ 
    521       parser->pointer[offset] == '_' ||                     \ 
    522       parser->pointer[offset] == '-') 
     508#define IS_ALPHA_AT(parser,offset)                                              \ 
     509     ((parser->buffer.pointer[offset] >= (yaml_char_t) '0' &&                   \ 
     510       parser->buffer.pointer[offset] <= (yaml_char_t) '9') ||                  \ 
     511      (parser->buffer.pointer[offset] >= (yaml_char_t) 'A' &&                   \ 
     512       parser->buffer.pointer[offset] <= (yaml_char_t) 'Z') ||                  \ 
     513      (parser->buffer.pointer[offset] >= (yaml_char_t) 'a' &&                   \ 
     514       parser->buffer.pointer[offset] <= (yaml_char_t) 'z') ||                  \ 
     515      parser->buffer.pointer[offset] == '_' ||                                  \ 
     516      parser->buffer.pointer[offset] == '-') 
    523517 
    524518#define IS_ALPHA(parser)    IS_ALPHA_AT(parser,0) 
     
    528522 */ 
    529523 
    530 #define IS_DIGIT_AT(parser,offset)  \ 
    531      ((parser->pointer[offset] >= (yaml_char_t) '0' &&      \ 
    532        parser->pointer[offset] <= (yaml_char_t) '9')) 
     524#define IS_DIGIT_AT(parser,offset)                                              \ 
     525     ((parser->buffer.pointer[offset] >= (yaml_char_t) '0' &&                   \ 
     526       parser->buffer.pointer[offset] <= (yaml_char_t) '9')) 
    533527 
    534528#define IS_DIGIT(parser)    IS_DIGIT_AT(parser,0) 
     
    538532 */ 
    539533 
    540 #define AS_DIGIT_AT(parser,offset)  \ 
    541      (parser->pointer[offset] - (yaml_char_t) '0') 
     534#define AS_DIGIT_AT(parser,offset)                                              \ 
     535     (parser->buffer.pointer[offset] - (yaml_char_t) '0') 
    542536 
    543537#define AS_DIGIT(parser)    AS_DIGIT_AT(parser,0) 
     
    547541 */ 
    548542 
    549 #define IS_HEX_AT(parser,offset)    \ 
    550      ((parser->pointer[offset] >= (yaml_char_t) '0' &&      \ 
    551        parser->pointer[offset] <= (yaml_char_t) '9') ||     \ 
    552       (parser->pointer[offset] >= (yaml_char_t) 'A' &&      \ 
    553        parser->pointer[offset] <= (yaml_char_t) 'F') ||     \ 
    554       (parser->pointer[offset] >= (yaml_char_t) 'a' &&      \ 
    555        parser->pointer[offset] <= (yaml_char_t) 'f')) 
     543#define IS_HEX_AT(parser,offset)                                                \ 
     544     ((parser->buffer.pointer[offset] >= (yaml_char_t) '0' &&                   \ 
     545       parser->buffer.pointer[offset] <= (yaml_char_t) '9') ||                  \ 
     546      (parser->buffer.pointer[offset] >= (yaml_char_t) 'A' &&                   \ 
     547       parser->buffer.pointer[offset] <= (yaml_char_t) 'F') ||                  \ 
     548      (parser->buffer.pointer[offset] >= (yaml_char_t) 'a' &&                   \ 
     549       parser->buffer.pointer[offset] <= (yaml_char_t) 'f')) 
    556550 
    557551#define IS_HEX(parser)    IS_HEX_AT(parser,0) 
     
    561555 */ 
    562556 
    563 #define AS_HEX_AT(parser,offset)    \ 
    564       ((parser->pointer[offset] >= (yaml_char_t) 'A' &&     \ 
    565         parser->pointer[offset] <= (yaml_char_t) 'F') ?     \ 
    566        (parser->pointer[offset] - (yaml_char_t) 'A' + 10) : \ 
    567        (parser->pointer[offset] >= (yaml_char_t) 'a' &&     \ 
    568         parser->pointer[offset] <= (yaml_char_t) 'f') ?     \ 
    569        (parser->pointer[offset] - (yaml_char_t) 'a' + 10) : \ 
    570        (parser->pointer[offset] - (yaml_char_t) '0')) 
     557#define AS_HEX_AT(parser,offset)                                                \ 
     558      ((parser->buffer.pointer[offset] >= (yaml_char_t) 'A' &&                  \ 
     559        parser->buffer.pointer[offset] <= (yaml_char_t) 'F') ?                  \ 
     560       (parser->buffer.pointer[offset] - (yaml_char_t) 'A' + 10) :              \ 
     561       (parser->buffer.pointer[offset] >= (yaml_char_t) 'a' &&                  \ 
     562        parser->buffer.pointer[offset] <= (yaml_char_t) 'f') ?                  \ 
     563       (parser->buffer.pointer[offset] - (yaml_char_t) 'a' + 10) :              \ 
     564       (parser->buffer.pointer[offset] - (yaml_char_t) '0')) 
    571565  
    572566#define AS_HEX(parser)  AS_HEX_AT(parser,0) 
     
    584578 */ 
    585579 
    586 #define IS_BOM_AT(parser,offset)                                    \ 
    587      (CHECK_AT(parser,'\xEF',(offset))                              \ 
    588       && CHECK_AT(parser,'\xBB',(offset)+1)                         \ 
     580#define IS_BOM_AT(parser,offset)                                                \ 
     581     (CHECK_AT(parser,'\xEF',(offset))                                          \ 
     582      && CHECK_AT(parser,'\xBB',(offset)+1)                                     \ 
    589583      && CHECK_AT(parser,'\xBF',(offset)+1))    /* BOM (#xFEFF) */ 
    590584 
     
    620614 */ 
    621615 
    622 #define IS_BREAK_AT(parser,offset)                                      \ 
    623     (CHECK_AT(parser,'\r',(offset))                 /* CR (#xD)*/       \ 
    624      || CHECK_AT(parser,'\n',(offset))              /* LF (#xA) */      \ 
    625      || (CHECK_AT(parser,'\xC2',(offset))                               \ 
    626          && CHECK_AT(parser,'\x85',(offset)+1))     /* NEL (#x85) */    \ 
    627      || (CHECK_AT(parser,'\xE2',(offset))                               \ 
    628          && CHECK_AT(parser,'\x80',(offset)+1)                          \ 
    629          && CHECK_AT(parser,'\xA8',(offset)+2))     /* LS (#x2028) */   \ 
    630      || (CHECK_AT(parser,'\xE2',(offset))                               \ 
    631          && CHECK_AT(parser,'\x80',(offset)+1)                          \ 
     616#define IS_BREAK_AT(parser,offset)                                              \ 
     617    (CHECK_AT(parser,'\r',(offset))                 /* CR (#xD)*/               \ 
     618     || CHECK_AT(parser,'\n',(offset))              /* LF (#xA) */              \ 
     619     || (CHECK_AT(parser,'\xC2',(offset))                                       \ 
     620         && CHECK_AT(parser,'\x85',(offset)+1))     /* NEL (#x85) */            \ 
     621     || (CHECK_AT(parser,'\xE2',(offset))                                       \ 
     622         && CHECK_AT(parser,'\x80',(offset)+1)                                  \ 
     623         && CHECK_AT(parser,'\xA8',(offset)+2))     /* LS (#x2028) */           \ 
     624     || (CHECK_AT(parser,'\xE2',(offset))                                       \ 
     625         && CHECK_AT(parser,'\x80',(offset)+1)                                  \ 
    632626         && CHECK_AT(parser,'\xA9',(offset)+2)))    /* PS (#x2029) */ 
    633627 
    634628#define IS_BREAK(parser)    IS_BREAK_AT(parser,0) 
    635629 
    636 #define IS_CRLF_AT(parser,offset) \ 
     630#define IS_CRLF_AT(parser,offset)                                               \ 
    637631     (CHECK_AT(parser,'\r',(offset)) && CHECK_AT(parser,'\n',(offset)+1)) 
    638632 
     
    643637 */ 
    644638 
    645 #define IS_BREAKZ_AT(parser,offset) \ 
     639#define IS_BREAKZ_AT(parser,offset)                                             \ 
    646640    (IS_BREAK_AT(parser,(offset)) || IS_Z_AT(parser,(offset))) 
    647641 
     
    652646 */ 
    653647 
    654 #define IS_SPACEZ_AT(parser,offset) \ 
     648#define IS_SPACEZ_AT(parser,offset)                                             \ 
    655649    (IS_SPACE_AT(parser,(offset)) || IS_BREAKZ_AT(parser,(offset))) 
    656650 
     
    661655 */ 
    662656 
    663 #define IS_BLANKZ_AT(parser,offset) \ 
     657#define IS_BLANKZ_AT(parser,offset)                                             \ 
    664658    (IS_BLANK_AT(parser,(offset)) || IS_BREAKZ_AT(parser,(offset))) 
    665659 
     
    670664 */ 
    671665 
    672 #define WIDTH_AT(parser,offset)                         \ 
    673      ((parser->pointer[(offset)] & 0x80) == 0x00 ? 1 :  \ 
    674       (parser->pointer[(offset)] & 0xE0) == 0xC0 ? 2 :  \ 
    675       (parser->pointer[(offset)] & 0xF0) == 0xE0 ? 3 :  \ 
    676       (parser->pointer[(offset)] & 0xF8) == 0xF0 ? 4 : 0) 
     666#define WIDTH_AT(parser,offset)                                                 \ 
     667     ((parser->buffer.pointer[offset] & 0x80) == 0x00 ? 1 :                     \ 
     668      (parser->buffer.pointer[offset] & 0xE0) == 0xC0 ? 2 :                     \ 
     669      (parser->buffer.pointer[offset] & 0xF0) == 0xE0 ? 3 :                     \ 
     670      (parser->buffer.pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) 
    677671 
    678672#define WIDTH(parser)   WIDTH_AT(parser,0) 
     
    682676 */ 
    683677 
    684 #define FORWARD(parser)                             \ 
    685      (parser->index ++,                             \ 
    686       parser->column ++,                            \ 
    687       parser->unread --,                            \ 
    688       parser->pointer += WIDTH(parser)) 
    689  
    690 #define FORWARD_LINE(parser)                        \ 
    691      (IS_CRLF(parser) ?                             \ 
    692       (parser->index += 2,                          \ 
    693        parser->column = 0,                          \ 
    694        parser->line ++,                             \ 
    695        parser->unread -= 2,                         \ 
    696        parser->pointer += 2) :                      \ 
    697       IS_BREAK(parser) ?                            \ 
    698       (parser->index ++,                            \ 
    699        parser->column = 0,                          \ 
    700        parser->line ++,                             \ 
    701        parser->unread --,                           \ 
    702        parser->pointer += WIDTH(parser)) : 0) 
    703  
    704 /* 
    705  * Resize a string if needed. 
    706  */ 
    707  
    708 #define RESIZE(parser,string)   \ 
    709     ((string).pointer-(string).buffer+5 < (string).size ? 1 :   \ 
    710      yaml_parser_resize_string(parser, &(string))) 
     678#define SKIP(parser)                                                            \ 
     679     (parser->mark.index ++,                                                    \ 
     680      parser->mark.column ++,                                                   \ 
     681      parser->unread --,                                                        \ 
     682      parser->buffer.pointer += WIDTH(parser)) 
     683 
     684#define SKIP_LINE(parser)                                                       \ 
     685     (IS_CRLF(parser) ?                                                         \ 
     686      (parser->mark.index += 2,                                                 \ 
     687       parser->mark.column = 0,                                                 \ 
     688       parser->mark.line ++,                                                    \ 
     689       parser->unread -= 2,                                                     \ 
     690       parser->buffer.pointer += 2) :                                           \ 
     691      IS_BREAK(parser) ?                                                        \ 
     692      (parser->mark.index ++,                                                   \ 
     693       parser->mark.column = 0,                                                 \ 
     694       parser->mark.line ++,                                                    \ 
     695       parser->unread --,                                                       \ 
     696       parser->buffer.pointer += WIDTH(parser)) : 0) 
    711697 
    712698/* 
     
    714700 */ 
    715701 
    716 #define COPY(parser,string)     \ 
    717      (((*parser->pointer & 0x80) == 0x00 ?                  \ 
    718        (*((string).pointer++) = *(parser->pointer++)) :     \ 
    719        (*parser->pointer & 0xE0) == 0xC0 ?                  \ 
    720        (*((string).pointer++) = *(parser->pointer++),       \ 
    721         *((string).pointer++) = *(parser->pointer++)) :     \ 
    722        (*parser->pointer & 0xF0) == 0xE0 ?                  \ 
    723        (*((string).pointer++) = *(parser->pointer++),       \ 
    724         *((string).pointer++) = *(parser->pointer++),       \ 
    725         *((string).pointer++) = *(parser->pointer++)) :     \ 
    726        (*parser->pointer & 0xF8) == 0xF0 ?                  \ 
    727        (*((string).pointer++) = *(parser->pointer++),       \ 
    728         *((string).pointer++) = *(parser->pointer++),       \ 
    729         *((string).pointer++) = *(parser->pointer++),       \ 
    730         *((string).pointer++) = *(parser->pointer++)) : 0), \ 
    731       parser->index ++,                                     \ 
    732       parser->column ++,                                    \ 
    733       parser->unread --) 
     702#define READ(parser,string)                                                     \ 
     703     (STRING_EXTEND(parser,string) ?                                            \ 
     704         (((*parser->buffer.pointer & 0x80) == 0x00 ?                           \ 
     705           (*((string).pointer++) = *(parser->buffer.pointer++)) :              \ 
     706           (*parser->buffer.pointer & 0xE0) == 0xC0 ?                           \ 
     707           (*((string).pointer++) = *(parser->buffer.pointer++),                \ 
     708            *((string).pointer++) = *(parser->buffer.pointer++)) :              \ 
     709           (*parser->buffer.pointer & 0xF0) == 0xE0 ?                           \ 
     710           (*((string).pointer++) = *(parser->buffer.pointer++),                \ 
     711            *((string).pointer++) = *(parser->buffer.pointer++),                \ 
     712            *((string).pointer++) = *(parser->buffer.pointer++)) :              \ 
     713           (*parser->buffer.pointer & 0xF8) == 0xF0 ?                           \ 
     714           (*((string).pointer++) = *(parser->buffer.pointer++),                \ 
     715            *((string).pointer++) = *(parser->buffer.pointer++),                \ 
     716            *((string).pointer++) = *(parser->buffer.pointer++),                \ 
     717            *((string).pointer++) = *(parser->buffer.pointer++)) : 0),          \ 
     718          parser->mark.index ++,                                                \ 
     719          parser->mark.column ++,                                               \ 
     720          parser->unread --,                                                    \ 
     721          1) : 0) 
    734722 
    735723/* 
     
    737725 */ 
    738726 
    739 #define COPY_LINE(parser,string)    \ 
    740     ((CHECK_AT(parser,'\r',0) && CHECK_AT(parser,'\n',1)) ? /* CR LF -> LF */   \ 
     727#define READ_LINE(parser,string)                                                \ 
     728    (STRING_EXTEND(parser,string) ?                                             \ 
     729    (((CHECK_AT(parser,'\r',0) && CHECK_AT(parser,'\n',1)) ? /* CR LF -> LF */  \ 
    741730     (*((string).pointer++) = (yaml_char_t) '\n',                               \ 
    742       parser->pointer += 2,                                                     \ 
    743       parser->index += 2,                                                       \ 
    744       parser->column = 0,                                                       \ 
    745       parser->line ++,                                                          \ 
     731      parser->buffer.pointer += 2,                                              \ 
     732      parser->mark.index += 2,                                                  \ 
     733      parser->mark.column = 0,                                                  \ 
     734      parser->mark.line ++,                                                     \ 
    746735      parser->unread -= 2) :                                                    \ 
    747736     (CHECK_AT(parser,'\r',0) || CHECK_AT(parser,'\n',0)) ? /* CR|LF -> LF */   \ 
    748737     (*((string).pointer++) = (yaml_char_t) '\n',                               \ 
    749       parser->pointer ++,                                                       \ 
    750       parser->index ++,                                                         \ 
    751       parser->column = 0,                                                       \ 
    752       parser->line ++,                                                          \ 
     738      parser->buffer.pointer ++,                                                \ 
     739      parser->mark.index ++,                                                    \ 
     740      parser->mark.column = 0,                                                  \ 
     741      parser->mark.line ++,                                                     \ 
    753742      parser->unread --) :                                                      \ 
    754743     (CHECK_AT(parser,'\xC2',0) && CHECK_AT(parser,'\x85',1)) ? /* NEL -> LF */ \ 
    755744     (*((string).pointer++) = (yaml_char_t) '\n',                               \ 
    756       parser->pointer += 2,                                                     \ 
    757       parser->index ++,                                                         \ 
    758       parser->column = 0,                                                       \ 
    759       parser->line ++,                                                          \ 
     745      parser->buffer.pointer += 2,                                              \ 
     746      parser->mark.index ++,                                                    \ 
     747      parser->mark.column = 0,                                                  \ 
     748      parser->mark.line ++,                                                     \ 
    760749      parser->unread --) :                                                      \ 
    761750     (CHECK_AT(parser,'\xE2',0) &&                                              \ 
     
    763752      (CHECK_AT(parser,'\xA8',2) ||                                             \ 
    764753       CHECK_AT(parser,'\xA9',2))) ?                    /* LS|PS -> LS|PS */    \ 
    765      (*((string).pointer++) = *(parser->pointer++),                             \ 
    766       *((string).pointer++) = *(parser->pointer++),                             \ 
    767       *((string).pointer++) = *(parser->pointer++),                             \ 
    768       parser->index ++,                                                         \ 
    769       parser->column = 0,                                                       \ 
    770       parser->line ++,                                                          \ 
    771       parser->unread --) : 0) 
    772  
    773 /* 
    774  * Append a string to another string and clear the former string. 
    775  */ 
    776  
    777 #define JOIN(parser,head_string,tail_string)    \ 
    778     (yaml_parser_join_string(parser, &(head_string), &(tail_string)) && \ 
    779      yaml_parser_clear_string(parser, &(tail_string))) 
     754     (*((string).pointer++) = *(parser->buffer.pointer++),                      \ 
     755      *((string).pointer++) = *(parser->buffer.pointer++),                      \ 
     756      *((string).pointer++) = *(parser->buffer.pointer++),                      \ 
     757      parser->mark.index ++,                                                    \ 
     758      parser->mark.column = 0,                                                  \ 
     759      parser->mark.line ++,                                                     \ 
     760      parser->unread --) : 0),                                                  \ 
     761    1) : 0) 
     762 
     763/* 
     764 * Token initializers. 
     765 */ 
     766 
     767#define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark)            \ 
     768    (memset(&(token), 0, sizeof(yaml_token_t)),                                 \ 
     769     (token).type = (token_type),                                               \ 
     770     (token).start_mark = (token_start_mark),                                   \ 
     771     (token).end_mark = (token_end_mark)) 
     772 
     773#define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark)       \ 
     774    (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)),       \ 
     775     (token).data.stream_start.encoding = (token_encoding)) 
     776 
     777#define STREAM_END_TOKEN_INIT(token,start_mark,end_mark)                        \ 
     778    (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark))) 
     779 
     780#define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark)                 \ 
     781    (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)),              \ 
     782     (token).data.alias.value = (token_value)) 
     783 
     784#define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark)                \ 
     785    (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)),             \ 
     786     (token).data.anchor.value = (token_value)) 
     787 
     788#define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark)     \ 
     789    (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)),                \ 
     790     (token).data.tag.handle = (token_handle),                                  \ 
     791     (token).data.tag.suffix = (token_suffix)) 
     792 
     793#define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark)   \ 
     794    (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)),             \ 
     795     (token).data.scalar.value = (token_value),                                 \ 
     796     (token).data.scalar.length = (token_length),                               \ 
     797     (token).data.scalar.style = (token_style)) 
     798 
     799#define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark)     \ 
     800    (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)),  \ 
     801     (token).data.version_directive.major = (token_major),                      \ 
     802     (token).data.version_directive.minor = (token_minor)) 
     803 
     804#define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark)       \ 
     805    (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)),      \ 
     806     (token).data.tag_directive.handle = (token_handle),                        \ 
     807     (token).data.tag_directive.prefix = (token_prefix)) 
    780808 
    781809/* 
     
    783811 */ 
    784812 
    785 YAML_DECLARE(yaml_token_t *) 
    786 yaml_parser_get_token(yaml_parser_t *parser); 
    787  
    788 YAML_DECLARE(yaml_token_t *) 
    789 yaml_parser_peek_token(yaml_parser_t *parser); 
     813YAML_DECLARE(int) 
     814yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token); 
    790815 
    791816/* 
     
    797822        yaml_mark_t context_mark, const char *problem); 
    798823 
    799 static yaml_mark_t 
    800 yaml_parser_get_mark(yaml_parser_t *parser); 
    801  
    802 /* 
    803  * Buffers and lists. 
    804  */ 
    805  
    806 typedef struct { 
    807     yaml_char_t *buffer; 
    808     yaml_char_t *pointer; 
    809     size_t size; 
    810 } yaml_string_t; 
    811  
    812 static yaml_string_t 
    813 yaml_parser_new_string(yaml_parser_t *parser); 
    814  
    815 static int 
    816 yaml_parser_resize_string(yaml_parser_t *parser, yaml_string_t *string); 
    817  
    818 static int 
    819 yaml_parser_join_string(yaml_parser_t *parser, 
    820         yaml_string_t *string1, yaml_string_t *string2); 
    821  
    822 static int 
    823 yaml_parser_clear_string(yaml_parser_t *parser, yaml_string_t *string); 
    824  
    825 static int 
    826 yaml_parser_resize_list(yaml_parser_t *parser, void **buffer, size_t *size, 
    827         size_t item_size); 
    828  
    829824/* 
    830825 * High-level token API. 
    831826 */ 
    832827 
    833 static int 
     828YAML_DECLARE(int) 
    834829yaml_parser_fetch_more_tokens(yaml_parser_t *parser); 
    835830 
     
    855850static int 
    856851yaml_parser_decrease_flow_level(yaml_parser_t *parser); 
    857  
    858 /* 
    859  * Token manipulation. 
    860  */ 
    861  
    862 static int 
    863 yaml_parser_append_token(yaml_parser_t *parser, yaml_token_t *token); 
    864  
    865 static int 
    866 yaml_parser_insert_token(yaml_parser_t *parser, 
    867         int number, yaml_token_t *token); 
    868852 
    869853/* 
     
    937921yaml_parser_scan_to_next_token(yaml_parser_t *parser); 
    938922 
    939 static yaml_token_t * 
    940 yaml_parser_scan_directive(yaml_parser_t *parser); 
     923static int 
     924yaml_parser_scan_directive(yaml_parser_t *parser, yaml_token_t *token); 
    941925 
    942926static int 
     
    956940        yaml_mark_t mark, yaml_char_t **handle, yaml_char_t **prefix); 
    957941 
    958 static yaml_token_t * 
    959 yaml_parser_scan_anchor(yaml_parser_t *parser, 
     942static int 
     943yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token, 
    960944        yaml_token_type_t type); 
    961945 
    962 static yaml_token_t * 
    963 yaml_parser_scan_tag(yaml_parser_t *parser); 
     946static int 
     947yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token); 
    964948 
    965949static int 
     
    975959        yaml_mark_t start_mark, yaml_string_t *string); 
    976960 
    977 static yaml_token_t * 
    978 yaml_parser_scan_block_scalar(yaml_parser_t *parser, int literal); 
     961static int 
     962yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token, 
     963        int literal); 
    979964 
    980965static int 
     
    983968        yaml_mark_t start_mark, yaml_mark_t *end_mark); 
    984969 
    985 static yaml_token_t * 
    986 yaml_parser_scan_flow_scalar(yaml_parser_t *parser, int single); 
    987  
    988 static yaml_token_t * 
    989 yaml_parser_scan_plain_scalar(yaml_parser_t *parser); 
    990  
    991 /* 
    992  * Get the next token and remove it from the tokens queue. 
    993  */ 
    994  
    995 YAML_DECLARE(yaml_token_t *) 
    996 yaml_parser_get_token(yaml_parser_t *parser) 
    997 { 
    998     yaml_token_t *token; 
    999  
     970static int 
     971yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token, 
     972        int single); 
     973 
     974static int 
     975yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token); 
     976 
     977/* 
     978 * Get the next token. 
     979 */ 
     980 
     981YAML_DECLARE(int) 
     982yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token) 
     983{ 
    1000984    assert(parser); /* Non-NULL parser object is expected. */ 
    1001     assert(!parser->stream_end_produced);   /* No tokens after STREAM-END. */ 
     985    assert(token);  /* Non-NULL token object is expected. */ 
     986 
     987    /* No tokens after STREAM-END or error. */ 
     988 
     989    if (parser->stream_end_produced || parser->error) { 
     990        memset(token, 0, sizeof(yaml_token_t)); 
     991 
     992        return 1; 
     993    } 
    1002994 
    1003995    /* Ensure that the tokens queue contains enough tokens. */ 
    1004996 
    1005     if (!yaml_parser_fetch_more_tokens(parser)) return NULL; 
     997    if (!parser->token_available) { 
     998        if (!yaml_parser_fetch_more_tokens(parser)) 
     999            return 0; 
     1000    } 
    10061001 
    10071002    /* Fetch the next token from the queue. */ 
    1008  
    1009     token = parser->tokens[parser->tokens_head]; 
    1010  
    1011     /* Move the queue head. */ 
    1012  
    1013     parser->tokens[parser->tokens_head++] = NULL; 
    1014  
    1015     parser->tokens_parsed++; 
     1003     
     1004    *token = DEQUEUE(parser, parser->tokens); 
     1005    parser->token_available = 0; 
     1006    parser->tokens_parsed ++; 
    10161007 
    10171008    if (token->type == YAML_STREAM_END_TOKEN) { 
    10181009        parser->stream_end_produced = 1; 
    10191010    } 
    1020  
    1021     return token; 
    1022 } 
    1023  
    1024 /* 
    1025  * Get the next token, but don't remove it from the queue. 
    1026  */ 
    1027  
    1028 YAML_DECLARE(yaml_token_t *) 
    1029 yaml_parser_peek_token(yaml_parser_t *parser) 
    1030 { 
    1031     assert(parser); /* Non-NULL parser object is expected. */ 
    1032     assert(!parser->stream_end_produced);   /* No tokens after STREAM-END. */ 
    1033  
    1034     /* Ensure that the tokens queue contains enough tokens. */ 
    1035  
    1036     if (!yaml_parser_fetch_more_tokens(parser)) return NULL; 
    1037  
    1038     /* Fetch the next token from the queue. */ 
    1039  
    1040     return parser->tokens[parser->tokens_head]; 
    1041 } 
    1042  
    1043 /* 
    1044  * Create a new string. 
    1045  */ 
    1046  
    1047 static yaml_string_t 
    1048 yaml_parser_new_string(yaml_parser_t *parser) 
    1049 { 
    1050     yaml_string_t string = { NULL, NULL, 0 }; 
    1051  
    1052     string.buffer = yaml_malloc(YAML_DEFAULT_SIZE); 
    1053     if (!string.buffer) { 
    1054         parser->error = YAML_MEMORY_ERROR; 
    1055         return string; 
    1056     } 
    1057  
    1058     memset(string.buffer, 0, YAML_DEFAULT_SIZE); 
    1059     string.pointer = string.buffer; 
    1060     string.size = YAML_DEFAULT_SIZE; 
    1061  
    1062     return string; 
    1063 } 
    1064  
    1065 /* 
    1066  * Double the size of a string. 
    1067  */ 
    1068  
    1069 static int 
    1070 yaml_parser_resize_string(yaml_parser_t *parser, yaml_string_t *string) 
    1071 { 
    1072     yaml_char_t *new_buffer = yaml_realloc(string->buffer, string->size*2); 
    1073  
    1074     if (!new_buffer) { 
    1075         yaml_free(string->buffer); 
    1076         string->buffer = NULL; 
    1077         string->pointer = NULL; 
    1078         string->size = 0; 
    1079         parser->error = YAML_MEMORY_ERROR; 
    1080         return 0; 
    1081     } 
    1082  
    1083     memset(new_buffer+string->size, 0, string->size); 
    1084  
    1085     string->pointer = new_buffer + (string->pointer-string->buffer); 
    1086     string->buffer = new_buffer; 
    1087     string->size *= 2; 
    1088  
    1089     return 1; 
    1090 } 
    1091  
    1092 /* 
    1093  * Append a string to another string. 
    1094  */ 
    1095  
    1096 static int 
    1097 yaml_parser_join_string(yaml_parser_t *parser, 
    1098         yaml_string_t *string1, yaml_string_t *string2) 
    1099 { 
    1100     if (string2->buffer == string2->pointer) return 1; 
    1101  
    1102     while (string1->pointer - string1->buffer + string2->pointer - string2->buffer + 1 
    1103             > string1->size) { 
    1104         if (!yaml_parser_resize_string(parser, string1)) return 0; 
    1105     } 
    1106  
    1107     memcpy(string1->pointer, string2->buffer, string2->pointer-string2->buffer); 
    1108     string1->pointer += string2->pointer-string2->buffer; 
    1109  
    1110     return 1; 
    1111 } 
    1112  
    1113 /* 
    1114  * Fill the string with NULs and move the pointer to the beginning. 
    1115  */ 
    1116  
    1117 static int 
    1118 yaml_parser_clear_string(yaml_parser_t *parser, yaml_string_t *string) 
    1119 { 
    1120     if (string->buffer == string->pointer) return 1; 
    1121  
    1122     memset(string->buffer, 0, string->pointer-string->buffer); 
    1123  
    1124     string->pointer = string->buffer; 
    1125  
    1126     return 1; 
    1127 } 
    1128  
    1129 /* 
    1130  * Double a list. 
    1131  */ 
    1132  
    1133 static int 
    1134 yaml_parser_resize_list(yaml_parser_t *parser, void **buffer, size_t *size, 
    1135         size_t item_size) 
    1136 { 
    1137     void *new_buffer = yaml_realloc(*buffer, item_size*(*size)*2); 
    1138  
    1139     if (!new_buffer) { 
    1140         parser->error = YAML_MEMORY_ERROR; 
    1141         return 0; 
    1142     } 
    1143  
    1144     memset(new_buffer+item_size*(*size), 0, item_size*(*size)); 
    1145  
    1146     *buffer = new_buffer; 
    1147     *size *= 2; 
    11481011 
    11491012    return 1; 
     
    11621025    parser->context_mark = context_mark; 
    11631026    parser->problem = problem; 
    1164     parser->problem_mark = yaml_parser_get_mark(parser); 
     1027    parser->problem_mark = parser->mark; 
    11651028 
    11661029    return 0; 
    11671030} 
    1168  
    1169 /* 
    1170  * Get the mark for the current buffer position. 
    1171  */ 
    1172  
    1173 static yaml_mark_t 
    1174 yaml_parser_get_mark(yaml_parser_t *parser) 
    1175 { 
    1176     yaml_mark_t mark = { parser->index, parser->line, parser->column }; 
    1177  
    1178     return mark; 
    1179 } 
    1180  
    11811031 
    11821032/* 
     
    11851035 */ 
    11861036 
    1187 static int 
     1037YAML_DECLARE(int) 
    11881038yaml_parser_fetch_more_tokens(yaml_parser_t *parser) 
    11891039{ 
    11901040    int need_more_tokens; 
    1191     int k; 
    11921041 
    11931042    /* While we need more tokens to fetch, do it. */ 
     
    12011050        need_more_tokens = 0; 
    12021051 
    1203         if (parser->tokens_head == parser->tokens_tail) 
     1052        if (parser->tokens.head == parser->tokens.tail) 
    12041053        { 
    12051054            /* Queue is empty. */ 
     
    12091058        else 
    12101059        { 
     1060            yaml_simple_key_t *simple_key; 
     1061 
    12111062            /* Check if any potential simple key may occupy the head position. */ 
    12121063 
     
    12141065                return 0; 
    12151066 
    1216             for (k = 0; k <= parser->flow_level; k++) { 
    1217                 yaml_simple_key_t *simple_key = parser->simple_keys[k]; 
    1218                 if (simple_key 
    1219                         && (simple_key->token_number == parser->tokens_parsed)) { 
     1067            for (simple_key = parser->simple_keys.start; 
     1068                    simple_key != parser->simple_keys.top; simple_key++) { 
     1069                if (simple_key->possible 
     1070                        && simple_key->token_number == parser->tokens_parsed) { 
    12201071                    need_more_tokens = 1; 
    12211072                    break; 
     
    12351086    } 
    12361087 
     1088    parser->token_available = 1; 
     1089 
    12371090    return 1; 
    12381091} 
     
    12471100    /* Ensure that the buffer is initialized. */ 
    12481101 
    1249     if (!UPDATE(parser, 1)) 
     1102    if (!CACHE(parser, 1)) 
    12501103        return 0; 
    12511104 
     
    12671120    /* Check the indentation level against the current column. */ 
    12681121 
    1269     if (!yaml_parser_unroll_indent(parser, parser->column)) 
     1122    if (!yaml_parser_unroll_indent(parser, parser->mark.column)) 
    12701123        return 0; 
    12711124 
     
    12751128     */ 
    12761129 
    1277     if (!UPDATE(parser, 4)) 
     1130    if (!CACHE(parser, 4)) 
    12781131        return 0; 
    12791132 
     
    12851138    /* Is it a directive? */ 
    12861139 
    1287     if (parser->column == 0 && CHECK(parser, '%')) 
     1140    if (parser->mark.column == 0 && CHECK(parser, '%')) 
    12881141        return yaml_parser_fetch_directive(parser); 
    12891142 
    12901143    /* Is it the document start indicator? */ 
    12911144 
    1292     if (parser->column == 0 
     1145    if (parser->mark.column == 0 
    12931146            && CHECK_AT(parser, '-', 0) 
    12941147            && CHECK_AT(parser, '-', 1) 
     
    13001153    /* Is it the document end indicator? */ 
    13011154 
    1302     if (parser->column == 0 
     1155    if (parser->mark.column == 0 
    13031156            && CHECK_AT(parser, '.', 0) 
    13041157            && CHECK_AT(parser, '.', 1) 
     
    14221275     */ 
    14231276 
    1424     return yaml_parser_set_scanner_error(parser, "while scanning for the next token", 
    1425             yaml_parser_get_mark(parser), "found character that cannot start any token"); 
     1277    return yaml_parser_set_scanner_error(parser, 
     1278            "while scanning for the next token", parser->mark, 
     1279            "found character that cannot start any token"); 
    14261280} 
    14271281 
     
    14341288yaml_parser_stale_simple_keys(yaml_parser_t *parser) 
    14351289{ 
    1436     int level; 
     1290    yaml_simple_key_t *simple_key; 
    14371291 
    14381292    /* Check for a potential simple key for each flow level. */ 
    14391293 
    1440     for (level = 0; level <= parser->flow_level; level++) 
     1294    for (simple_key = parser->simple_keys.start; 
     1295            simple_key != parser->simple_keys.top; simple_key ++) 
    14411296    { 
    1442         yaml_simple_key_t *simple_key = parser->simple_keys[level]; 
    1443  
    14441297        /* 
    14451298         * The specification requires that a simple key 
     
    14491302         */ 
    14501303 
    1451         if (simple_key && (simple_key->line < parser->line || 
    1452                     simple_key->index+1024 < parser->index)) { 
     1304        if (simple_key->possible 
     1305                && (simple_key->mark.line < parser->mark.line 
     1306                    || simple_key->mark.index+1024 < parser->mark.index)) { 
    14531307 
    14541308            /* Check if the potential simple key to be removed is required. */ 
     
    14601314            } 
    14611315 
    1462             yaml_free(simple_key); 
    1463             parser->simple_keys[level] = NULL; 
     1316            simple_key->possible = 0; 
    14641317        } 
    14651318    } 
     
    14821335     */ 
    14831336 
    1484     int required = (!parser->flow_level && parser->indent == parser->column); 
     1337    int required = (!parser->flow_level 
     1338            && parser->indent == parser->mark.column); 
    14851339 
    14861340    /* 
     
    14971351    if (parser->simple_key_allowed) 
    14981352    { 
    1499         yaml_simple_key_t simple_key = { required, 
    1500             parser->tokens_parsed + parser->tokens_tail - parser->tokens_head, 
    1501             parser->index, parser->line, parser->column, 
    1502             yaml_parser_get_mark(parser) }; 
     1353        yaml_simple_key_t simple_key = { 1, required, 
     1354            parser->tokens_parsed + parser->tokens.tail - parser->tokens.head, 
     1355            parser->mark }; 
    15031356 
    15041357        if (!yaml_parser_remove_simple_key(parser)) return 0; 
    15051358 
    1506         parser->simple_keys[parser->flow_level] = 
    1507             yaml_malloc(sizeof(yaml_simple_key_t)); 
    1508         if (!parser->simple_keys[parser->flow_level]) { 
    1509             parser->error = YAML_MEMORY_ERROR; 
    1510             return 0; 
    1511         } 
    1512  
    1513         *(parser->simple_keys[parser->flow_level]) = simple_key; 
     1359        *(parser->simple_keys.top-1) = simple_key; 
    15141360    } 
    15151361 
     
    15241370yaml_parser_remove_simple_key(yaml_parser_t *parser) 
    15251371{ 
    1526     yaml_simple_key_t *simple_key = parser->simple_keys[parser->flow_level]; 
    1527  
    1528     if (simple_key) 
     1372    yaml_simple_key_t *simple_key = parser->simple_keys.top-1; 
     1373 
     1374    if (simple_key->possible) 
    15291375    { 
    15301376        /* If the key is required, it is an error. */ 
     
    15351381                    "could not found expected ':'"); 
    15361382        } 
    1537  
    1538         /* Remove the key from the list. */ 
    1539  
    1540         yaml_free(simple_key); 
    1541         parser->simple_keys[parser->flow_level] = NULL; 
    1542     } 
     1383    } 
     1384 
     1385    /* Remove the key from the stack. */ 
     1386 
     1387    simple_key->possible = 0; 
    15431388 
    15441389    return 1; 
     
    15521397yaml_parser_increase_flow_level(yaml_parser_t *parser) 
    15531398{ 
    1554     /* Check if we need to resize the list. */ 
    1555  
    1556     if (parser->flow_level == parser->simple_keys_size-1) { 
    1557         if (!yaml_parser_resize_list(parser, (void **)&parser->simple_keys, 
    1558                     &parser->simple_keys_size, sizeof(yaml_simple_key_t *))) 
    1559             return 0; 
    1560     } 
    1561  
    1562     /* Increase the flow level and reset the simple key. */ 
    1563  
    1564     parser->simple_keys[++parser->flow_level] = NULL; 
     1399    yaml_simple_key_t empty_simple_key = { 0, 0, 0, { 0, 0, 0 } }; 
     1400 
     1401    /* Reset the simple key on the next level. */ 
     1402 
     1403    if (!PUSH(parser, parser->simple_keys, empty_simple_key)) 
     1404        return 0; 
     1405 
     1406    /* Increase the flow level. */ 
     1407 
     1408    parser->flow_level++; 
    15651409 
    15661410    return 1; 
     
    15741418yaml_parser_decrease_flow_level(yaml_parser_t *parser) 
    15751419{ 
    1576     assert(parser->flow_level);                         /* Greater than 0. */ 
    1577     assert(!parser->simple_keys[parser->flow_level]);   /* Must be removed. */ 
    1578  
    1579     parser->flow_level --; 
    1580  
    1581     return 1; 
    1582 } 
    1583  
    1584 /* 
    1585  * Add a token to the tail of the tokens queue. 
    1586  */ 
    1587  
    1588 static int 
    1589 yaml_parser_append_token(yaml_parser_t *parser, yaml_token_t *token) 
    1590 { 
    1591     return yaml_parser_insert_token(parser, -1, token); 
    1592 } 
    1593  
    1594 /* 
    1595  * Insert the token into the tokens queue.  The number parameter is the 
    1596  * ordinal number of the token.  If the number is equal to -1, add the token 
    1597  * to the tail of the queue. 
    1598  */ 
    1599  
    1600 static int 
    1601 yaml_parser_insert_token(yaml_parser_t *parser, 
    1602         int number, yaml_token_t *token) 
    1603 { 
    1604     /* The index of the token in the queue. */ 
    1605  
    1606     int index = (number == -1) 
    1607             ? parser->tokens_tail - parser->tokens_head 
    1608             : number - parser->tokens_parsed; 
    1609  
    1610     assert(index >= 0 && index <= (parser->tokens_tail-parser->tokens_head)); 
    1611  
    1612     /* Check if we need to resize the queue. */ 
    1613  
    1614     if (parser->tokens_head == 0 && parser->tokens_tail == parser->tokens_size) { 
    1615         if (!yaml_parser_resize_list(parser, (void **)&parser->tokens, 
    1616                     &parser->tokens_size, sizeof(yaml_token_t *))) 
    1617             return 0; 
    1618     } 
    1619  
    1620     /* Check if we need to move the queue to the beginning of the buffer. */ 
    1621  
    1622     if (parser->tokens_tail == parser->tokens_size) 
    1623     { 
    1624         if (parser->tokens_head < parser->tokens_tail) { 
    1625             memmove(parser->tokens, parser->tokens+parser->tokens_head, 
    1626                     sizeof(yaml_token_t *)*(parser->tokens_tail-parser->tokens_head)); 
    1627         } 
    1628         parser->tokens_tail -= parser->tokens_head; 
    1629         parser->tokens_head = 0; 
    1630     } 
    1631  
    1632     /* Check if we need to free space within the queue. */ 
    1633  
    1634     if (index < (parser->tokens_tail-parser->tokens_head)) { 
    1635         memmove(parser->tokens+parser->tokens_head+index+1, 
    1636                 parser->tokens+parser->tokens_head+index, 
    1637                 sizeof(yaml_token_t *)*(parser->tokens_tail-parser->tokens_head-index)); 
    1638     } 
    1639  
    1640     /* Insert the token. */ 
    1641  
    1642     parser->tokens[parser->tokens_head+index] = token; 
    1643     parser->tokens_tail ++; 
     1420    if (parser->flow_level) { 
     1421        parser->flow_level --; 
     1422        POP(parser, parser->simple_keys); 
     1423    } 
    16441424 
    16451425    return 1; 
     
    16571437        int number, yaml_token_type_t type, yaml_mark_t mark) 
    16581438{ 
    1659     yaml_token_t *token; 
     1439    yaml_token_t token; 
    16601440 
    16611441    /* In the flow context, do nothing. */ 
     
    16661446    if (parser->indent < column) 
    16671447    { 
    1668         /* Check if we need to expand the indents stack. */ 
    1669  
    1670         if (parser->indents_length == parser->indents_size) { 
    1671             if (!yaml_parser_resize_list(parser, (void **)&parser->indents, 
    1672                         &parser->indents_size, sizeof(int))) 
    1673                 return 0; 
    1674         } 
    1675  
    16761448        /* 
    16771449         * Push the current indentation level to the stack and set the new 
     
    16791451         */ 
    16801452 
    1681         parser->indents[parser->indents_length++] = parser->indent; 
     1453        if (!PUSH(parser, parser->indents, parser->indent)) 
     1454            return 0; 
     1455 
    16821456        parser->indent = column; 
    16831457 
    1684         /* Create a token. */ 
    1685  
    1686         token = yaml_token_new(type, mark, mark); 
    1687         if (!token) { 
    1688             parser->error = YAML_MEMORY_ERROR; 
    1689             return 0; 
    1690         } 
    1691  
    1692         /* Insert the token into the queue. */ 
    1693  
    1694         if (!yaml_parser_insert_token(parser, number, token)) { 
    1695             yaml_token_delete(token); 
    1696             return 0; 
     1458        /* Create a token and insert it into the queue. */ 
     1459 
     1460        TOKEN_INIT(token, type, mark, mark); 
     1461 
     1462        if (number == -1) { 
     1463            if (!ENQUEUE(parser, parser->tokens, token)) 
     1464                return 0; 
     1465        } 
     1466        else { 
     1467            if (!QUEUE_INSERT(parser, 
     1468                        parser->tokens, number - parser->tokens_parsed, token)) 
     1469                return 0; 
    16971470        } 
    16981471    } 
     
    17111484yaml_parser_unroll_indent(yaml_parser_t *parser, int column) 
    17121485{ 
    1713     yaml_token_t *token; 
     1486    yaml_token_t token; 
    17141487 
    17151488    /* In the flow context, do nothing. */ 
     
    17221495    while (parser->indent > column) 
    17231496    { 
    1724         yaml_mark_t mark = yaml_parser_get_mark(parser); 
    1725  
    1726         /* Create a token. */ 
    1727  
    1728         token = yaml_token_new(YAML_BLOCK_END_TOKEN, mark, mark); 
    1729         if (!token) { 
    1730             parser->error = YAML_MEMORY_ERROR; 
     1497        /* Create a token and append it to the queue. */ 
     1498 
     1499        TOKEN_INIT(token, YAML_BLOCK_END_TOKEN, parser->mark, parser->mark); 
     1500 
     1501        if (!ENQUEUE(parser, parser->tokens, token)) 
    17311502            return 0; 
    1732         } 
    1733  
    1734         /* Append the token to the queue. */ 
    1735  
    1736         if (!yaml_parser_append_token(parser, token)) { 
    1737             yaml_token_delete(token); 
    1738             return 0; 
    1739         } 
    17401503 
    17411504        /* Pop the indentation level. */ 
    17421505 
    1743         assert(parser->indents_length);     /* Non-empty stack expected. */ 
    1744  
    1745         parser->indent = parser->indents[--parser->indents_length]; 
     1506        parser->indent = POP(parser, parser->indents); 
    17461507    } 
    17471508 
     
    17561517yaml_parser_fetch_stream_start(yaml_parser_t *parser) 
    17571518{ 
    1758     yaml_mark_t mark = yaml_parser_get_mark(parser); 
    1759     yaml_token_t *token; 
     1519    yaml_simple_key_t simple_key = { 0, 0, 0, { 0, 0, 0 } }; 
     1520    yaml_token_t token; 
    17601521 
    17611522    /* Set the initial indentation. */ 
     
    17631524    parser->indent = -1; 
    17641525 
     1526    /* Initialize the simple key stack. */ 
     1527 
     1528    if (!PUSH(parser, parser->simple_keys, simple_key)) 
     1529        return 0; 
     1530 
    17651531    /* A simple key is allowed at the beginning of the stream. */ 
    17661532 
     
    17711537    parser->stream_start_produced = 1; 
    17721538 
    1773     /* Create the STREAM-START token. */ 
    1774  
    1775     token = yaml_stream_start_token_new(parser->encoding, mark, mark); 
    1776     if (!token) { 
    1777         parser->error = YAML_MEMORY_ERROR; 
    1778         return 0; 
    1779     } 
     1539    /* Create the STREAM-START token and append it to the queue. */ 
     1540 
     1541    STREAM_START_TOKEN_INIT(token, parser->encoding, 
     1542            parser->mark, parser->mark); 
     1543 
     1544    if (!ENQUEUE(parser, parser->tokens, token)) 
     1545        return 0; 
     1546 
     1547    return 1; 
     1548} 
     1549 
     1550/* 
     1551 * Produce the STREAM-END token and shut down the scanner. 
     1552 */ 
     1553 
     1554static int 
     1555yaml_parser_fetch_stream_end(yaml_parser_t *parser) 
     1556{ 
     1557    yaml_token_t token; 
     1558 
     1559    /* Reset the indentation level. */ 
     1560 
     1561    if (!yaml_parser_unroll_indent(parser, -1)) 
     1562        return 0; 
     1563 
     1564    /* Reset simple keys. */ 
     1565 
     1566    if (!yaml_parser_remove_simple_key(parser)) 
     1567        return 0; 
     1568 
     1569    parser->simple_key_allowed = 0; 
     1570 
     1571    /* Create the STREAM-END token and append it to the queue. */ 
     1572 
     1573    STREAM_END_TOKEN_INIT(token, parser->mark, parser->mark); 
     1574 
     1575    if (!ENQUEUE(parser, parser->tokens, token)) 
     1576        return 0; 
     1577 
     1578    return 1; 
     1579} 
     1580 
     1581/* 
     1582 * Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token. 
     1583 */ 
     1584 
     1585static int 
     1586yaml_parser_fetch_directive(yaml_parser_t *parser) 
     1587{ 
     1588    yaml_token_t token; 
     1589 
     1590    /* Reset the indentation level. */ 
     1591 
     1592    if (!yaml_parser_unroll_indent(parser, -1)) 
     1593        return 0; 
     1594 
     1595    /* Reset simple keys. */ 
     1596 
     1597    if (!yaml_parser_remove_simple_key(parser)) 
     1598        return 0; 
     1599 
     1600    parser->simple_key_allowed = 0; 
     1601 
     1602    /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */ 
     1603 
     1604    if (!yaml_parser_scan_directive(parser, &token)) 
     1605        return 0; 
    17801606 
    17811607    /* Append the token to the queue. */ 
    17821608 
    1783     if (!yaml_parser_append_token(parser, token)) { 
    1784         yaml_token_delete(token); 
    1785         return 0; 
    1786     } 
    1787  
    1788     return 1; 
    1789 } 
    1790  
    1791 /* 
    1792  * Produce the STREAM-END token and shut down the scanner. 
    1793  */ 
    1794  
    1795 static int 
    1796 yaml_parser_fetch_stream_end(yaml_parser_t *parser) 
    1797 { 
    1798     yaml_mark_t mark = yaml_parser_get_mark(parser); 
    1799     yaml_token_t *token; 
    1800  
    1801     /* Reset the indentation level. */ 
    1802  
    1803     if (!yaml_parser_unroll_indent(parser, -1)) 
    1804         return 0; 
    1805  
    1806     /* Reset simple keys. */ 
    1807  
    1808     if (!yaml_parser_remove_simple_key(parser)) 
    1809         return 0; 
    1810  
    1811     parser->simple_key_allowed = 0; 
    1812  
    1813     /* Create the STREAM-END token. */ 
    1814  
    1815     token = yaml_stream_end_token_new(mark, mark); 
    1816     if (!token) { 
    1817         parser->error = YAML_MEMORY_ERROR; 
    1818         return 0; 
    1819     } 
    1820  
    1821     /* Append the token to the queue. */ 
    1822  
    1823     if (!yaml_parser_append_token(parser, token)) { 
    1824         yaml_token_delete(token); 
    1825         return 0; 
    1826     } 
    1827  
    1828     return 1; 
    1829 } 
    1830  
    1831 /* 
    1832  * Produce the YAML-DIRECTIVE or TAG-DIRECTIVE token. 
    1833  */ 
    1834  
    1835 static int 
    1836 yaml_parser_fetch_directive(yaml_parser_t *parser) 
    1837 { 
    1838     yaml_token_t *token; 
    1839  
    1840     /* Reset the indentation level. */ 
    1841  
    1842     if (!yaml_parser_unroll_indent(parser, -1)) 
    1843         return 0; 
    1844  
    1845     /* Reset simple keys. */ 
    1846  
    1847     if (!yaml_parser_remove_simple_key(parser)) 
    1848         return 0; 
    1849  
    1850     parser->simple_key_allowed = 0; 
    1851  
    1852     /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */ 
    1853  
    1854     token = yaml_parser_scan_directive(parser); 
    1855     if (!token) return 0; 
    1856  
    1857     /* Append the token to the queue. */ 
    1858  
    1859     if (!yaml_parser_append_token(parser, token)) { 
    1860         yaml_token_delete(token); 
     1609    if (!ENQUEUE(parser, parser->tokens, token)) { 
     1610        yaml_token_delete(&token); 
    18611611        return 0; 
    18621612    } 
     
    18741624{ 
    18751625    yaml_mark_t start_mark, end_mark; 
    1876     yaml_token_t *token; 
     1626    yaml_token_t token; 
    18771627 
    18781628    /* Reset the indentation level. */ 
     
    18901640    /* Consume the token. */ 
    18911641 
    1892     start_mark = yaml_parser_get_mark(parser); 
    1893  
    1894     FORWARD(parser); 
    1895     FORWARD(parser); 
    1896     FORWARD(parser); 
    1897  
    1898     end_mark = yaml_parser_get_mark(parser); 
     1642    start_mark = parser->mark; 
     1643 
     1644    SKIP(parser); 
     1645    SKIP(parser); 
     1646    SKIP(parser); 
     1647 
     1648    end_mark = parser->mark; 
    18991649 
    19001650    /* Create the DOCUMENT-START or DOCUMENT-END token. */ 
    19011651 
    1902     token = yaml_token_new(type, start_mark, end_mark); 
    1903     if (!token) { 
    1904         parser->error = YAML_MEMORY_ERROR; 
    1905         return 0; 
    1906     } 
     1652    TOKEN_INIT(token, type, start_mark, end_mark); 
    19071653 
    19081654    /* Append the token to the queue. */ 
    19091655 
    1910     if (!yaml_parser_append_token(parser, token)) { 
    1911         yaml_token_delete(token); 
    1912         return 0; 
    1913     } 
     1656    if (!ENQUEUE(parser, parser->tokens, token)) 
     1657        return 0; 
    19141658 
    19151659    return 1; 
     
    19251669{ 
    19261670    yaml_mark_t start_mark, end_mark; 
    1927     yaml_token_t *token; 
     1671    yaml_token_t token; 
    19281672 
    19291673    /* The indicators '[' and '{' may start a simple key. */ 
     
    19431687    /* Consume the token. */ 
    19441688 
    1945     start_mark = yaml_parser_get_mark(parser); 
    1946     FORWARD(parser); 
    1947     end_mark = yaml_parser_get_mark(parser); 
     1689    start_mark = parser->mark; 
     1690    SKIP(parser); 
     1691    end_mark = parser->mark; 
    19481692 
    19491693    /* Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. */ 
    19501694 
    1951     token = yaml_token_new(type, start_mark, end_mark); 
    1952     if (!token) { 
    1953         parser->error = YAML_MEMORY_ERROR; 
    1954         return 0; 
    1955     } 
     1695    TOKEN_INIT(token, type, start_mark, end_mark); 
    19561696 
    19571697    /* Append the token to the queue. */ 
    19581698 
    1959     if (!yaml_parser_append_token(parser, token)) { 
    1960         yaml_token_delete(token); 
    1961         return 0; 
    1962     } 
     1699    if (!ENQUEUE(parser, parser->tokens, token)) 
     1700        return 0; 
    19631701 
    19641702    return 1; 
     
    19741712{ 
    19751713    yaml_mark_t start_mark, end_mark; 
    1976     yaml_token_t *token; 
     1714    yaml_token_t token; 
    19771715 
    19781716    /* Reset any potential simple key on the current flow level. */ 
     
    19921730    /* Consume the token. */ 
    19931731 
    1994     start_mark = yaml_parser_get_mark(parser); 
    1995     FORWARD(parser); 
    1996     end_mark = yaml_parser_get_mark(parser); 
     1732    start_mark = parser->mark; 
     1733    SKIP(parser); 
     1734    end_mark = parser->mark; 
    19971735 
    19981736    /* Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token. */ 
    19991737 
    2000     token = yaml_token_new(type, start_mark, end_mark); 
    2001     if (!token) { 
    2002         parser->error = YAML_MEMORY_ERROR; 
    2003         return 0; 
    2004     } 
     1738    TOKEN_INIT(token, type, start_mark, end_mark); 
    20051739 
    20061740    /* Append the token to the queue. */ 
    20071741 
    2008     if (!yaml_parser_append_token(parser, token)) { 
    2009         yaml_token_delete(token); 
    2010         return 0; 
    2011     } 
     1742    if (!ENQUEUE(parser, parser->tokens, token)) 
     1743        return 0; 
    20121744 
    20131745    return 1; 
     
    20221754{ 
    20231755    yaml_mark_t start_mark, end_mark; 
    2024     yaml_token_t *token; 
     1756    yaml_token_t token; 
    20251757 
    20261758    /* Reset any potential simple keys on the current flow level. */ 
     
    20351767    /* Consume the token. */ 
    20361768 
    2037     start_mark = yaml_parser_get_mark(parser); 
    2038     FORWARD(parser); 
    2039     end_mark = yaml_parser_get_mark(parser); 
    2040  
    2041     /* Create the FLOW-ENTRY token. */ 
    2042  
    2043     token = yaml_token_new(YAML_FLOW_ENTRY_TOKEN, start_mark, end_mark); 
    2044     if (!token) { 
    2045         parser->error = YAML_MEMORY_ERROR; 
    2046         return 0; 
    2047     } 
    2048  
    2049     /* Append the token to the queue. */ 
    2050  
    2051     if (!yaml_parser_append_token(parser, token)) { 
    2052         yaml_token_delete(token); 
    2053         return 0; 
    2054     } 
     1769    start_mark = parser->mark; 
     1770    SKIP(parser); 
     1771    end_mark = parser->mark; 
     1772 
     1773    /* Create the FLOW-ENTRY token and append it to the queue. */ 
     1774 
     1775    TOKEN_INIT(token, YAML_FLOW_ENTRY_TOKEN, start_mark, end_mark); 
     1776 
     1777    if (!ENQUEUE(parser, parser->tokens, token)) 
     1778        return 0; 
    20551779 
    20561780    return 1; 
     
    20651789{ 
    20661790    yaml_mark_t start_mark, end_mark; 
    2067     yaml_token_t *token; 
     1791    yaml_token_t token; 
    20681792 
    20691793    /* Check if the scanner is in the block context. */ 
     
    20741798 
    20751799        if (!parser->simple_key_allowed) { 
    2076             return yaml_parser_set_scanner_error(parser, NULL, 
    2077                     yaml_parser_get_mark(parser), 
     1800            return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 
    20781801                    "block sequence entries are not allowed in this context"); 
    20791802        } 
     
    20811804        /* Add the BLOCK-SEQUENCE-START token if needed. */ 
    20821805 
    2083         if (!yaml_parser_roll_indent(parser, parser->column, -1, 
    2084                     YAML_BLOCK_SEQUENCE_START_TOKEN, yaml_parser_get_mark(parser))) 
     1806        if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, 
     1807                    YAML_BLOCK_SEQUENCE_START_TOKEN, parser->mark)) 
    20851808            return 0; 
    20861809    } 
     
    21051828    /* Consume the token. */ 
    21061829 
    2107     start_mark = yaml_parser_get_mark(parser); 
    2108     FORWARD(parser); 
    2109     end_mark = yaml_parser_get_mark(parser); 
    2110  
    2111     /* Create the BLOCK-ENTRY token. */ 
    2112  
    2113     token = yaml_token_new(YAML_BLOCK_ENTRY_TOKEN, start_mark, end_mark); 
    2114     if (!token) { 
    2115         parser->error = YAML_MEMORY_ERROR; 
    2116         return 0; 
    2117     } 
    2118  
    2119     /* Append the token to the queue. */ 
    2120  
    2121     if (!yaml_parser_append_token(parser, token)) { 
    2122         yaml_token_delete(token); 
    2123         return 0; 
    2124     } 
     1830    start_mark = parser->mark; 
     1831    SKIP(parser); 
     1832    end_mark = parser->mark; 
     1833 
     1834    /* Create the BLOCK-ENTRY token and append it to the queue. */ 
     1835 
     1836    TOKEN_INIT(token, YAML_BLOCK_ENTRY_TOKEN, start_mark, end_mark); 
     1837 
     1838    if (!ENQUEUE(parser, parser->tokens, token)) 
     1839        return 0; 
    21251840 
    21261841    return 1; 
     
    21351850{ 
    21361851    yaml_mark_t start_mark, end_mark; 
    2137     yaml_token_t *token; 
     1852    yaml_token_t token; 
    21381853 
    21391854    /* In the block context, additional checks are required. */ 
     
    21441859 
    21451860        if (!parser->simple_key_allowed) { 
    2146             return yaml_parser_set_scanner_error(parser, NULL, 
    2147                     yaml_parser_get_mark(parser), 
     1861            return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 
    21481862                    "mapping keys are not allowed in this context"); 
    21491863        } 
     
    21511865        /* Add the BLOCK-MAPPING-START token if needed. */ 
    21521866 
    2153         if (!yaml_parser_roll_indent(parser, parser->column, -1, 
    2154                     YAML_BLOCK_MAPPING_START_TOKEN, yaml_parser_get_mark(parser))) 
     1867        if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, 
     1868                    YAML_BLOCK_MAPPING_START_TOKEN, parser->mark)) 
    21551869            return 0; 
    21561870    } 
     
    21671881    /* Consume the token. */ 
    21681882 
    2169     start_mark = yaml_parser_get_mark(parser); 
    2170     FORWARD(parser); 
    2171     end_mark = yaml_parser_get_mark(parser); 
    2172  
    2173     /* Create the KEY token. */ 
    2174  
    2175     token = yaml_token_new(YAML_KEY_TOKEN, start_mark, end_mark); 
    2176     if (!token) { 
    2177         parser->error = YAML_MEMORY_ERROR; 
    2178         return 0; 
    2179     } 
    2180  
    2181     /* Append the token to the queue. */ 
    2182  
    2183     if (!yaml_parser_append_token(parser, token)) { 
    2184         yaml_token_delete(token); 
    2185         return 0; 
    2186     } 
     1883    start_mark = parser->mark; 
     1884    SKIP(parser); 
     1885    end_mark = parser->mark; 
     1886 
     1887    /* Create the KEY token and append it to the queue. */ 
     1888 
     1889    TOKEN_INIT(token, YAML_KEY_TOKEN, start_mark, end_mark); 
     1890 
     1891    if (!ENQUEUE(parser, parser->tokens, token)) 
     1892        return 0; 
    21871893 
    21881894    return 1; 
     
    21971903{ 
    21981904    yaml_mark_t start_mark, end_mark; 
    2199     yaml_token_t *token; 
     1905    yaml_token_t token; 
     1906    yaml_simple_key_t *simple_key = parser->simple_keys.top-1; 
    22001907 
    22011908    /* Have we found a simple key? */ 
    22021909 
    2203     if (parser->simple_keys[parser->flow_level]) 
     1910    if (simple_key->possible) 
    22041911    { 
    2205         yaml_simple_key_t *simple_key = parser->simple_keys[parser->flow_level]; 
    2206  
    2207         /* Create the KEY token. */ 
    2208  
    2209         token = yaml_token_new(YAML_KEY_TOKEN, simple_key->mark, simple_key->mark); 
    2210         if (!token) { 
    2211             parser->error = YAML_MEMORY_ERROR; 
     1912 
     1913        /* Create the KEY token and insert it into the queue. */ 
     1914 
     1915        TOKEN_INIT(token, YAML_KEY_TOKEN, simple_key->mark, simple_key->mark); 
     1916 
     1917        if (!QUEUE_INSERT(parser, parser->tokens, 
     1918                    simple_key->token_number - parser->tokens_parsed, token)) 
    22121919            return 0; 
    2213         } 
    2214  
    2215         /* Insert the token into the queue. */ 
    2216  
    2217         if (!yaml_parser_insert_token(parser, simple_key->token_number, token)) { 
    2218             yaml_token_delete(token); 
    2219             return 0; 
    2220         } 
    22211920 
    22221921        /* In the block context, we may need to add the BLOCK-MAPPING-START token. */ 
    22231922 
    2224         if (!yaml_parser_roll_indent(parser, simple_key->column, 
     1923        if (!yaml_parser_roll_indent(parser, simple_key->mark.column, 
    22251924                    simple_key->token_number, 
    22261925                    YAML_BLOCK_MAPPING_START_TOKEN, simple_key->mark)) 
    22271926            return 0; 
    22281927 
    2229         /* Remove the simple key from the list. */ 
    2230  
    2231         yaml_free(simple_key); 
    2232         parser->simple_keys[parser->flow_level] = NULL; 
     1928        /* Remove the simple key. */ 
     1929 
     1930        simple_key->possible = 0; 
    22331931 
    22341932        /* A simple key cannot follow another simple key. */ 
     
    22471945 
    22481946            if (!parser->simple_key_allowed) { 
    2249                 return yaml_parser_set_scanner_error(parser, NULL, 
    2250                         yaml_parser_get_mark(parser), 
     1947                return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 
    22511948                        "mapping values are not allowed in this context"); 
    22521949            } 
     
    22541951            /* Add the BLOCK-MAPPING-START token if needed. */ 
    22551952 
    2256             if (!yaml_parser_roll_indent(parser, parser->column, -1, 
    2257                         YAML_BLOCK_MAPPING_START_TOKEN, yaml_parser_get_mark(parser))) 
     1953            if (!yaml_parser_roll_indent(parser, parser->mark.column, -1, 
     1954                        YAML_BLOCK_MAPPING_START_TOKEN, parser->mark)) 
    22581955                return 0; 
    22591956        } 
     
    22661963    /* Consume the token. */ 
    22671964 
    2268     start_mark = yaml_parser_get_mark(parser); 
    2269     FORWARD(parser); 
    2270     end_mark = yaml_parser_get_mark(parser); 
    2271  
    2272     /* Create the VALUE token. */ 
    2273  
    2274     token = yaml_token_new(YAML_VALUE_TOKEN, start_mark, end_mark); 
    2275     if (!token) { 
    2276         parser->error = YAML_MEMORY_ERROR; 
    2277         return 0; 
    2278     } 
    2279  
    2280     /* Append the token to the queue. */ 
    2281  
    2282     if (!yaml_parser_append_token(parser, token)) { 
    2283         yaml_token_delete(token); 
    2284         return 0; 
    2285     } 
     1965    start_mark = parser->mark; 
     1966    SKIP(parser); 
     1967    end_mark = parser->mark; 
     1968 
     1969    /* Create the VALUE token and append it to the queue. */ 
     1970 
     1971    TOKEN_INIT(token, YAML_VALUE_TOKEN, start_mark, end_mark); 
     1972 
     1973    if (!ENQUEUE(parser, parser->tokens, token)) 
     1974        return 0; 
    22861975 
    22871976    return 1; 
     
    22951984yaml_parser_fetch_anchor(yaml_parser_t *parser, yaml_token_type_t type) 
    22961985{ 
    2297     yaml_token_t *token; 
     1986    yaml_token_t token; 
    22981987 
    22991988    /* An anchor or an alias could be a simple key. */ 
     
    23061995    parser->simple_key_allowed = 0; 
    23071996 
    2308     /* Create the ALIAS or ANCHOR token. */ 
    2309  
    2310     token = yaml_parser_scan_anchor(parser, type); 
    2311     if (!token) return 0; 
    2312  
    2313     /* Append the token to the queue. */ 
    2314  
    2315     if (!yaml_parser_append_token(parser, token)) { 
    2316         yaml_token_delete(token); 
    2317         return 0; 
    2318     } 
    2319  
     1997    /* Create the ALIAS or ANCHOR token and append it to the queue. */ 
     1998 
     1999    if (!yaml_parser_scan_anchor(parser, &token, type)) 
     2000        return 0; 
     2001 
     2002    if (!ENQUEUE(parser, parser->tokens, token)) { 
     2003        yaml_token_delete(&token); 
     2004        return 0; 
     2005    } 
    23202006    return 1; 
    23212007} 
     
    23282014yaml_parser_fetch_tag(yaml_parser_t *parser) 
    23292015{ 
    2330     yaml_token_t *token; 
     2016    yaml_token_t token; 
    23312017 
    23322018    /* A tag could be a simple key. */ 
     
    23392025    parser->simple_key_allowed = 0; 
    23402026 
    2341     /* Create the TAG token. */ 
    2342  
    2343     token = yaml_parser_scan_tag(parser); 
    2344     if (!token) return 0; 
    2345  
    2346     /* Append the token to the queue. */ 
    2347  
    2348     if (!yaml_parser_append_token(parser, token)) { 
    2349         yaml_token_delete(token); 
     2027    /* Create the TAG token and append it to the queue. */ 
     2028 
     2029    if (!yaml_parser_scan_tag(parser, &token)) 
     2030        return 0; 
     2031 
     2032    if (!ENQUEUE(parser, parser->tokens, token)) { 
     2033        yaml_token_delete(&token); 
    23502034        return 0; 
    23512035    } 
     
    23612045yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal) 
    23622046{ 
    2363     yaml_token_t *token; 
     2047    yaml_token_t token; 
    23642048 
    23652049    /* Remove any potential simple keys. */