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

Refactor internal and external API.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libyaml/trunk/src/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. */ 
     
    23722056    parser->simple_key_allowed = 1; 
    23732057 
    2374     /* Create the SCALAR token. */ 
    2375  
    2376     token = yaml_parser_scan_block_scalar(parser, literal); 
    2377     if (!token) return 0; 
    2378  
    2379     /* Append the token to the queue. */ 
    2380  
    2381     if (!yaml_parser_append_token(parser, token)) { 
    2382         yaml_token_delete(token); 
     2058    /* Create the SCALAR token and append it to the queue. */ 
     2059 
     2060    if (!yaml_parser_scan_block_scalar(parser, &token, literal)) 
     2061        return 0; 
     2062 
     2063    if (!ENQUEUE(parser, parser->tokens, token)) { 
     2064        yaml_token_delete(&token); 
    23832065        return 0; 
    23842066    } 
     
    23942076yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single) 
    23952077{ 
    2396     yaml_token_t *token; 
     2078    yaml_token_t token; 
    23972079 
    23982080    /* A plain scalar could be a simple key. */ 
     
    24052087    parser->simple_key_allowed = 0; 
    24062088 
    2407     /* Create the SCALAR token. */ 
    2408  
    2409     token = yaml_parser_scan_flow_scalar(parser, single); 
    2410     if (!token) return 0; 
    2411  
    2412     /* Append the token to the queue. */ 
    2413  
    2414     if (!yaml_parser_append_token(parser, token)) { 
    2415         yaml_token_delete(token); 
     2089    /* Create the SCALAR token and append it to the queue. */ 
     2090 
     2091    if (!yaml_parser_scan_flow_scalar(parser, &token, single)) 
     2092        return 0; 
     2093 
     2094    if (!ENQUEUE(parser, parser->tokens, token)) { 
     2095        yaml_token_delete(&token); 
    24162096        return 0; 
    24172097    } 
     
    24272107yaml_parser_fetch_plain_scalar(yaml_parser_t *parser) 
    24282108{ 
    2429     yaml_token_t *token; 
     2109    yaml_token_t token; 
    24302110 
    24312111    /* A plain scalar could be a simple key. */ 
     
    24382118    parser->simple_key_allowed = 0; 
    24392119 
    2440     /* Create the SCALAR token. */ 
    2441  
    2442     token = yaml_parser_scan_plain_scalar(parser); 
    2443     if (!token) return 0; 
    2444  
    2445     /* Append the token to the queue. */ 
    2446  
    2447     if (!yaml_parser_append_token(parser, token)) { 
    2448         yaml_token_delete(token); 
     2120    /* Create the SCALAR token and append it to the queue. */ 
     2121 
     2122    if (!yaml_parser_scan_plain_scalar(parser, &token)) 
     2123        return 0; 
     2124 
     2125    if (!ENQUEUE(parser, parser->tokens, token)) { 
     2126        yaml_token_delete(&token); 
    24492127        return 0; 
    24502128    } 
     
    24662144        /* Allow the BOM mark to start a line. */ 
    24672145 
    2468         if (!UPDATE(parser, 1)) return 0; 
    2469  
    2470         if (parser->column == 0 && IS_BOM(parser)) 
    2471             FORWARD(parser); 
     2146        if (!CACHE(parser, 1)) return 0; 
     2147 
     2148        if (parser->mark.column == 0 && IS_BOM(parser)) 
     2149            SKIP(parser); 
    24722150 
    24732151        /* 
     
    24812159         */ 
    24822160 
    2483         if (!UPDATE(parser, 1)) return 0; 
     2161        if (!CACHE(parser, 1)) return 0; 
    24842162 
    24852163        while (CHECK(parser,' ') || 
    24862164                ((parser->flow_level || !parser->simple_key_allowed) && 
    24872165                 CHECK(parser, '\t'))) { 
    2488             FORWARD(parser); 
    2489             if (!UPDATE(parser, 1)) return 0; 
     2166            SKIP(parser); 
     2167            if (!CACHE(parser, 1)) return 0; 
    24902168        } 
    24912169 
     
    24942172        if (CHECK(parser, '#')) { 
    24952173            while (!IS_BREAKZ(parser)) { 
    2496                 FORWARD(parser); 
    2497                 if (!UPDATE(parser, 1)) return 0; 
     2174                SKIP(parser); 
     2175                if (!CACHE(parser, 1)) return 0; 
    24982176            } 
    24992177        } 
     
    25032181        if (IS_BREAK(parser)) 
    25042182        { 
    2505             if (!UPDATE(parser, 2)) return 0; 
    2506             FORWARD_LINE(parser); 
     2183            if (!CACHE(parser, 2)) return 0; 
     2184            SKIP_LINE(parser); 
    25072185 
    25082186            /* In the block context, a new line may start a simple key. */ 
     
    25332211 */ 
    25342212 
    2535 static yaml_token_t * 
    2536 yaml_parser_scan_directive(yaml_parser_t *parser) 
     2213int 
     2214yaml_parser_scan_directive(yaml_parser_t *parser, yaml_token_t *token) 
    25372215{ 
    25382216    yaml_mark_t start_mark, end_mark; 
     
    25402218    int major, minor; 
    25412219    yaml_char_t *handle = NULL, *prefix = NULL; 
    2542     yaml_token_t *token = NULL; 
    25432220 
    25442221    /* Eat '%'. */ 
    25452222 
    2546     start_mark = yaml_parser_get_mark(parser); 
    2547  
    2548     FORWARD(parser); 
     2223    start_mark = parser->mark; 
     2224 
     2225    SKIP(parser); 
    25492226 
    25502227    /* Scan the directive name. */ 
     
    25632240            goto error; 
    25642241 
    2565         end_mark = yaml_parser_get_mark(parser); 
     2242        end_mark = parser->mark; 
    25662243 
    25672244        /* Create a VERSION-DIRECTIVE token. */ 
    25682245 
    2569         token = yaml_version_directive_token_new(major, minor, 
     2246        VERSION_DIRECTIVE_TOKEN_INIT(*token, major, minor, 
    25702247                start_mark, end_mark); 
    2571         if (!token) { 
    2572             parser->error = YAML_MEMORY_ERROR; 
    2573             return 0; 
    2574         } 
    25752248    } 
    25762249 
     
    25852258            goto error; 
    25862259 
    2587         end_mark = yaml_parser_get_mark(parser); 
     2260        end_mark = parser->mark; 
    25882261 
    25892262        /* Create a TAG-DIRECTIVE token. */ 
    25902263 
    2591         token = yaml_tag_directive_token_new(handle, prefix, 
     2264        TAG_DIRECTIVE_TOKEN_INIT(*token, handle, prefix, 
    25922265                start_mark, end_mark); 
    2593         if (!token) { 
    2594             parser->error = YAML_MEMORY_ERROR; 
    2595             return 0; 
    2596         } 
    25972266    } 
    25982267 
     
    26082277    /* Eat the rest of the line including any comments. */ 
    26092278 
     2279    if (!CACHE(parser, 1)) goto error; 
     2280 
    26102281    while (IS_BLANK(parser)) { 
    2611         FORWARD(parser); 
    2612         if (!UPDATE(parser, 1)) goto error; 
     2282        SKIP(parser); 
     2283        if (!CACHE(parser, 1)) goto error; 
    26132284    } 
    26142285 
    26152286    if (CHECK(parser, '#')) { 
    26162287        while (!IS_BREAKZ(parser)) { 
    2617             FORWARD(parser); 
    2618             if (!UPDATE(parser, 1)) goto error; 
     2288            SKIP(parser); 
     2289            if (!CACHE(parser, 1)) goto error; 
    26192290        } 
    26202291    } 
     
    26312302 
    26322303    if (IS_BREAK(parser)) { 
    2633         if (!UPDATE(parser, 2)) goto error; 
    2634         FORWARD_LINE(parser); 
     2304        if (!CACHE(parser, 2)) goto error; 
     2305        SKIP_LINE(parser); 
    26352306    } 
    26362307 
    26372308    yaml_free(name); 
    26382309 
    2639     return token; 
     2310    return 1; 
    26402311 
    26412312error: 
    2642     yaml_free(token); 
    26432313    yaml_free(prefix); 
    26442314    yaml_free(handle); 
    26452315    yaml_free(name); 
    2646     return NULL; 
     2316    return 0; 
    26472317} 
    26482318 
     
    26612331        yaml_mark_t start_mark, yaml_char_t **name) 
    26622332{ 
    2663     yaml_string_t string = yaml_parser_new_string(parser); 
    2664  
    2665     if (!string.buffer) goto error; 
     2333    yaml_string_t string = NULL_STRING; 
     2334 
     2335    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
    26662336 
    26672337    /* Consume the directive name. */ 
    26682338 
    2669     if (!UPDATE(parser, 1)) goto error; 
     2339    if (!CACHE(parser, 1)) goto error; 
    26702340 
    26712341    while (IS_ALPHA(parser)) 
    26722342    { 
    2673         if (!RESIZE(parser, string)) goto error; 
    2674         COPY(parser, string); 
    2675         if (!UPDATE(parser, 1)) goto error; 
     2343        if (!READ(parser, string)) goto error; 
     2344        if (!CACHE(parser, 1)) goto error; 
    26762345    } 
    26772346 
    26782347    /* Check if the name is empty. */ 
    26792348 
    2680     if (string.buffer == string.pointer) { 
     2349    if (string.start == string.pointer) { 
    26812350        yaml_parser_set_scanner_error(parser, "while scanning a directive", 
    26822351                start_mark, "cannot found expected directive name"); 
     
    26922361    } 
    26932362 
    2694     *name = string.buffer; 
     2363    *name = string.start; 
    26952364 
    26962365    return 1; 
    26972366 
    26982367error: 
    2699     yaml_free(string.buffer); 
     2368    STRING_DEL(parser, string); 
    27002369    return 0; 
    27012370} 
     
    27152384    /* Eat whitespaces. */ 
    27162385 
    2717     if (!UPDATE(parser, 1)) return 0; 
     2386    if (!CACHE(parser, 1)) return 0; 
    27182387 
    27192388    while (IS_BLANK(parser)) { 
    2720         FORWARD(parser); 
    2721         if (!UPDATE(parser, 1)) return 0; 
     2389        SKIP(parser); 
     2390        if (!CACHE(parser, 1)) return 0; 
    27222391    } 
    27232392 
     
    27342403    } 
    27352404 
    2736     FORWARD(parser); 
     2405    SKIP(parser); 
    27372406 
    27382407    /* Consume the minor version number. */ 
     
    27652434    /* Repeat while the next character is digit. */ 
    27662435 
    2767     if (!UPDATE(parser, 1)) return 0; 
     2436    if (!CACHE(parser, 1)) return 0; 
    27682437 
    27692438    while (IS_DIGIT(parser)) 
     
    27782447        value = value*10 + AS_DIGIT(parser); 
    27792448 
    2780         FORWARD(parser); 
    2781  
    2782         if (!UPDATE(parser, 1)) return 0; 
     2449        SKIP(parser); 
     2450 
     2451        if (!CACHE(parser, 1)) return 0; 
    27832452    } 
    27842453 
     
    28122481    /* Eat whitespaces. */ 
    28132482 
    2814     if (!UPDATE(parser, 1)) goto error; 
     2483    if (!CACHE(parser, 1)) goto error; 
    28152484 
    28162485    while (IS_BLANK(parser)) { 
    2817         FORWARD(parser); 
    2818         if (!UPDATE(parser, 1)) goto error; 
     2486        SKIP(parser); 
     2487        if (!CACHE(parser, 1)) goto error; 
    28192488    } 
    28202489 
     
    28262495    /* Expect a whitespace. */ 
    28272496 
    2828     if (!UPDATE(parser, 1)) goto error; 
     2497    if (!CACHE(parser, 1)) goto error; 
    28292498 
    28302499    if (!IS_BLANK(parser)) { 
     
    28372506 
    28382507    while (IS_BLANK(parser)) { 
    2839         FORWARD(parser); 
    2840         if (!UPDATE(parser, 1)) goto error; 
     2508        SKIP(parser); 
     2509        if (!CACHE(parser, 1)) goto error; 
    28412510    } 
    28422511 
     
    28482517    /* Expect a whitespace or line break. */ 
    28492518 
    2850     if (!UPDATE(parser, 1)) goto error; 
     2519    if (!CACHE(parser, 1)) goto error; 
    28512520 
    28522521    if (!IS_BLANKZ(parser)) { 
     
    28672536} 
    28682537 
    2869 static yaml_token_t * 
    2870 yaml_parser_scan_anchor(yaml_parser_t *parser, 
     2538static int 
     2539yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token, 
    28712540        yaml_token_type_t type) 
    28722541{ 
    28732542    int length = 0; 
    28742543    yaml_mark_t start_mark, end_mark; 
    2875     yaml_token_t *token = NULL; 
    2876     yaml_string_t string = yaml_parser_new_string(parser); 
    2877  
    2878     if (!string.buffer) goto error; 
     2544    yaml_string_t string = NULL_STRING; 
     2545 
     2546    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
    28792547 
    28802548    /* Eat the indicator character. */ 
    28812549 
    2882     start_mark = yaml_parser_get_mark(parser); 
    2883  
    2884     FORWARD(parser); 
     2550    start_mark = parser->mark; 
     2551 
     2552    SKIP(parser); 
    28852553 
    28862554    /* Consume the value. */ 
    28872555 
    2888     if (!UPDATE(parser, 1)) goto error; 
     2556    if (!CACHE(parser, 1)) goto error; 
    28892557 
    28902558    while (IS_ALPHA(parser)) { 
    2891         if (!RESIZE(parser, string)) goto error; 
    2892         COPY(parser, string); 
    2893         if (!UPDATE(parser, 1)) goto error; 
     2559        if (!READ(parser, string)) goto error; 
     2560        if (!CACHE(parser, 1)) goto error; 
    28942561        length ++; 
    28952562    } 
    28962563 
    2897     end_mark = yaml_parser_get_mark(parser); 
     2564    end_mark = parser->mark; 
    28982565 
    28992566    /* 
     
    29152582    /* Create a token. */ 
    29162583 
    2917     token = type == YAML_ANCHOR_TOKEN ? 
    2918         yaml_anchor_token_new(string.buffer, start_mark, end_mark) : 
    2919         yaml_alias_token_new(string.buffer, start_mark, end_mark); 
    2920     if (!token) { 
    2921         parser->error = YAML_MEMORY_ERROR; 
    2922         return 0; 
    2923     } 
    2924  
    2925     return token; 
     2584    if (type == YAML_ANCHOR_TOKEN) { 
     2585        ANCHOR_TOKEN_INIT(*token, string.start, start_mark, end_mark); 
     2586    } 
     2587    else { 
     2588        ALIAS_TOKEN_INIT(*token, string.start, start_mark, end_mark); 
     2589    } 
     2590 
     2591    return 1; 
    29262592 
    29272593error: 
    2928     yaml_free(string.buffer); 
    2929     yaml_free(token); 
     2594    STRING_DEL(parser, string); 
    29302595    return 0; 
    29312596} 
     
    29352600 */ 
    29362601 
    2937 static yaml_token_t * 
    2938 yaml_parser_scan_tag(yaml_parser_t *parser) 
     2602static int 
     2603yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token) 
    29392604{ 
    29402605    yaml_char_t *handle = NULL; 
    29412606    yaml_char_t *suffix = NULL; 
    2942     yaml_token_t *token = NULL; 
    29432607    yaml_mark_t start_mark, end_mark; 
    29442608 
    2945     start_mark = yaml_parser_get_mark(parser); 
     2609    start_mark = parser->mark; 
    29462610 
    29472611    /* Check if the tag is in the canonical form. */ 
    29482612 
    2949     if (!UPDATE(parser, 2)) goto error; 
     2613    if (!CACHE(parser, 2)) goto error; 
    29502614 
    29512615    if (CHECK_AT(parser, '<', 1)) 
     
    29592623        /* Eat '!<' */ 
    29602624 
    2961         FORWARD(parser); 
    2962         FORWARD(parser); 
     2625        SKIP(parser); 
     2626        SKIP(parser); 
    29632627 
    29642628        /* Consume the tag value. */ 
     
    29752639        } 
    29762640 
    2977         FORWARD(parser); 
     2641        SKIP(parser); 
    29782642    } 
    29792643    else 
     
    30112675 
    30122676            /* 
    3013              * A special case: the '!' tag. 
     2677             * A special case: the '!' tag.  Set the handle to '' and the 
     2678             * suffix to '!'. 
    30142679             */ 
    30152680 
     
    30242689    /* Check the character which ends the tag. */ 
    30252690 
    3026     if (!UPDATE(parser, 1)) goto error; 
     2691    if (!CACHE(parser, 1)) goto error; 
    30272692 
    30282693    if (!IS_BLANKZ(parser)) { 
     
    30322697    } 
    30332698 
    3034     end_mark = yaml_parser_get_mark(parser); 
     2699    end_mark = parser->mark; 
    30352700 
    30362701    /* Create a token. */ 
    30372702 
    3038     token = yaml_tag_token_new(handle, suffix, start_mark, end_mark); 
    3039     if (!token) { 
    3040         parser->error = YAML_MEMORY_ERROR; 
    3041         return 0; 
    3042     } 
    3043  
    3044     return token; 
     2703    TAG_TOKEN_INIT(*token, handle, suffix, start_mark, end_mark); 
     2704 
     2705    return 1; 
    30452706 
    30462707error: 
    30472708    yaml_free(handle); 
    30482709    yaml_free(suffix); 
    3049     return NULL; 
     2710    return 0; 
    30502711} 
    30512712 
     
    30582719        yaml_mark_t start_mark, yaml_char_t **handle) 
    30592720{ 
    3060     yaml_string_t string = yaml_parser_new_string(parser); 
    3061  
    3062     if (!string.buffer) goto error; 
     2721    yaml_string_t string = NULL_STRING; 
     2722 
     2723    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
    30632724 
    30642725    /* Check the initial '!' character. */ 
    30652726 
    3066     if (!UPDATE(parser, 1)) goto error; 
     2727    if (!CACHE(parser, 1)) goto error; 
    30672728 
    30682729    if (!CHECK(parser, '!')) { 
     
    30752736    /* Copy the '!' character. */ 
    30762737 
    3077     COPY(parser, string); 
     2738    if (!READ(parser, string)) goto error; 
    30782739 
    30792740    /* Copy all subsequent alphabetical and numerical characters. */ 
    30802741 
    3081     if (!UPDATE(parser, 1)) goto error; 
     2742    if (!CACHE(parser, 1)) goto error; 
    30822743 
    30832744    while (IS_ALPHA(parser)) 
    30842745    { 
    3085         if (!RESIZE(parser, string)) goto error; 
    3086         COPY(parser, string); 
    3087         if (!UPDATE(parser, 1)) goto error; 
     2746        if (!READ(parser, string)) goto error; 
     2747        if (!CACHE(parser, 1)) goto error; 
    30882748    } 
    30892749 
     
    30922752    if (CHECK(parser, '!')) 
    30932753    { 
    3094         if (!RESIZE(parser, string)) goto error; 
    3095         COPY(parser, string); 
     2754        if (!READ(parser, string)) goto error; 
    30962755    } 
    30972756    else 
     
    31032762         */ 
    31042763 
    3105         if (directive && !(string.buffer[0] == '!' && string.buffer[1] == '\0')) { 
     2764        if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) { 
    31062765            yaml_parser_set_scanner_error(parser, "while parsing a tag directive", 
    31072766                    start_mark, "did not find expected '!'"); 
     
    31102769    } 
    31112770 
    3112     *handle = string.buffer; 
     2771    *handle = string.start; 
    31132772 
    31142773    return 1; 
    31152774 
    31162775error: 
    3117     yaml_free(string.buffer); 
     2776    STRING_DEL(parser, string); 
    31182777    return 0; 
    31192778} 
     
    31282787{ 
    31292788    size_t length = head ? strlen((char *)head) : 0; 
    3130     yaml_string_t string = yaml_parser_new_string(parser); 
    3131  
    3132     if (!string.buffer) goto error; 
     2789    yaml_string_t string = NULL_STRING; 
     2790 
     2791    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
    31332792 
    31342793    /* Resize the string to include the head. */ 
    31352794 
    3136     while (string.size <= length) { 
    3137         if (!yaml_parser_resize_string(parser, &string)) goto error; 
     2795    while (string.end - string.start <= length) { 
     2796        if (!yaml_string_extend(&string.start, &string.pointer, &string.end)) { 
     2797            parser->error = YAML_MEMORY_ERROR; 
     2798            goto error; 
     2799        } 
    31382800    } 
    31392801 
     
    31452807 
    31462808    if (length > 1) { 
    3147         memcpy(string.buffer, head+1, length-1); 
     2809        memcpy(string.start, head+1, length-1); 
    31482810        string.pointer += length-1; 
    31492811    } 
     
    31512813    /* Scan the tag. */ 
    31522814 
    3153     if (!UPDATE(parser, 1)) goto error; 
     2815    if (!CACHE(parser, 1)) goto error; 
    31542816 
    31552817    /* 
     
    31692831            CHECK(parser, '[') || CHECK(parser, ']') || CHECK(parser, '%')) 
    31702832    { 
    3171         if (!RESIZE(parser, string)) goto error; 
    3172  
    31732833        /* Check if it is a URI-escape sequence. */ 
    31742834 
     
    31782838        } 
    31792839        else { 
    3180             COPY(parser, string); 
     2840            if (!READ(parser, string)) goto error; 
    31812841        } 
    31822842 
    31832843        length ++; 
    3184         if (!UPDATE(parser, 1)) goto error; 
     2844        if (!CACHE(parser, 1)) goto error; 
    31852845    } 
    31862846 
     
    31882848 
    31892849    if (!length) { 
     2850        if (!STRING_EXTEND(parser, string)) 
     2851            goto error; 
     2852 
    31902853        yaml_parser_set_scanner_error(parser, directive ? 
    31912854                "while parsing a %TAG directive" : "while parsing a tag", 
     
    31942857    } 
    31952858 
    3196     *uri = string.buffer; 
     2859    *uri = string.start; 
    31972860 
    31982861    return 1; 
    31992862 
    32002863error: 
    3201     yaml_free(string.buffer); 
     2864    STRING_DEL(parser, string); 
    32022865    return 0; 
    32032866} 
     
    32212884        /* Check for a URI-escaped octet. */ 
    32222885 
    3223         if (!UPDATE(parser, 3)) return 0; 
     2886        if (!CACHE(parser, 3)) return 0; 
    32242887 
    32252888        if (!(CHECK(parser, '%') && IS_HEX_AT(parser, 1) && IS_HEX_AT(parser, 2))) { 
     
    32612924 
    32622925        *(string->pointer++) = octet; 
    3263         FORWARD(parser); 
    3264         FORWARD(parser); 
    3265         FORWARD(parser); 
     2926        SKIP(parser); 
     2927        SKIP(parser); 
     2928        SKIP(parser); 
    32662929 
    32672930    } while (--width); 
     
    32742937 */ 
    32752938 
    3276 static yaml_token_t * 
    3277 yaml_parser_scan_block_scalar(yaml_parser_t *parser, int literal) 
     2939static int 
     2940yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token, 
     2941        int literal) 
    32782942{ 
    32792943    yaml_mark_t start_mark; 
    32802944    yaml_mark_t end_mark; 
    3281     yaml_string_t string = yaml_parser_new_string(parser); 
    3282     yaml_string_t leading_break = yaml_parser_new_string(parser); 
    3283     yaml_string_t trailing_breaks = yaml_parser_new_string(parser); 
    3284     yaml_token_t *token = NULL; 
     2945    yaml_string_t string = NULL_STRING; 
     2946    yaml_string_t leading_break = NULL_STRING; 
     2947    yaml_string_t trailing_breaks = NULL_STRING; 
    32852948    int chomping = 0; 
    32862949    int increment = 0; 
     
    32892952    int trailing_blank = 0; 
    32902953 
    3291     if (!string.buffer) goto error; 
    3292     if (!leading_break.buffer) goto error; 
    3293     if (!trailing_breaks.buffer) goto error; 
     2954    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
     2955    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; 
     2956    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; 
    32942957 
    32952958    /* Eat the indicator '|' or '>'. */ 
    32962959 
    3297     start_mark = yaml_parser_get_mark(parser); 
    3298  
    3299     FORWARD(parser); 
     2960    start_mark = parser->mark; 
     2961 
     2962    SKIP(parser); 
    33002963 
    33012964    /* Scan the additional block scalar indicators. */ 
    33022965 
    3303     if (!UPDATE(parser, 1)) goto error; 
     2966    if (!CACHE(parser, 1)) goto error; 
    33042967 
    33052968    /* Check for a chomping indicator. */ 
     
    33112974        chomping = CHECK(parser, '+') ? +1 : -1; 
    33122975 
    3313         FORWARD(parser); 
     2976        SKIP(parser); 
    33142977 
    33152978        /* Check for an indentation indicator. */ 
    33162979 
    3317         if (!UPDATE(parser, 1)) goto error; 
     2980        if (!CACHE(parser, 1)) goto error; 
    33182981 
    33192982        if (IS_DIGIT(parser)) 
     
    33312994            increment = AS_DIGIT(parser); 
    33322995 
    3333             FORWARD(parser); 
     2996            SKIP(parser); 
    33342997        } 
    33352998    } 
     
    33473010        increment = AS_DIGIT(parser); 
    33483011 
    3349         FORWARD(parser); 
    3350  
    3351         if (!UPDATE(parser, 1)) goto error; 
     3012        SKIP(parser); 
     3013 
     3014        if (!CACHE(parser, 1)) goto error; 
    33523015 
    33533016        if (CHECK(parser, '+') || CHECK(parser, '-')) { 
    33543017            chomping = CHECK(parser, '+') ? +1 : -1; 
    3355             FORWARD(parser); 
     3018 
     3019            SKIP(parser); 
    33563020        } 
    33573021    } 
     
    33593023    /* Eat whitespaces and comments to the end of the line. */ 
    33603024 
    3361     if (!UPDATE(parser, 1)) goto error; 
     3025    if (!CACHE(parser, 1)) goto error; 
    33623026 
    33633027    while (IS_BLANK(parser)) { 
    3364         FORWARD(parser); 
    3365         if (!UPDATE(parser, 1)) goto error; 
     3028        SKIP(parser); 
     3029        if (!CACHE(parser, 1)) goto error; 
    33663030    } 
    33673031 
    33683032    if (CHECK(parser, '#')) { 
    33693033        while (!IS_BREAKZ(parser)) { 
    3370             FORWARD(parser); 
    3371             if (!UPDATE(parser, 1)) goto error; 
     3034            SKIP(parser); 
     3035            if (!CACHE(parser, 1)) goto error; 
    33723036        } 
    33733037    } 
     
    33843048 
    33853049    if (IS_BREAK(parser)) { 
    3386         if (!UPDATE(parser, 2)) goto error; 
    3387         FORWARD_LINE(parser); 
    3388     } 
    3389  
    3390     end_mark = yaml_parser_get_mark(parser); 
     3050        if (!CACHE(parser, 2)) goto error; 
     3051        SKIP_LINE(parser); 
     3052    } 
     3053 
     3054    end_mark = parser->mark; 
    33913055 
    33923056    /* Set the intendation level if it was specified. */ 
     
    34033067    /* Scan the block scalar content. */ 
    34043068 
    3405     if (!UPDATE(parser, 1)) goto error; 
    3406  
    3407     while (parser->column == indent && !IS_Z(parser)) 
     3069    if (!CACHE(parser, 1)) goto error; 
     3070 
     3071    while (parser->mark.column == indent && !IS_Z(parser)) 
    34083072    { 
    34093073        /* 
     
    34173081        /* Check if we need to fold the leading line break. */ 
    34183082 
    3419         if (!literal && (*leading_break.buffer == '\n') 
     3083        if (!literal && (*leading_break.start == '\n') 
    34203084                && !leading_blank && !trailing_blank) 
    34213085        { 
    34223086            /* Do we need to join the lines by space? */ 
    34233087 
    3424             if (*trailing_breaks.buffer == '\0') { 
    3425                 if (!RESIZE(parser, string)) goto error; 
     3088            if (*trailing_breaks.start == '\0') { 
     3089                if (!STRING_EXTEND(parser, string)) goto error; 
    34263090                *(string.pointer ++) = ' '; 
    34273091            } 
    34283092 
    3429             yaml_parser_clear_string(parser, &leading_break); 
     3093            CLEAR(parser, leading_break); 
    34303094        } 
    34313095        else { 
    34323096            if (!JOIN(parser, string, leading_break)) goto error; 
     3097            CLEAR(parser, leading_break); 
    34333098        } 
    34343099 
     
    34363101 
    34373102        if (!JOIN(parser, string, trailing_breaks)) goto error; 
     3103        CLEAR(parser, trailing_breaks); 
    34383104 
    34393105        /* Is it a leading whitespace? */ 
     
    34443110 
    34453111        while (!IS_BREAKZ(parser)) { 
    3446             if (!RESIZE(parser, string)) goto error; 
    3447             COPY(parser, string); 
    3448             if (!UPDATE(parser, 1)) goto error; 
     3112            if (!READ(parser, string)) goto error; 
     3113            if (!CACHE(parser, 1)) goto error; 
    34493114        } 
    34503115 
    34513116        /* Consume the line break. */ 
    34523117 
    3453         if (!UPDATE(parser, 2)) goto error; 
    3454  
    3455         COPY_LINE(parser, leading_break); 
     3118        if (!CACHE(parser, 2)) goto error; 
     3119 
     3120        if (!READ_LINE(parser, leading_break)) goto error; 
    34563121 
    34573122        /* Eat the following intendation spaces and line breaks. */ 
     
    34723137    /* Create a token. */ 
    34733138 
    3474     token = yaml_scalar_token_new(string.buffer, string.pointer-string.buffer, 
     3139    SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, 
    34753140            literal ? YAML_LITERAL_SCALAR_STYLE : YAML_FOLDED_SCALAR_STYLE, 
    34763141            start_mark, end_mark); 
    3477     if (!token) { 
    3478         parser->error = YAML_MEMORY_ERROR; 
    3479         return 0; 
    3480     } 
    3481  
    3482     yaml_free(leading_break.buffer); 
    3483     yaml_free(trailing_breaks.buffer); 
    3484  
    3485     return token; 
     3142 
     3143    STRING_DEL(parser, leading_break); 
     3144    STRING_DEL(parser, trailing_breaks); 
     3145 
     3146    return 1; 
    34863147 
    34873148error: 
    3488     yaml_free(string.buffer); 
    3489     yaml_free(leading_break.buffer); 
    3490     yaml_free(trailing_breaks.buffer); 
    3491  
    3492     return NULL; 
     3149    STRING_DEL(parser, string); 
     3150    STRING_DEL(parser, leading_break); 
     3151    STRING_DEL(parser, trailing_breaks); 
     3152 
     3153    return 0; 
    34933154} 
    34943155 
     
    35053166    int max_indent = 0; 
    35063167 
    3507     *end_mark = yaml_parser_get_mark(parser); 
     3168    *end_mark = parser->mark; 
    35083169 
    35093170    /* Eat the intendation spaces and line breaks. */ 
     
    35133174        /* Eat the intendation spaces. */ 
    35143175 
    3515         if (!UPDATE(parser, 1)) return 0; 
    3516  
    3517         while ((!*indent || parser->column < *indent) && IS_SPACE(parser)) { 
    3518             FORWARD(parser); 
    3519             if (!UPDATE(parser, 1)) return 0; 
    3520         } 
    3521  
    3522         if (parser->column > max_indent) 
    3523             max_indent = parser->column; 
     3176        if (!CACHE(parser, 1)) return 0; 
     3177 
     3178        while ((!*indent || parser->mark.column < *indent) && IS_SPACE(parser)) { 
     3179            SKIP(parser); 
     3180            if (!CACHE(parser, 1)) return 0; 
     3181        } 
     3182 
     3183        if (parser->mark.column > max_indent) 
     3184            max_indent = parser->mark.column; 
    35243185 
    35253186        /* Check for a tab character messing the intendation. */ 
    35263187 
    3527         if ((!*indent || parser->column < *indent) && IS_TAB(parser)) { 
     3188        if ((!*indent || parser->mark.column < *indent) && IS_TAB(parser)) { 
    35283189            return yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 
    35293190                    start_mark, "found a tab character where an intendation space is expected"); 
     
    35363197        /* Consume the line break. */ 
    35373198 
    3538         if (!UPDATE(parser, 2)) return 0; 
    3539         if (!RESIZE(parser, *breaks)) return 0; 
    3540         COPY_LINE(parser, *breaks); 
    3541         *end_mark = yaml_parser_get_mark(parser); 
     3199        if (!CACHE(parser, 2)) return 0; 
     3200        if (!READ_LINE(parser, *breaks)) return 0; 
     3201        *end_mark = parser->mark; 
    35423202    } 
    35433203 
     
    35593219 */ 
    35603220 
    3561 static yaml_token_t * 
    3562 yaml_parser_scan_flow_scalar(yaml_parser_t *parser, int single) 
     3221static int 
     3222yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token, 
     3223        int single) 
    35633224{ 
    35643225    yaml_mark_t start_mark; 
    35653226    yaml_mark_t end_mark; 
    3566     yaml_string_t string = yaml_parser_new_string(parser); 
    3567     yaml_string_t leading_break = yaml_parser_new_string(parser); 
    3568     yaml_string_t trailing_breaks = yaml_parser_new_string(parser); 
    3569     yaml_string_t whitespaces = yaml_parser_new_string(parser); 
    3570     yaml_token_t *token = NULL; 
     3227    yaml_string_t string = NULL_STRING; 
     3228    yaml_string_t leading_break = NULL_STRING; 
     3229    yaml_string_t trailing_breaks = NULL_STRING; 
     3230    yaml_string_t whitespaces = NULL_STRING; 
    35713231    int leading_blanks; 
    35723232 
    3573     if (!string.buffer) goto error; 
    3574     if (!leading_break.buffer) goto error; 
    3575     if (!trailing_breaks.buffer) goto error; 
    3576     if (!whitespaces.buffer) goto error; 
     3233    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
     3234    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; 
     3235    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; 
     3236    if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error; 
    35773237 
    35783238    /* Eat the left quote. */ 
    35793239 
    3580     start_mark = yaml_parser_get_mark(parser); 
    3581  
    3582     FORWARD(parser); 
     3240    start_mark = parser->mark; 
     3241 
     3242    SKIP(parser); 
    35833243 
    35843244    /* Consume the content of the quoted scalar. */ 
     
    35883248        /* Check that there are no document indicators at the beginning of the line. */ 
    35893249 
    3590         if (!UPDATE(parser, 4)) goto error; 
    3591  
    3592         if (parser->column == 0 && 
     3250        if (!CACHE(parser, 4)) goto error; 
     3251 
     3252        if (parser->mark.column == 0 && 
    35933253            ((CHECK_AT(parser, '-', 0) && 
    35943254              CHECK_AT(parser, '-', 1) && 
     
    36143274        /* Consume non-blank characters. */ 
    36153275 
    3616         if (!UPDATE(parser, 2)) goto error; 
    3617         if (!RESIZE(parser, string)) goto error; 
     3276        if (!CACHE(parser, 2)) goto error; 
    36183277 
    36193278        leading_blanks = 0; 
     
    36253284            if (single && CHECK_AT(parser, '\'', 0) && CHECK_AT(parser, '\'', 1)) 
    36263285            { 
     3286                if (!STRING_EXTEND(parser, string)) goto error; 
    36273287                *(string.pointer++) = '\''; 
    3628                 FORWARD(parser); 
    3629                 FORWARD(parser); 
     3288                SKIP(parser); 
     3289                SKIP(parser); 
    36303290            } 
    36313291 
     
    36413301            else if (!single && CHECK(parser, '\\') && IS_BREAK_AT(parser, 1)) 
    36423302            { 
    3643                 if (!UPDATE(parser, 3)) goto error; 
    3644                 FORWARD(parser); 
    3645                 FORWARD_LINE(parser); 
     3303                if (!CACHE(parser, 3)) goto error; 
     3304                SKIP(parser); 
     3305                SKIP_LINE(parser); 
    36463306                leading_blanks = 1; 
    36473307                break; 
     
    36543314                int code_length = 0; 
    36553315 
     3316                if (!STRING_EXTEND(parser, string)) goto error; 
     3317 
    36563318                /* Check the escape character. */ 
    36573319 
    3658                 switch (parser->pointer[1]) 
     3320                switch (parser->buffer.pointer[1]) 
    36593321                { 
    36603322                    case '0': 
     
    37513413                } 
    37523414 
    3753                 FORWARD(parser); 
    3754                 FORWARD(parser); 
     3415                SKIP(parser); 
     3416                SKIP(parser); 
    37553417 
    37563418                /* Consume an arbitrary escape code. */ 
     
    37633425                    /* Scan the character value. */ 
    37643426 
    3765                     if (!UPDATE(parser, code_length)) goto error; 
     3427                    if (!CACHE(parser, code_length)) goto error; 
    37663428 
    37673429                    for (k = 0; k < code_length; k ++) { 
     
    38043466 
    38053467                    for (k = 0; k < code_length; k ++) { 
    3806                         FORWARD(parser); 
     3468                        SKIP(parser); 
    38073469                    } 
    38083470                } 
     
    38133475                /* It is a non-escaped non-blank character. */ 
    38143476 
    3815                 COPY(parser, string); 
     3477                if (!READ(parser, string)) goto error; 
    38163478            } 
    38173479 
    3818             if (!UPDATE(parser, 2)) goto error; 
    3819             if (!RESIZE(parser, string)) goto error; 
     3480            if (!CACHE(parser, 2)) goto error; 
    38203481        } 
    38213482 
     
    38273488        /* Consume blank characters. */ 
    38283489 
    3829         if (!UPDATE(parser, 1)) goto error; 
     3490        if (!CACHE(parser, 1)) goto error; 
    38303491 
    38313492        while (IS_BLANK(parser) || IS_BREAK(parser)) 
     
    38363497 
    38373498                if (!leading_blanks) { 
    3838                     if (!RESIZE(parser, whitespaces)) goto error; 
    3839                     COPY(parser, whitespaces); 
     3499                    if (!READ(parser, whitespaces)) goto error; 
    38403500                } 
    38413501                else { 
    3842                     FORWARD(parser); 
     3502                    SKIP(parser); 
    38433503                } 
    38443504            } 
    38453505            else 
    38463506            { 
    3847                 if (!UPDATE(parser, 2)) goto error; 
     3507                if (!CACHE(parser, 2)) goto error; 
    38483508 
    38493509                /* Check if it is a first line break. */ 
     
    38513511                if (!leading_blanks) 
    38523512                { 
    3853                     yaml_parser_clear_string(parser, &whitespaces); 
    3854                     COPY_LINE(parser, leading_break); 
     3513                    CLEAR(parser, whitespaces); 
     3514                    if (!READ_LINE(parser, leading_break)) goto error; 
    38553515                    leading_blanks = 1; 
    38563516                } 
    38573517                else 
    38583518                { 
    3859                     if (!RESIZE(parser, trailing_breaks)) goto error; 
    3860                     COPY_LINE(parser, trailing_breaks); 
     3519                    if (!READ_LINE(parser, trailing_breaks)) goto error; 
    38613520                } 
    38623521            } 
    3863             if (!UPDATE(parser, 1)) goto error; 
     3522            if (!CACHE(parser, 1)) goto error; 
    38643523        } 
    38653524 
    38663525        /* Join the whitespaces or fold line breaks. */ 
    3867  
    3868         if (!RESIZE(parser, string)) goto error; 
    38693526 
    38703527        if (leading_blanks) 
     
    38723529            /* Do we need to fold line breaks? */ 
    38733530 
    3874             if (leading_break.buffer[0] == '\n') { 
    3875                 if (trailing_breaks.buffer[0] == '\0') { 
     3531            if (leading_break.start[0] == '\n') { 
     3532                if (trailing_breaks.start[0] == '\0') { 
     3533                    if (!STRING_EXTEND(parser, string)) goto error; 
    38763534                    *(string.pointer++) = ' '; 
    38773535                } 
    38783536                else { 
    38793537                    if (!JOIN(parser, string, trailing_breaks)) goto error; 
     3538                    CLEAR(parser, trailing_breaks); 
    38803539                } 
    3881                 yaml_parser_clear_string(parser, &leading_break); 
     3540                CLEAR(parser, leading_break); 
    38823541            } 
    38833542            else { 
    38843543                if (!JOIN(parser, string, leading_break)) goto error; 
    38853544                if (!JOIN(parser, string, trailing_breaks)) goto error; 
     3545                CLEAR(parser, leading_break); 
     3546                CLEAR(parser, trailing_breaks); 
    38863547            } 
    38873548        } 
     
    38893550        { 
    38903551            if (!JOIN(parser, string, whitespaces)) goto error; 
     3552            CLEAR(parser, whitespaces); 
    38913553        } 
    38923554    } 
     
    38943556    /* Eat the right quote. */ 
    38953557 
    3896     FORWARD(parser); 
    3897  
    3898     end_mark = yaml_parser_get_mark(parser); 
     3558    SKIP(parser); 
     3559 
     3560    end_mark = parser->mark; 
    38993561 
    39003562    /* Create a token. */ 
    39013563 
    3902     token = yaml_scalar_token_new(string.buffer, string.pointer-string.buffer, 
     3564    SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, 
    39033565            single ? YAML_SINGLE_QUOTED_SCALAR_STYLE : YAML_DOUBLE_QUOTED_SCALAR_STYLE, 
    39043566            start_mark, end_mark); 
    3905     if (!token) { 
    3906         parser->error = YAML_MEMORY_ERROR; 
    3907         return 0; 
    3908     } 
    3909  
    3910     yaml_free(leading_break.buffer); 
    3911     yaml_free(trailing_breaks.buffer); 
    3912     yaml_free(whitespaces.buffer); 
    3913  
    3914     return token; 
     3567 
     3568    STRING_DEL(parser, leading_break); 
     3569    STRING_DEL(parser, trailing_breaks); 
     3570    STRING_DEL(parser, whitespaces); 
     3571 
     3572    return 1; 
    39153573 
    39163574error: 
    3917     yaml_free(string.buffer); 
    3918     yaml_free(leading_break.buffer); 
    3919     yaml_free(trailing_breaks.buffer); 
    3920     yaml_free(whitespaces.buffer); 
    3921  
    3922     return NULL; 
     3575    STRING_DEL(parser, string); 
     3576    STRING_DEL(parser, leading_break); 
     3577    STRING_DEL(parser, trailing_breaks); 
     3578    STRING_DEL(parser, whitespaces); 
     3579 
     3580    return 0; 
    39233581} 
    39243582 
     
    39273585 */ 
    39283586 
    3929 static yaml_token_t * 
    3930 yaml_parser_scan_plain_scalar(yaml_parser_t *parser) 
     3587static int 
     3588yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token) 
    39313589{ 
    39323590    yaml_mark_t start_mark; 
    39333591    yaml_mark_t end_mark; 
    3934     yaml_string_t string = yaml_parser_new_string(parser); 
    3935     yaml_string_t leading_break = yaml_parser_new_string(parser); 
    3936     yaml_string_t trailing_breaks = yaml_parser_new_string(parser); 
    3937     yaml_string_t whitespaces = yaml_parser_new_string(parser); 
    3938     yaml_token_t *token = NULL; 
     3592    yaml_string_t string = NULL_STRING; 
     3593    yaml_string_t leading_break = NULL_STRING; 
     3594    yaml_string_t trailing_breaks = NULL_STRING; 
     3595    yaml_string_t whitespaces = NULL_STRING; 
    39393596    int leading_blanks = 0; 
    39403597    int indent = parser->indent+1; 
    39413598 
    3942     if (!string.buffer) goto error; 
    3943     if (!leading_break.buffer) goto error; 
    3944     if (!trailing_breaks.buffer) goto error; 
    3945     if (!whitespaces.buffer) goto error; 
    3946  
    3947     start_mark = yaml_parser_get_mark(parser); 
     3599    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
     3600    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; 
     3601    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; 
     3602    if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error; 
     3603 
     3604    start_mark = parser->mark; 
    39483605 
    39493606    /* Consume the content of the plain scalar. */ 
     
    39533610        /* Check for a document indicator. */ 
    39543611 
    3955         if (!UPDATE(parser, 4)) goto error; 
    3956  
    3957         if (parser->column == 0 && 
     3612        if (!CACHE(parser, 4)) goto error; 
     3613 
     3614        if (parser->mark.column == 0 && 
    39583615            ((CHECK_AT(parser, '-', 0) && 
    39593616              CHECK_AT(parser, '-', 1) && 
     
    39933650            /* Check if we need to join whitespaces and breaks. */ 
    39943651 
    3995             if (leading_blanks || whitespaces.buffer != whitespaces.pointer) 
     3652            if (leading_blanks || whitespaces.start != whitespaces.pointer) 
    39963653            { 
    3997                 if (!RESIZE(parser, string)) goto error; 
    3998  
    39993654                if (leading_blanks) 
    40003655                { 
    40013656                    /* Do we need to fold line breaks? */ 
    40023657 
    4003                     if (leading_break.buffer[0] == '\n') { 
    4004                         if (trailing_breaks.buffer[0] == '\0') { 
     3658                    if (leading_break.start[0] == '\n') { 
     3659                        if (trailing_breaks.start[0] == '\0') { 
     3660                            if (!STRING_EXTEND(parser, string)) goto error; 
    40053661                            *(string.pointer++) = ' '; 
    40063662                        } 
    40073663                        else { 
    40083664                            if (!JOIN(parser, string, trailing_breaks)) goto error; 
     3665                            CLEAR(parser, trailing_breaks); 
    40093666                        } 
    4010                         yaml_parser_clear_string(parser, &leading_break); 
     3667                        CLEAR(parser, leading_break); 
    40113668                    } 
    40123669                    else { 
    40133670                        if (!JOIN(parser, string, leading_break)) goto error; 
    40143671                        if (!JOIN(parser, string, trailing_breaks)) goto error; 
     3672                        CLEAR(parser, leading_break); 
     3673                        CLEAR(parser, trailing_breaks); 
    40153674                    } 
    40163675 
     
    40203679                { 
    40213680                    if (!JOIN(parser, string, whitespaces)) goto error; 
     3681                    CLEAR(parser, whitespaces); 
    40223682                } 
    40233683            } 
     
    40253685            /* Copy the character. */ 
    40263686 
    4027             if (!RESIZE(parser, string)) goto error; 
    4028  
    4029             COPY(parser, string); 
    4030  
    4031             end_mark = yaml_parser_get_mark(parser); 
    4032  
    4033             if (!UPDATE(parser, 2)) goto error; 
     3687            if (!READ(parser, string)) goto error; 
     3688 
     3689            end_mark = parser->mark; 
     3690 
     3691            if (!CACHE(parser, 2)) goto error; 
    40343692        } 
    40353693 
     
    40413699        /* Consume blank characters. */ 
    40423700 
    4043         if (!UPDATE(parser, 1)) goto error; 
     3701        if (!CACHE(parser, 1)) goto error; 
    40443702 
    40453703        while (IS_BLANK(parser) || IS_BREAK(parser)) 
     
    40493707                /* Check for tab character that abuse intendation. */ 
    40503708 
    4051                 if (leading_blanks && parser->column < indent && IS_TAB(parser)) { 
     3709                if (leading_blanks && parser->mark.column < indent && IS_TAB(parser)) { 
    40523710                    yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", 
    40533711                            start_mark, "found a tab character that violate intendation"); 
     
    40583716 
    40593717                if (!leading_blanks) { 
    4060                     if (!RESIZE(parser, whitespaces)) goto error; 
    4061                     COPY(parser, whitespaces); 
     3718                    if (!READ(parser, whitespaces)) goto error; 
    40623719                } 
    40633720                else { 
    4064                     FORWARD(parser); 
     3721                    SKIP(parser); 
    40653722                } 
    40663723            } 
    40673724            else 
    40683725            { 
    4069                 if (!UPDATE(parser, 2)) goto error; 
     3726                if (!CACHE(parser, 2)) goto error; 
    40703727 
    40713728                /* Check if it is a first line break. */ 
     
    40733730                if (!leading_blanks) 
    40743731                { 
    4075                     yaml_parser_clear_string(parser, &whitespaces); 
    4076                     COPY_LINE(parser, leading_break); 
     3732                    CLEAR(parser, whitespaces); 
     3733                    if (!READ_LINE(parser, leading_break)) goto error; 
    40773734                    leading_blanks = 1; 
    40783735                } 
    40793736                else 
    40803737                { 
    4081                     if (!RESIZE(parser, trailing_breaks)) goto error; 
    4082                     COPY_LINE(parser, trailing_breaks); 
     3738                    if (!READ_LINE(parser, trailing_breaks)) goto error; 
    40833739                } 
    40843740            } 
    4085             if (!UPDATE(parser, 1)) goto error; 
     3741            if (!CACHE(parser, 1)) goto error; 
    40863742        } 
    40873743 
    40883744        /* Check intendation level. */ 
    40893745 
    4090         if (!parser->flow_level && parser->column < indent) 
     3746        if (!parser->flow_level && parser->mark.column < indent) 
    40913747            break; 
    40923748    } 
     
    40943750    /* Create a token. */ 
    40953751 
    4096     token = yaml_scalar_token_new(string.buffer, string.pointer-string.buffer, 
     3752    SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, 
    40973753            YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark); 
    4098     if (!token) { 
    4099         parser->error = YAML_MEMORY_ERROR; 
    4100         return 0; 
    4101     } 
    41023754 
    41033755    /* Note that we change the 'simple_key_allowed' flag. */ 
     
    41073759    } 
    41083760 
    4109     yaml_free(leading_break.buffer); 
    4110     yaml_free(trailing_breaks.buffer); 
    4111     yaml_free(whitespaces.buffer); 
    4112  
    4113     return token; 
     3761    STRING_DEL(parser, leading_break); 
     3762    STRING_DEL(parser, trailing_breaks); 
     3763    STRING_DEL(parser, whitespaces); 
     3764 
     3765    return 1; 
    41143766 
    41153767error: 
    4116     yaml_free(string.buffer); 
    4117     yaml_free(leading_break.buffer); 
    4118     yaml_free(trailing_breaks.buffer); 
    4119     yaml_free(whitespaces.buffer); 
    4120  
    4121     return NULL; 
    4122 } 
    4123  
     3768    STRING_DEL(parser, string); 
     3769    STRING_DEL(parser, leading_break); 
     3770    STRING_DEL(parser, trailing_breaks); 
     3771    STRING_DEL(parser, whitespaces); 
     3772 
     3773    return 0; 
     3774} 
     3775 
Note: See TracChangeset for help on using the changeset viewer.