Ignore:
Timestamp:
07/28/06 16:09:34 (8 years ago)
Author:
xi
Message:

Implement everything except tag and scalar writers.

File:
1 edited

Legend:

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

    r213 r214  
    489489 
    490490/* 
    491  * Check the octet at the specified position. 
    492  */ 
    493  
    494 #define CHECK_AT(parser,octet,offset)                                           \ 
    495     (parser->buffer.pointer[offset] == (yaml_char_t)(octet)) 
    496  
    497 /* 
    498  * Check the current octet in the buffer. 
    499  */ 
    500  
    501 #define CHECK(parser,octet) CHECK_AT(parser,(octet),0) 
    502  
    503 /* 
    504  * Check if the character at the specified position is an alphabetical 
    505  * character, a digit, '_', or '-'. 
    506  */ 
    507  
    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] == '-') 
    517  
    518 #define IS_ALPHA(parser)    IS_ALPHA_AT(parser,0) 
    519  
    520 /* 
    521  * Check if the character at the specified position is a digit. 
    522  */ 
    523  
    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')) 
    527  
    528 #define IS_DIGIT(parser)    IS_DIGIT_AT(parser,0) 
    529  
    530 /* 
    531  * Get the value of a digit. 
    532  */ 
    533  
    534 #define AS_DIGIT_AT(parser,offset)                                              \ 
    535      (parser->buffer.pointer[offset] - (yaml_char_t) '0') 
    536  
    537 #define AS_DIGIT(parser)    AS_DIGIT_AT(parser,0) 
    538  
    539 /* 
    540  * Check if the character at the specified position is a hex-digit. 
    541  */ 
    542  
    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')) 
    550  
    551 #define IS_HEX(parser)    IS_HEX_AT(parser,0) 
    552  
    553 /* 
    554  * Get the value of a hex-digit. 
    555  */ 
    556  
    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')) 
    565   
    566 #define AS_HEX(parser)  AS_HEX_AT(parser,0) 
    567   
    568 /* 
    569  * Check if the character at the specified position is NUL. 
    570  */ 
    571  
    572 #define IS_Z_AT(parser,offset)    CHECK_AT(parser,'\0',(offset)) 
    573  
    574 #define IS_Z(parser)    IS_Z_AT(parser,0) 
    575  
    576 /* 
    577  * Check if the character at the specified position is BOM. 
    578  */ 
    579  
    580 #define IS_BOM_AT(parser,offset)                                                \ 
    581      (CHECK_AT(parser,'\xEF',(offset))                                          \ 
    582       && CHECK_AT(parser,'\xBB',(offset)+1)                                     \ 
    583       && CHECK_AT(parser,'\xBF',(offset)+1))    /* BOM (#xFEFF) */ 
    584  
    585 #define IS_BOM(parser)  IS_BOM_AT(parser,0) 
    586  
    587 /* 
    588  * Check if the character at the specified position is space. 
    589  */ 
    590  
    591 #define IS_SPACE_AT(parser,offset)  CHECK_AT(parser,' ',(offset)) 
    592  
    593 #define IS_SPACE(parser)    IS_SPACE_AT(parser,0) 
    594  
    595 /* 
    596  * Check if the character at the specified position is tab. 
    597  */ 
    598  
    599 #define IS_TAB_AT(parser,offset)    CHECK_AT(parser,'\t',(offset)) 
    600  
    601 #define IS_TAB(parser)  IS_TAB_AT(parser,0) 
    602  
    603 /* 
    604  * Check if the character at the specified position is blank (space or tab). 
    605  */ 
    606  
    607 #define IS_BLANK_AT(parser,offset)  \ 
    608     (IS_SPACE_AT(parser,(offset)) || IS_TAB_AT(parser,(offset))) 
    609  
    610 #define IS_BLANK(parser)    IS_BLANK_AT(parser,0) 
    611  
    612 /* 
    613  * Check if the character at the specified position is a line break. 
    614  */ 
    615  
    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)                                  \ 
    626          && CHECK_AT(parser,'\xA9',(offset)+2)))    /* PS (#x2029) */ 
    627  
    628 #define IS_BREAK(parser)    IS_BREAK_AT(parser,0) 
    629  
    630 #define IS_CRLF_AT(parser,offset)                                               \ 
    631      (CHECK_AT(parser,'\r',(offset)) && CHECK_AT(parser,'\n',(offset)+1)) 
    632  
    633 #define IS_CRLF(parser) IS_CRLF_AT(parser,0) 
    634  
    635 /* 
    636  * Check if the character is a line break or NUL. 
    637  */ 
    638  
    639 #define IS_BREAKZ_AT(parser,offset)                                             \ 
    640     (IS_BREAK_AT(parser,(offset)) || IS_Z_AT(parser,(offset))) 
    641  
    642 #define IS_BREAKZ(parser)   IS_BREAKZ_AT(parser,0) 
    643  
    644 /* 
    645  * Check if the character is a line break, space, or NUL. 
    646  */ 
    647  
    648 #define IS_SPACEZ_AT(parser,offset)                                             \ 
    649     (IS_SPACE_AT(parser,(offset)) || IS_BREAKZ_AT(parser,(offset))) 
    650  
    651 #define IS_SPACEZ(parser)   IS_SPACEZ_AT(parser,0) 
    652  
    653 /* 
    654  * Check if the character is a line break, space, tab, or NUL. 
    655  */ 
    656  
    657 #define IS_BLANKZ_AT(parser,offset)                                             \ 
    658     (IS_BLANK_AT(parser,(offset)) || IS_BREAKZ_AT(parser,(offset))) 
    659  
    660 #define IS_BLANKZ(parser)   IS_BLANKZ_AT(parser,0) 
    661  
    662 /* 
    663  * Determine the width of the character. 
    664  */ 
    665  
    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) 
    671  
    672 #define WIDTH(parser)   WIDTH_AT(parser,0) 
    673  
    674 /* 
    675491 * Advance the buffer pointer. 
    676492 */ 
     
    680496      parser->mark.column ++,                                                   \ 
    681497      parser->unread --,                                                        \ 
    682       parser->buffer.pointer += WIDTH(parser)) 
     498      parser->buffer.pointer += WIDTH(parser->buffer)) 
    683499 
    684500#define SKIP_LINE(parser)                                                       \ 
    685      (IS_CRLF(parser) ?                                                         \ 
     501     (IS_CRLF(parser->buffer) ?                                                 \ 
    686502      (parser->mark.index += 2,                                                 \ 
    687503       parser->mark.column = 0,                                                 \ 
     
    689505       parser->unread -= 2,                                                     \ 
    690506       parser->buffer.pointer += 2) :                                           \ 
    691       IS_BREAK(parser) ?                                                        \ 
     507      IS_BREAK(parser->buffer) ?                                                \ 
    692508      (parser->mark.index ++,                                                   \ 
    693509       parser->mark.column = 0,                                                 \ 
    694510       parser->mark.line ++,                                                    \ 
    695511       parser->unread --,                                                       \ 
    696        parser->buffer.pointer += WIDTH(parser)) : 0) 
     512       parser->buffer.pointer += WIDTH(parser->buffer)) : 0) 
    697513 
    698514/* 
     
    702518#define READ(parser,string)                                                     \ 
    703519     (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),          \ 
     520         (COPY(string,parser->buffer),                                          \ 
    718521          parser->mark.index ++,                                                \ 
    719522          parser->mark.column ++,                                               \ 
     
    727530#define READ_LINE(parser,string)                                                \ 
    728531    (STRING_EXTEND(parser,string) ?                                             \ 
    729     (((CHECK_AT(parser,'\r',0) && CHECK_AT(parser,'\n',1)) ? /* CR LF -> LF */  \ 
     532    (((CHECK_AT(parser->buffer,'\r',0)                                          \ 
     533       && CHECK_AT(parser->buffer,'\n',1)) ?        /* CR LF -> LF */           \ 
    730534     (*((string).pointer++) = (yaml_char_t) '\n',                               \ 
    731535      parser->buffer.pointer += 2,                                              \ 
     
    734538      parser->mark.line ++,                                                     \ 
    735539      parser->unread -= 2) :                                                    \ 
    736      (CHECK_AT(parser,'\r',0) || CHECK_AT(parser,'\n',0)) ? /* CR|LF -> LF */   \ 
     540     (CHECK_AT(parser->buffer,'\r',0)                                           \ 
     541      || CHECK_AT(parser->buffer,'\n',0)) ?         /* CR|LF -> LF */           \ 
    737542     (*((string).pointer++) = (yaml_char_t) '\n',                               \ 
    738543      parser->buffer.pointer ++,                                                \ 
     
    741546      parser->mark.line ++,                                                     \ 
    742547      parser->unread --) :                                                      \ 
    743      (CHECK_AT(parser,'\xC2',0) && CHECK_AT(parser,'\x85',1)) ? /* NEL -> LF */ \ 
     548     (CHECK_AT(parser->buffer,'\xC2',0)                                         \ 
     549      && CHECK_AT(parser->buffer,'\x85',1)) ?       /* NEL -> LF */             \ 
    744550     (*((string).pointer++) = (yaml_char_t) '\n',                               \ 
    745551      parser->buffer.pointer += 2,                                              \ 
     
    748554      parser->mark.line ++,                                                     \ 
    749555      parser->unread --) :                                                      \ 
    750      (CHECK_AT(parser,'\xE2',0) &&                                              \ 
    751       CHECK_AT(parser,'\x80',1) &&                                              \ 
    752       (CHECK_AT(parser,'\xA8',2) ||                                             \ 
    753        CHECK_AT(parser,'\xA9',2))) ?                    /* LS|PS -> LS|PS */    \ 
     556     (CHECK_AT(parser->buffer,'\xE2',0) &&                                      \ 
     557      CHECK_AT(parser->buffer,'\x80',1) &&                                      \ 
     558      (CHECK_AT(parser->buffer,'\xA8',2) ||                                     \ 
     559       CHECK_AT(parser->buffer,'\xA9',2))) ?        /* LS|PS -> LS|PS */        \ 
    754560     (*((string).pointer++) = *(parser->buffer.pointer++),                      \ 
    755561      *((string).pointer++) = *(parser->buffer.pointer++),                      \ 
     
    1089895    /* Is it the end of the stream? */ 
    1090896 
    1091     if (IS_Z(parser)) 
     897    if (IS_Z(parser->buffer)) 
    1092898        return yaml_parser_fetch_stream_end(parser); 
    1093899 
    1094900    /* Is it a directive? */ 
    1095901 
    1096     if (parser->mark.column == 0 && CHECK(parser, '%')) 
     902    if (parser->mark.column == 0 && CHECK(parser->buffer, '%')) 
    1097903        return yaml_parser_fetch_directive(parser); 
    1098904 
     
    1100906 
    1101907    if (parser->mark.column == 0 
    1102             && CHECK_AT(parser, '-', 0) 
    1103             && CHECK_AT(parser, '-', 1) 
    1104             && CHECK_AT(parser, '-', 2) 
    1105             && IS_BLANKZ_AT(parser, 3)) 
     908            && CHECK_AT(parser->buffer, '-', 0) 
     909            && CHECK_AT(parser->buffer, '-', 1) 
     910            && CHECK_AT(parser->buffer, '-', 2) 
     911            && IS_BLANKZ_AT(parser->buffer, 3)) 
    1106912        return yaml_parser_fetch_document_indicator(parser, 
    1107913                YAML_DOCUMENT_START_TOKEN); 
     
    1110916 
    1111917    if (parser->mark.column == 0 
    1112             && CHECK_AT(parser, '.', 0) 
    1113             && CHECK_AT(parser, '.', 1) 
    1114             && CHECK_AT(parser, '.', 2) 
    1115             && IS_BLANKZ_AT(parser, 3)) 
     918            && CHECK_AT(parser->buffer, '.', 0) 
     919            && CHECK_AT(parser->buffer, '.', 1) 
     920            && CHECK_AT(parser->buffer, '.', 2) 
     921            && IS_BLANKZ_AT(parser->buffer, 3)) 
    1116922        return yaml_parser_fetch_document_indicator(parser, 
    1117923                YAML_DOCUMENT_END_TOKEN); 
     
    1119925    /* Is it the flow sequence start indicator? */ 
    1120926 
    1121     if (CHECK(parser, '[')) 
     927    if (CHECK(parser->buffer, '[')) 
    1122928        return yaml_parser_fetch_flow_collection_start(parser, 
    1123929                YAML_FLOW_SEQUENCE_START_TOKEN); 
     
    1125931    /* Is it the flow mapping start indicator? */ 
    1126932 
    1127     if (CHECK(parser, '{')) 
     933    if (CHECK(parser->buffer, '{')) 
    1128934        return yaml_parser_fetch_flow_collection_start(parser, 
    1129935                YAML_FLOW_MAPPING_START_TOKEN); 
     
    1131937    /* Is it the flow sequence end indicator? */ 
    1132938 
    1133     if (CHECK(parser, ']')) 
     939    if (CHECK(parser->buffer, ']')) 
    1134940        return yaml_parser_fetch_flow_collection_end(parser, 
    1135941                YAML_FLOW_SEQUENCE_END_TOKEN); 
     
    1137943    /* Is it the flow mapping end indicator? */ 
    1138944 
    1139     if (CHECK(parser, '}')) 
     945    if (CHECK(parser->buffer, '}')) 
    1140946        return yaml_parser_fetch_flow_collection_end(parser, 
    1141947                YAML_FLOW_MAPPING_END_TOKEN); 
     
    1143949    /* Is it the flow entry indicator? */ 
    1144950 
    1145     if (CHECK(parser, ',')) 
     951    if (CHECK(parser->buffer, ',')) 
    1146952        return yaml_parser_fetch_flow_entry(parser); 
    1147953 
    1148954    /* Is it the block entry indicator? */ 
    1149955 
    1150     if (CHECK(parser, '-') && IS_BLANKZ_AT(parser, 1)) 
     956    if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1)) 
    1151957        return yaml_parser_fetch_block_entry(parser); 
    1152958 
    1153959    /* Is it the key indicator? */ 
    1154960 
    1155     if (CHECK(parser, '?') && (parser->flow_level || IS_BLANKZ_AT(parser, 1))) 
     961    if (CHECK(parser->buffer, '?') 
     962            && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1))) 
    1156963        return yaml_parser_fetch_key(parser); 
    1157964 
    1158965    /* Is it the value indicator? */ 
    1159966 
    1160     if (CHECK(parser, ':') && (parser->flow_level || IS_BLANKZ_AT(parser, 1))) 
     967    if (CHECK(parser->buffer, ':') 
     968            && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1))) 
    1161969        return yaml_parser_fetch_value(parser); 
    1162970 
    1163971    /* Is it an alias? */ 
    1164972 
    1165     if (CHECK(parser, '*')) 
     973    if (CHECK(parser->buffer, '*')) 
    1166974        return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN); 
    1167975 
    1168976    /* Is it an anchor? */ 
    1169977 
    1170     if (CHECK(parser, '&')) 
     978    if (CHECK(parser->buffer, '&')) 
    1171979        return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN); 
    1172980 
    1173981    /* Is it a tag? */ 
    1174982 
    1175     if (CHECK(parser, '!')) 
     983    if (CHECK(parser->buffer, '!')) 
    1176984        return yaml_parser_fetch_tag(parser); 
    1177985 
    1178986    /* Is it a literal scalar? */ 
    1179987 
    1180     if (CHECK(parser, '|') && !parser->flow_level) 
     988    if (CHECK(parser->buffer, '|') && !parser->flow_level) 
    1181989        return yaml_parser_fetch_block_scalar(parser, 1); 
    1182990 
    1183991    /* Is it a folded scalar? */ 
    1184992 
    1185     if (CHECK(parser, '>') && !parser->flow_level) 
     993    if (CHECK(parser->buffer, '>') && !parser->flow_level) 
    1186994        return yaml_parser_fetch_block_scalar(parser, 0); 
    1187995 
    1188996    /* Is it a single-quoted scalar? */ 
    1189997 
    1190     if (CHECK(parser, '\'')) 
     998    if (CHECK(parser->buffer, '\'')) 
    1191999        return yaml_parser_fetch_flow_scalar(parser, 1); 
    11921000 
    11931001    /* Is it a double-quoted scalar? */ 
    11941002 
    1195     if (CHECK(parser, '"')) 
     1003    if (CHECK(parser->buffer, '"')) 
    11961004        return yaml_parser_fetch_flow_scalar(parser, 0); 
    11971005 
     
    12151023     */ 
    12161024 
    1217     if (!(IS_BLANKZ(parser) || CHECK(parser, '-') || CHECK(parser, '?') 
    1218                 || CHECK(parser, ':') || CHECK(parser, ',') || CHECK(parser, '[') 
    1219                 || CHECK(parser, ']') || CHECK(parser, '{') || CHECK(parser, '}') 
    1220                 || CHECK(parser, '#') || CHECK(parser, '&') || CHECK(parser, '*') 
    1221                 || CHECK(parser, '!') || CHECK(parser, '|') || CHECK(parser, '>') 
    1222                 || CHECK(parser, '\'') || CHECK(parser, '"') || CHECK(parser, '%') 
    1223                 || CHECK(parser, '@') || CHECK(parser, '`')) || 
    1224             (CHECK(parser, '-') && !IS_BLANK_AT(parser, 1)) || 
     1025    if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-') 
     1026                || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':') 
     1027                || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[') 
     1028                || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') 
     1029                || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#') 
     1030                || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*') 
     1031                || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|') 
     1032                || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'') 
     1033                || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%') 
     1034                || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) || 
     1035            (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) || 
    12251036            (!parser->flow_level && 
    1226              (CHECK(parser, '?') || CHECK(parser, ':')) && !IS_BLANKZ_AT(parser, 1))) 
     1037             (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')) 
     1038             && !IS_BLANKZ_AT(parser->buffer, 1))) 
    12271039        return yaml_parser_fetch_plain_scalar(parser); 
    12281040 
     
    21021914        if (!CACHE(parser, 1)) return 0; 
    21031915 
    2104         if (parser->mark.column == 0 && IS_BOM(parser)) 
     1916        if (parser->mark.column == 0 && IS_BOM(parser->buffer)) 
    21051917            SKIP(parser); 
    21061918 
     
    21171929        if (!CACHE(parser, 1)) return 0; 
    21181930 
    2119         while (CHECK(parser,' ') || 
     1931        while (CHECK(parser->buffer,' ') || 
    21201932                ((parser->flow_level || !parser->simple_key_allowed) && 
    2121                  CHECK(parser, '\t'))) { 
     1933                 CHECK(parser->buffer, '\t'))) { 
    21221934            SKIP(parser); 
    21231935            if (!CACHE(parser, 1)) return 0; 
     
    21261938        /* Eat a comment until a line break. */ 
    21271939 
    2128         if (CHECK(parser, '#')) { 
    2129             while (!IS_BREAKZ(parser)) { 
     1940        if (CHECK(parser->buffer, '#')) { 
     1941            while (!IS_BREAKZ(parser->buffer)) { 
    21301942                SKIP(parser); 
    21311943                if (!CACHE(parser, 1)) return 0; 
     
    21351947        /* If it is a line break, eat it. */ 
    21361948 
    2137         if (IS_BREAK(parser)) 
     1949        if (IS_BREAK(parser->buffer)) 
    21381950        { 
    21391951            if (!CACHE(parser, 2)) return 0; 
     
    22352047    if (!CACHE(parser, 1)) goto error; 
    22362048 
    2237     while (IS_BLANK(parser)) { 
     2049    while (IS_BLANK(parser->buffer)) { 
    22382050        SKIP(parser); 
    22392051        if (!CACHE(parser, 1)) goto error; 
    22402052    } 
    22412053 
    2242     if (CHECK(parser, '#')) { 
    2243         while (!IS_BREAKZ(parser)) { 
     2054    if (CHECK(parser->buffer, '#')) { 
     2055        while (!IS_BREAKZ(parser->buffer)) { 
    22442056            SKIP(parser); 
    22452057            if (!CACHE(parser, 1)) goto error; 
     
    22492061    /* Check if we are at the end of the line. */ 
    22502062 
    2251     if (!IS_BREAKZ(parser)) { 
     2063    if (!IS_BREAKZ(parser->buffer)) { 
    22522064        yaml_parser_set_scanner_error(parser, "while scanning a directive", 
    22532065                start_mark, "did not found expected comment or line break"); 
     
    22572069    /* Eat a line break. */ 
    22582070 
    2259     if (IS_BREAK(parser)) { 
     2071    if (IS_BREAK(parser->buffer)) { 
    22602072        if (!CACHE(parser, 2)) goto error; 
    22612073        SKIP_LINE(parser); 
     
    22952107    if (!CACHE(parser, 1)) goto error; 
    22962108 
    2297     while (IS_ALPHA(parser)) 
     2109    while (IS_ALPHA(parser->buffer)) 
    22982110    { 
    22992111        if (!READ(parser, string)) goto error; 
     
    23112123    /* Check for an blank character after the name. */ 
    23122124 
    2313     if (!IS_BLANKZ(parser)) { 
     2125    if (!IS_BLANKZ(parser->buffer)) { 
    23142126        yaml_parser_set_scanner_error(parser, "while scanning a directive", 
    23152127                start_mark, "found unexpected non-alphabetical character"); 
     
    23422154    if (!CACHE(parser, 1)) return 0; 
    23432155 
    2344     while (IS_BLANK(parser)) { 
     2156    while (IS_BLANK(parser->buffer)) { 
    23452157        SKIP(parser); 
    23462158        if (!CACHE(parser, 1)) return 0; 
     
    23542166    /* Eat '.'. */ 
    23552167 
    2356     if (!CHECK(parser, '.')) { 
     2168    if (!CHECK(parser->buffer, '.')) { 
    23572169        return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", 
    23582170                start_mark, "did not find expected digit or '.' character"); 
     
    23922204    if (!CACHE(parser, 1)) return 0; 
    23932205 
    2394     while (IS_DIGIT(parser)) 
     2206    while (IS_DIGIT(parser->buffer)) 
    23952207    { 
    23962208        /* Check if the number is too long. */ 
     
    24012213        } 
    24022214 
    2403         value = value*10 + AS_DIGIT(parser); 
     2215        value = value*10 + AS_DIGIT(parser->buffer); 
    24042216 
    24052217        SKIP(parser); 
     
    24392251    if (!CACHE(parser, 1)) goto error; 
    24402252 
    2441     while (IS_BLANK(parser)) { 
     2253    while (IS_BLANK(parser->buffer)) { 
    24422254        SKIP(parser); 
    24432255        if (!CACHE(parser, 1)) goto error; 
     
    24532265    if (!CACHE(parser, 1)) goto error; 
    24542266 
    2455     if (!IS_BLANK(parser)) { 
     2267    if (!IS_BLANK(parser->buffer)) { 
    24562268        yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", 
    24572269                start_mark, "did not find expected whitespace"); 
     
    24612273    /* Eat whitespaces. */ 
    24622274 
    2463     while (IS_BLANK(parser)) { 
     2275    while (IS_BLANK(parser->buffer)) { 
    24642276        SKIP(parser); 
    24652277        if (!CACHE(parser, 1)) goto error; 
     
    24752287    if (!CACHE(parser, 1)) goto error; 
    24762288 
    2477     if (!IS_BLANKZ(parser)) { 
     2289    if (!IS_BLANKZ(parser->buffer)) { 
    24782290        yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", 
    24792291                start_mark, "did not find expected whitespace or line break"); 
     
    25122324    if (!CACHE(parser, 1)) goto error; 
    25132325 
    2514     while (IS_ALPHA(parser)) { 
     2326    while (IS_ALPHA(parser->buffer)) { 
    25152327        if (!READ(parser, string)) goto error; 
    25162328        if (!CACHE(parser, 1)) goto error; 
     
    25272339     */ 
    25282340 
    2529     if (!length || !(IS_BLANKZ(parser) || CHECK(parser, '?') || CHECK(parser, ':') || 
    2530                 CHECK(parser, ',') || CHECK(parser, ']') || CHECK(parser, '}') || 
    2531                 CHECK(parser, '%') || CHECK(parser, '@') || CHECK(parser, '`'))) { 
     2341    if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?') 
     2342                || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',') 
     2343                || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}') 
     2344                || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@') 
     2345                || CHECK(parser->buffer, '`'))) { 
    25322346        yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ? 
    25332347                "while scanning an anchor" : "while scanning an alias", start_mark, 
     
    25692383    if (!CACHE(parser, 2)) goto error; 
    25702384 
    2571     if (CHECK_AT(parser, '<', 1)) 
     2385    if (CHECK_AT(parser->buffer, '<', 1)) 
    25722386    { 
    25732387        /* Set the handle to '' */ 
     
    25892403        /* Check for '>' and eat it. */ 
    25902404 
    2591         if (!CHECK(parser, '>')) { 
     2405        if (!CHECK(parser->buffer, '>')) { 
    25922406            yaml_parser_set_scanner_error(parser, "while scanning a tag", 
    25932407                    start_mark, "did not find the expected '>'"); 
     
    26472461    if (!CACHE(parser, 1)) goto error; 
    26482462 
    2649     if (!IS_BLANKZ(parser)) { 
     2463    if (!IS_BLANKZ(parser->buffer)) { 
    26502464        yaml_parser_set_scanner_error(parser, "while scanning a tag", 
    26512465                start_mark, "did not found expected whitespace or line break"); 
     
    26832497    if (!CACHE(parser, 1)) goto error; 
    26842498 
    2685     if (!CHECK(parser, '!')) { 
     2499    if (!CHECK(parser->buffer, '!')) { 
    26862500        yaml_parser_set_scanner_error(parser, directive ? 
    26872501                "while scanning a tag directive" : "while scanning a tag", 
     
    26982512    if (!CACHE(parser, 1)) goto error; 
    26992513 
    2700     while (IS_ALPHA(parser)) 
     2514    while (IS_ALPHA(parser->buffer)) 
    27012515    { 
    27022516        if (!READ(parser, string)) goto error; 
     
    27062520    /* Check if the trailing character is '!' and copy it. */ 
    27072521 
    2708     if (CHECK(parser, '!')) 
     2522    if (CHECK(parser->buffer, '!')) 
    27092523    { 
    27102524        if (!READ(parser, string)) goto error; 
     
    27792593     */ 
    27802594 
    2781     while (IS_ALPHA(parser) || CHECK(parser, ';') || CHECK(parser, '/') || 
    2782             CHECK(parser, '?') || CHECK(parser, ':') || CHECK(parser, '@') || 
    2783             CHECK(parser, '&') || CHECK(parser, '=') || CHECK(parser, '+') || 
    2784             CHECK(parser, '$') || CHECK(parser, ',') || CHECK(parser, '.') || 
    2785             CHECK(parser, '!') || CHECK(parser, '~') || CHECK(parser, '*') || 
    2786             CHECK(parser, '\'') || CHECK(parser, '(') || CHECK(parser, ')') || 
    2787             CHECK(parser, '[') || CHECK(parser, ']') || CHECK(parser, '%')) 
     2595    while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';') 
     2596            || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?') 
     2597            || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@') 
     2598            || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=') 
     2599            || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$') 
     2600            || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '.') 
     2601            || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~') 
     2602            || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'') 
     2603            || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')') 
     2604            || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']') 
     2605            || CHECK(parser->buffer, '%')) 
    27882606    { 
    27892607        /* Check if it is a URI-escape sequence. */ 
    27902608 
    2791         if (CHECK(parser, '%')) { 
     2609        if (CHECK(parser->buffer, '%')) { 
    27922610            if (!yaml_parser_scan_uri_escapes(parser, 
    27932611                        directive, start_mark, &string)) goto error; 
     
    28422660        if (!CACHE(parser, 3)) return 0; 
    28432661 
    2844         if (!(CHECK(parser, '%') && IS_HEX_AT(parser, 1) && IS_HEX_AT(parser, 2))) { 
     2662        if (!(CHECK(parser->buffer, '%') 
     2663                    && IS_HEX_AT(parser->buffer, 1) 
     2664                    && IS_HEX_AT(parser->buffer, 2))) { 
    28452665            return yaml_parser_set_scanner_error(parser, directive ? 
    28462666                    "while parsing a %TAG directive" : "while parsing a tag", 
     
    28502670        /* Get the octet. */ 
    28512671 
    2852         octet = (AS_HEX_AT(parser, 1) << 4) + AS_HEX_AT(parser, 2); 
     2672        octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2); 
    28532673 
    28542674        /* If it is the leading octet, determine the length of the UTF-8 sequence. */ 
     
    29242744    /* Check for a chomping indicator. */ 
    29252745 
    2926     if (CHECK(parser, '+') || CHECK(parser, '-')) 
     2746    if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) 
    29272747    { 
    29282748        /* Set the chomping method and eat the indicator. */ 
    29292749 
    2930         chomping = CHECK(parser, '+') ? +1 : -1; 
     2750        chomping = CHECK(parser->buffer, '+') ? +1 : -1; 
    29312751 
    29322752        SKIP(parser); 
     
    29362756        if (!CACHE(parser, 1)) goto error; 
    29372757 
    2938         if (IS_DIGIT(parser)) 
     2758        if (IS_DIGIT(parser->buffer)) 
    29392759        { 
    29402760            /* Check that the intendation is greater than 0. */ 
    29412761 
    2942             if (CHECK(parser, '0')) { 
     2762            if (CHECK(parser->buffer, '0')) { 
    29432763                yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 
    29442764                        start_mark, "found an intendation indicator equal to 0"); 
     
    29482768            /* Get the intendation level and eat the indicator. */ 
    29492769 
    2950             increment = AS_DIGIT(parser); 
     2770            increment = AS_DIGIT(parser->buffer); 
    29512771 
    29522772            SKIP(parser); 
     
    29562776    /* Do the same as above, but in the opposite order. */ 
    29572777 
    2958     else if (IS_DIGIT(parser)) 
     2778    else if (IS_DIGIT(parser->buffer)) 
    29592779    { 
    2960         if (CHECK(parser, '0')) { 
     2780        if (CHECK(parser->buffer, '0')) { 
    29612781            yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 
    29622782                    start_mark, "found an intendation indicator equal to 0"); 
     
    29642784        } 
    29652785 
    2966         increment = AS_DIGIT(parser); 
     2786        increment = AS_DIGIT(parser->buffer); 
    29672787 
    29682788        SKIP(parser); 
     
    29702790        if (!CACHE(parser, 1)) goto error; 
    29712791 
    2972         if (CHECK(parser, '+') || CHECK(parser, '-')) { 
    2973             chomping = CHECK(parser, '+') ? +1 : -1; 
     2792        if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) { 
     2793            chomping = CHECK(parser->buffer, '+') ? +1 : -1; 
    29742794 
    29752795            SKIP(parser); 
     
    29812801    if (!CACHE(parser, 1)) goto error; 
    29822802 
    2983     while (IS_BLANK(parser)) { 
     2803    while (IS_BLANK(parser->buffer)) { 
    29842804        SKIP(parser); 
    29852805        if (!CACHE(parser, 1)) goto error; 
    29862806    } 
    29872807 
    2988     if (CHECK(parser, '#')) { 
    2989         while (!IS_BREAKZ(parser)) { 
     2808    if (CHECK(parser->buffer, '#')) { 
     2809        while (!IS_BREAKZ(parser->buffer)) { 
    29902810            SKIP(parser); 
    29912811            if (!CACHE(parser, 1)) goto error; 
     
    29952815    /* Check if we are at the end of the line. */ 
    29962816 
    2997     if (!IS_BREAKZ(parser)) { 
     2817    if (!IS_BREAKZ(parser->buffer)) { 
    29982818        yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 
    29992819                start_mark, "did not found expected comment or line break"); 
     
    30032823    /* Eat a line break. */ 
    30042824 
    3005     if (IS_BREAK(parser)) { 
     2825    if (IS_BREAK(parser->buffer)) { 
    30062826        if (!CACHE(parser, 2)) goto error; 
    30072827        SKIP_LINE(parser); 
     
    30252845    if (!CACHE(parser, 1)) goto error; 
    30262846 
    3027     while (parser->mark.column == indent && !IS_Z(parser)) 
     2847    while (parser->mark.column == indent && !IS_Z(parser->buffer)) 
    30282848    { 
    30292849        /* 
     
    30332853        /* Is it a trailing whitespace? */ 
    30342854 
    3035         trailing_blank = IS_BLANK(parser); 
     2855        trailing_blank = IS_BLANK(parser->buffer); 
    30362856 
    30372857        /* Check if we need to fold the leading line break. */ 
     
    30612881        /* Is it a leading whitespace? */ 
    30622882 
    3063         leading_blank = IS_BLANK(parser); 
     2883        leading_blank = IS_BLANK(parser->buffer); 
    30642884 
    30652885        /* Consume the current line. */ 
    30662886 
    3067         while (!IS_BREAKZ(parser)) { 
     2887        while (!IS_BREAKZ(parser->buffer)) { 
    30682888            if (!READ(parser, string)) goto error; 
    30692889            if (!CACHE(parser, 1)) goto error; 
     
    31322952        if (!CACHE(parser, 1)) return 0; 
    31332953 
    3134         while ((!*indent || parser->mark.column < *indent) && IS_SPACE(parser)) { 
     2954        while ((!*indent || parser->mark.column < *indent) 
     2955                && IS_SPACE(parser->buffer)) { 
    31352956            SKIP(parser); 
    31362957            if (!CACHE(parser, 1)) return 0; 
     
    31422963        /* Check for a tab character messing the intendation. */ 
    31432964 
    3144         if ((!*indent || parser->mark.column < *indent) && IS_TAB(parser)) { 
     2965        if ((!*indent || parser->mark.column < *indent) 
     2966                && IS_TAB(parser->buffer)) { 
    31452967            return yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 
    31462968                    start_mark, "found a tab character where an intendation space is expected"); 
     
    31492971        /* Have we found a non-empty line? */ 
    31502972 
    3151         if (!IS_BREAK(parser)) break; 
     2973        if (!IS_BREAK(parser->buffer)) break; 
    31522974 
    31532975        /* Consume the line break. */ 
     
    32073029 
    32083030        if (parser->mark.column == 0 && 
    3209             ((CHECK_AT(parser, '-', 0) && 
    3210               CHECK_AT(parser, '-', 1) && 
    3211               CHECK_AT(parser, '-', 2)) || 
    3212              (CHECK_AT(parser, '.', 0) && 
    3213               CHECK_AT(parser, '.', 1) && 
    3214               CHECK_AT(parser, '.', 2))) && 
    3215             IS_BLANKZ_AT(parser, 3)) 
     3031            ((CHECK_AT(parser->buffer, '-', 0) && 
     3032              CHECK_AT(parser->buffer, '-', 1) && 
     3033              CHECK_AT(parser->buffer, '-', 2)) || 
     3034             (CHECK_AT(parser->buffer, '.', 0) && 
     3035              CHECK_AT(parser->buffer, '.', 1) && 
     3036              CHECK_AT(parser->buffer, '.', 2))) && 
     3037            IS_BLANKZ_AT(parser->buffer, 3)) 
    32163038        { 
    32173039            yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", 
     
    32223044        /* Check for EOF. */ 
    32233045 
    3224         if (IS_Z(parser)) { 
     3046        if (IS_Z(parser->buffer)) { 
    32253047            yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", 
    32263048                    start_mark, "found unexpected end of stream"); 
     
    32343056        leading_blanks = 0; 
    32353057 
    3236         while (!IS_BLANKZ(parser)) 
     3058        while (!IS_BLANKZ(parser->buffer)) 
    32373059        { 
    32383060            /* Check for an escaped single quote. */ 
    32393061 
    3240             if (single && CHECK_AT(parser, '\'', 0) && CHECK_AT(parser, '\'', 1)) 
     3062            if (single && CHECK_AT(parser->buffer, '\'', 0) 
     3063                    && CHECK_AT(parser->buffer, '\'', 1)) 
    32413064            { 
    32423065                if (!STRING_EXTEND(parser, string)) goto error; 
     
    32483071            /* Check for the right quote. */ 
    32493072 
    3250             else if (CHECK(parser, single ? '\'' : '"')) 
     3073            else if (CHECK(parser->buffer, single ? '\'' : '"')) 
    32513074            { 
    32523075                break; 
     
    32553078            /* Check for an escaped line break. */ 
    32563079 
    3257             else if (!single && CHECK(parser, '\\') && IS_BREAK_AT(parser, 1)) 
     3080            else if (!single && CHECK(parser->buffer, '\\') 
     3081                    && IS_BREAK_AT(parser->buffer, 1)) 
    32583082            { 
    32593083                if (!CACHE(parser, 3)) goto error; 
     
    32663090            /* Check for an escape sequence. */ 
    32673091 
    3268             else if (!single && CHECK(parser, '\\')) 
     3092            else if (!single && CHECK(parser->buffer, '\\')) 
    32693093            { 
    32703094                int code_length = 0; 
     
    33843208 
    33853209                    for (k = 0; k < code_length; k ++) { 
    3386                         if (!IS_HEX_AT(parser, k)) { 
     3210                        if (!IS_HEX_AT(parser->buffer, k)) { 
    33873211                            yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", 
    33883212                                    start_mark, "did not find expected hexdecimal number"); 
    33893213                            goto error; 
    33903214                        } 
    3391                         value = (value << 4) + AS_HEX_AT(parser, k); 
     3215                        value = (value << 4) + AS_HEX_AT(parser->buffer, k); 
    33923216                    } 
    33933217 
     
    34393263        /* Check if we are at the end of the scalar. */ 
    34403264 
    3441         if (CHECK(parser, single ? '\'' : '"')) 
     3265        if (CHECK(parser->buffer, single ? '\'' : '"')) 
    34423266            break; 
    34433267 
     
    34463270        if (!CACHE(parser, 1)) goto error; 
    34473271 
    3448         while (IS_BLANK(parser) || IS_BREAK(parser)) 
     3272        while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) 
    34493273        { 
    3450             if (IS_BLANK(parser)) 
     3274            if (IS_BLANK(parser->buffer)) 
    34513275            { 
    34523276                /* Consume a space or a tab character. */ 
     
    35693393 
    35703394        if (parser->mark.column == 0 && 
    3571             ((CHECK_AT(parser, '-', 0) && 
    3572               CHECK_AT(parser, '-', 1) && 
    3573               CHECK_AT(parser, '-', 2)) || 
    3574              (CHECK_AT(parser, '.', 0) && 
    3575               CHECK_AT(parser, '.', 1) && 
    3576               CHECK_AT(parser, '.', 2))) && 
    3577             IS_BLANKZ_AT(parser, 3)) break; 
     3395            ((CHECK_AT(parser->buffer, '-', 0) && 
     3396              CHECK_AT(parser->buffer, '-', 1) && 
     3397              CHECK_AT(parser->buffer, '-', 2)) || 
     3398             (CHECK_AT(parser->buffer, '.', 0) && 
     3399              CHECK_AT(parser->buffer, '.', 1) && 
     3400              CHECK_AT(parser->buffer, '.', 2))) && 
     3401            IS_BLANKZ_AT(parser->buffer, 3)) break; 
    35783402 
    35793403        /* Check for a comment. */ 
    35803404 
    3581         if (CHECK(parser, '#')) 
     3405        if (CHECK(parser->buffer, '#')) 
    35823406            break; 
    35833407 
    35843408        /* Consume non-blank characters. */ 
    35853409 
    3586         while (!IS_BLANKZ(parser)) 
     3410        while (!IS_BLANKZ(parser->buffer)) 
    35873411        { 
    35883412            /* Check for 'x:x' in the flow context. TODO: Fix the test "spec-08-13". */ 
    35893413 
    3590             if (parser->flow_level && CHECK(parser, ':') && !IS_BLANKZ_AT(parser, 1)) { 
     3414            if (parser->flow_level 
     3415                    && CHECK(parser->buffer, ':') 
     3416                    && !IS_BLANKZ_AT(parser->buffer, 1)) { 
    35913417                yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", 
    35923418                        start_mark, "found unexpected ':'"); 
     
    35963422            /* Check for indicators that may end a plain scalar. */ 
    35973423 
    3598             if ((CHECK(parser, ':') && IS_BLANKZ_AT(parser, 1)) || 
    3599                     (parser->flow_level && 
    3600                      (CHECK(parser, ',') || CHECK(parser, ':') || 
    3601                       CHECK(parser, '?') || CHECK(parser, '[') || 
    3602                       CHECK(parser, ']') || CHECK(parser, '{') || 
    3603                       CHECK(parser, '}')))) 
     3424            if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1)) 
     3425                    || (parser->flow_level && 
     3426                        (CHECK(parser->buffer, ',') || CHECK(parser->buffer, ':') 
     3427                         || CHECK(parser->buffer, '?') || CHECK(parser->buffer, '[') 
     3428                         || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') 
     3429                         || CHECK(parser->buffer, '}')))) 
    36043430                break; 
    36053431 
     
    36503476        /* Is it the end? */ 
    36513477 
    3652         if (!(IS_BLANK(parser) || IS_BREAK(parser))) 
     3478        if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))) 
    36533479            break; 
    36543480 
     
    36573483        if (!CACHE(parser, 1)) goto error; 
    36583484 
    3659         while (IS_BLANK(parser) || IS_BREAK(parser)) 
     3485        while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) 
    36603486        { 
    3661             if (IS_BLANK(parser)) 
     3487            if (IS_BLANK(parser->buffer)) 
    36623488            { 
    36633489                /* Check for tab character that abuse intendation. */ 
    36643490 
    3665                 if (leading_blanks && parser->mark.column < indent && IS_TAB(parser)) { 
     3491                if (leading_blanks && parser->mark.column < indent 
     3492                        && IS_TAB(parser->buffer)) { 
    36663493                    yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", 
    36673494                            start_mark, "found a tab character that violate intendation"); 
Note: See TracChangeset for help on using the changeset viewer.