Ignore:
Timestamp:
12/27/07 07:05:17 (6 years ago)
Author:
xi
Message:

Completed the first phase of API refactoring.

File:
1 edited

Legend:

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

    r243 r263  
    496496      parser->mark.column ++,                                                   \ 
    497497      parser->unread --,                                                        \ 
    498       parser->buffer.pointer += WIDTH(parser->buffer)) 
     498      parser->input.pointer += WIDTH(parser->input)) 
    499499 
    500500#define SKIP_LINE(parser)                                                       \ 
    501      (IS_CRLF(parser->buffer) ?                                                 \ 
     501     (IS_CRLF(parser->input) ?                                                  \ 
    502502      (parser->mark.index += 2,                                                 \ 
    503503       parser->mark.column = 0,                                                 \ 
    504504       parser->mark.line ++,                                                    \ 
    505505       parser->unread -= 2,                                                     \ 
    506        parser->buffer.pointer += 2) :                                           \ 
    507       IS_BREAK(parser->buffer) ?                                                \ 
     506       parser->input.pointer += 2) :                                            \ 
     507      IS_BREAK(parser->input) ?                                                 \ 
    508508      (parser->mark.index ++,                                                   \ 
    509509       parser->mark.column = 0,                                                 \ 
    510510       parser->mark.line ++,                                                    \ 
    511511       parser->unread --,                                                       \ 
    512        parser->buffer.pointer += WIDTH(parser->buffer)) : 0) 
     512       parser->input.pointer += WIDTH(parser->input)) : 0) 
    513513 
    514514/* 
     
    518518#define READ(parser,string)                                                     \ 
    519519     (STRING_EXTEND(parser,string) ?                                            \ 
    520          (COPY(string,parser->buffer),                                          \ 
     520         (COPY(string,parser->input),                                           \ 
    521521          parser->mark.index ++,                                                \ 
    522522          parser->mark.column ++,                                               \ 
     
    530530#define READ_LINE(parser,string)                                                \ 
    531531    (STRING_EXTEND(parser,string) ?                                             \ 
    532     (((CHECK_AT(parser->buffer,'\r',0)                                          \ 
    533        && CHECK_AT(parser->buffer,'\n',1)) ?        /* CR LF -> LF */           \ 
    534      (*((string).pointer++) = (yaml_char_t) '\n',                               \ 
    535       parser->buffer.pointer += 2,                                              \ 
     532    (((CHECK_AT(parser->input,'\r',0)                                           \ 
     533       && CHECK_AT(parser->input,'\n',1)) ?         /* CR LF -> LF */           \ 
     534     (JOIN_OCTET(string, (yaml_char_t) '\n'),                                   \ 
     535      parser->input.pointer += 2,                                               \ 
    536536      parser->mark.index += 2,                                                  \ 
    537537      parser->mark.column = 0,                                                  \ 
    538538      parser->mark.line ++,                                                     \ 
    539539      parser->unread -= 2) :                                                    \ 
    540      (CHECK_AT(parser->buffer,'\r',0)                                           \ 
    541       || CHECK_AT(parser->buffer,'\n',0)) ?         /* CR|LF -> LF */           \ 
    542      (*((string).pointer++) = (yaml_char_t) '\n',                               \ 
    543       parser->buffer.pointer ++,                                                \ 
     540     (CHECK_AT(parser->input,'\r',0)                                            \ 
     541      || CHECK_AT(parser->input,'\n',0)) ?          /* CR|LF -> LF */           \ 
     542     (JOIN_OCTET(string,(yaml_char_t) '\n'),                                    \ 
     543      parser->input.pointer ++,                                                 \ 
    544544      parser->mark.index ++,                                                    \ 
    545545      parser->mark.column = 0,                                                  \ 
    546546      parser->mark.line ++,                                                     \ 
    547547      parser->unread --) :                                                      \ 
    548      (CHECK_AT(parser->buffer,'\xC2',0)                                         \ 
    549       && CHECK_AT(parser->buffer,'\x85',1)) ?       /* NEL -> LF */             \ 
    550      (*((string).pointer++) = (yaml_char_t) '\n',                               \ 
    551       parser->buffer.pointer += 2,                                              \ 
     548     (CHECK_AT(parser->input,'\xC2',0)                                          \ 
     549      && CHECK_AT(parser->input,'\x85',1)) ?        /* NEL -> LF */             \ 
     550     (JOIN_OCTET(string,(yaml_char_t) '\n'),                                    \ 
     551      parser->input.pointer += 2,                                               \ 
    552552      parser->mark.index ++,                                                    \ 
    553553      parser->mark.column = 0,                                                  \ 
    554554      parser->mark.line ++,                                                     \ 
    555555      parser->unread --) :                                                      \ 
    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 */        \ 
    560      (*((string).pointer++) = *(parser->buffer.pointer++),                      \ 
    561       *((string).pointer++) = *(parser->buffer.pointer++),                      \ 
    562       *((string).pointer++) = *(parser->buffer.pointer++),                      \ 
     556     (CHECK_AT(parser->input,'\xE2',0) &&                                       \ 
     557      CHECK_AT(parser->input,'\x80',1) &&                                       \ 
     558      (CHECK_AT(parser->input,'\xA8',2) ||                                      \ 
     559       CHECK_AT(parser->input,'\xA9',2))) ?         /* LS|PS -> LS|PS */        \ 
     560     (COPY_OCTET(string,parser->input),                                         \ 
     561      COPY_OCTET(string,parser->input),                                         \ 
     562      COPY_OCTET(string,parser->input),                                         \ 
    563563      parser->mark.index ++,                                                    \ 
    564564      parser->mark.column = 0,                                                  \ 
     
    575575 
    576576/* 
    577  * Error handling. 
    578  */ 
    579  
    580 static int 
    581 yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context, 
    582         yaml_mark_t context_mark, const char *problem); 
    583  
    584 /* 
    585577 * High-level token API. 
    586578 */ 
     
    751743    /* No tokens after STREAM-END or error. */ 
    752744 
    753     if (parser->stream_end_produced || parser->error) { 
     745    if (parser->is_stream_end_produced || parser->error.type) { 
    754746        return 1; 
    755747    } 
     
    757749    /* Ensure that the tokens queue contains enough tokens. */ 
    758750 
    759     if (!parser->token_available) { 
     751    if (!parser->is_token_available) { 
    760752        if (!yaml_parser_fetch_more_tokens(parser)) 
    761753            return 0; 
     
    765757     
    766758    *token = DEQUEUE(parser, parser->tokens); 
    767     parser->token_available = 0; 
     759    parser->is_token_available = 0; 
    768760    parser->tokens_parsed ++; 
    769761 
    770762    if (token->type == YAML_STREAM_END_TOKEN) { 
    771         parser->stream_end_produced = 1; 
    772     } 
    773  
    774     return 1; 
    775 } 
    776  
    777 /* 
    778  * Set the scanner error and return 0. 
    779  */ 
    780  
    781 static int 
    782 yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context, 
    783         yaml_mark_t context_mark, const char *problem) 
    784 { 
    785     parser->error = YAML_SCANNER_ERROR; 
    786     parser->context = context; 
    787     parser->context_mark = context_mark; 
    788     parser->problem = problem; 
    789     parser->problem_mark = parser->mark; 
    790  
    791     return 0; 
     763        parser->is_stream_end_produced = 1; 
     764    } 
     765 
     766    return 1; 
    792767} 
    793768 
     
    820795        else 
    821796        { 
    822             yaml_simple_key_t *simple_key; 
     797            size_t idx; 
    823798 
    824799            /* Check if any potential simple key may occupy the head position. */ 
     
    827802                return 0; 
    828803 
    829             for (simple_key = parser->simple_keys.start; 
    830                     simple_key != parser->simple_keys.top; simple_key++) { 
    831                 if (simple_key->possible 
     804            for (idx = 0; idx < parser->simple_keys.length; idx++) { 
     805                yaml_simple_key_t *simple_key  = parser->simple_keys.list + idx; 
     806                if (simple_key->is_possible 
    832807                        && simple_key->token_number == parser->tokens_parsed) { 
    833808                    need_more_tokens = 1; 
     
    848823    } 
    849824 
    850     parser->token_available = 1; 
     825    parser->is_token_available = 1; 
    851826 
    852827    return 1; 
     
    860835yaml_parser_fetch_next_token(yaml_parser_t *parser) 
    861836{ 
     837    yaml_mark_t start_mark = parser->mark; 
     838 
    862839    /* Ensure that the buffer is initialized. */ 
    863840 
     
    867844    /* Check if we just started scanning.  Fetch STREAM-START then. */ 
    868845 
    869     if (!parser->stream_start_produced) 
     846    if (!parser->is_stream_start_produced) 
    870847        return yaml_parser_fetch_stream_start(parser); 
    871848 
     
    895872    /* Is it the end of the stream? */ 
    896873 
    897     if (IS_Z(parser->buffer)) 
     874    if (IS_Z(parser->input)) 
    898875        return yaml_parser_fetch_stream_end(parser); 
    899876 
    900877    /* Is it a directive? */ 
    901878 
    902     if (parser->mark.column == 0 && CHECK(parser->buffer, '%')) 
     879    if (parser->mark.column == 0 && CHECK(parser->input, '%')) 
    903880        return yaml_parser_fetch_directive(parser); 
    904881 
     
    906883 
    907884    if (parser->mark.column == 0 
    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)) 
     885            && CHECK_AT(parser->input, '-', 0) 
     886            && CHECK_AT(parser->input, '-', 1) 
     887            && CHECK_AT(parser->input, '-', 2) 
     888            && IS_BLANKZ_AT(parser->input, 3)) 
    912889        return yaml_parser_fetch_document_indicator(parser, 
    913890                YAML_DOCUMENT_START_TOKEN); 
     
    916893 
    917894    if (parser->mark.column == 0 
    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)) 
     895            && CHECK_AT(parser->input, '.', 0) 
     896            && CHECK_AT(parser->input, '.', 1) 
     897            && CHECK_AT(parser->input, '.', 2) 
     898            && IS_BLANKZ_AT(parser->input, 3)) 
    922899        return yaml_parser_fetch_document_indicator(parser, 
    923900                YAML_DOCUMENT_END_TOKEN); 
     
    925902    /* Is it the flow sequence start indicator? */ 
    926903 
    927     if (CHECK(parser->buffer, '[')) 
     904    if (CHECK(parser->input, '[')) 
    928905        return yaml_parser_fetch_flow_collection_start(parser, 
    929906                YAML_FLOW_SEQUENCE_START_TOKEN); 
     
    931908    /* Is it the flow mapping start indicator? */ 
    932909 
    933     if (CHECK(parser->buffer, '{')) 
     910    if (CHECK(parser->input, '{')) 
    934911        return yaml_parser_fetch_flow_collection_start(parser, 
    935912                YAML_FLOW_MAPPING_START_TOKEN); 
     
    937914    /* Is it the flow sequence end indicator? */ 
    938915 
    939     if (CHECK(parser->buffer, ']')) 
     916    if (CHECK(parser->input, ']')) 
    940917        return yaml_parser_fetch_flow_collection_end(parser, 
    941918                YAML_FLOW_SEQUENCE_END_TOKEN); 
     
    943920    /* Is it the flow mapping end indicator? */ 
    944921 
    945     if (CHECK(parser->buffer, '}')) 
     922    if (CHECK(parser->input, '}')) 
    946923        return yaml_parser_fetch_flow_collection_end(parser, 
    947924                YAML_FLOW_MAPPING_END_TOKEN); 
     
    949926    /* Is it the flow entry indicator? */ 
    950927 
    951     if (CHECK(parser->buffer, ',')) 
     928    if (CHECK(parser->input, ',')) 
    952929        return yaml_parser_fetch_flow_entry(parser); 
    953930 
    954931    /* Is it the block entry indicator? */ 
    955932 
    956     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1)) 
     933    if (CHECK(parser->input, '-') && IS_BLANKZ_AT(parser->input, 1)) 
    957934        return yaml_parser_fetch_block_entry(parser); 
    958935 
    959936    /* Is it the key indicator? */ 
    960937 
    961     if (CHECK(parser->buffer, '?') 
    962             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1))) 
     938    if (CHECK(parser->input, '?') 
     939            && (parser->flow_level || IS_BLANKZ_AT(parser->input, 1))) 
    963940        return yaml_parser_fetch_key(parser); 
    964941 
    965942    /* Is it the value indicator? */ 
    966943 
    967     if (CHECK(parser->buffer, ':') 
    968             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1))) 
     944    if (CHECK(parser->input, ':') 
     945            && (parser->flow_level || IS_BLANKZ_AT(parser->input, 1))) 
    969946        return yaml_parser_fetch_value(parser); 
    970947 
    971948    /* Is it an alias? */ 
    972949 
    973     if (CHECK(parser->buffer, '*')) 
     950    if (CHECK(parser->input, '*')) 
    974951        return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN); 
    975952 
    976953    /* Is it an anchor? */ 
    977954 
    978     if (CHECK(parser->buffer, '&')) 
     955    if (CHECK(parser->input, '&')) 
    979956        return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN); 
    980957 
    981958    /* Is it a tag? */ 
    982959 
    983     if (CHECK(parser->buffer, '!')) 
     960    if (CHECK(parser->input, '!')) 
    984961        return yaml_parser_fetch_tag(parser); 
    985962 
    986963    /* Is it a literal scalar? */ 
    987964 
    988     if (CHECK(parser->buffer, '|') && !parser->flow_level) 
     965    if (CHECK(parser->input, '|') && !parser->flow_level) 
    989966        return yaml_parser_fetch_block_scalar(parser, 1); 
    990967 
    991968    /* Is it a folded scalar? */ 
    992969 
    993     if (CHECK(parser->buffer, '>') && !parser->flow_level) 
     970    if (CHECK(parser->input, '>') && !parser->flow_level) 
    994971        return yaml_parser_fetch_block_scalar(parser, 0); 
    995972 
    996973    /* Is it a single-quoted scalar? */ 
    997974 
    998     if (CHECK(parser->buffer, '\'')) 
     975    if (CHECK(parser->input, '\'')) 
    999976        return yaml_parser_fetch_flow_scalar(parser, 1); 
    1000977 
    1001978    /* Is it a double-quoted scalar? */ 
    1002979 
    1003     if (CHECK(parser->buffer, '"')) 
     980    if (CHECK(parser->input, '"')) 
    1004981        return yaml_parser_fetch_flow_scalar(parser, 0); 
    1005982 
     
    10231000     */ 
    10241001 
    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)) || 
     1002    if (!(IS_BLANKZ(parser->input) || CHECK(parser->input, '-') 
     1003                || CHECK(parser->input, '?') || CHECK(parser->input, ':') 
     1004                || CHECK(parser->input, ',') || CHECK(parser->input, '[') 
     1005                || CHECK(parser->input, ']') || CHECK(parser->input, '{') 
     1006                || CHECK(parser->input, '}') || CHECK(parser->input, '#') 
     1007                || CHECK(parser->input, '&') || CHECK(parser->input, '*') 
     1008                || CHECK(parser->input, '!') || CHECK(parser->input, '|') 
     1009                || CHECK(parser->input, '>') || CHECK(parser->input, '\'') 
     1010                || CHECK(parser->input, '"') || CHECK(parser->input, '%') 
     1011                || CHECK(parser->input, '@') || CHECK(parser->input, '`')) || 
     1012            (CHECK(parser->input, '-') && !IS_BLANK_AT(parser->input, 1)) || 
    10361013            (!parser->flow_level && 
    1037              (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')) 
    1038              && !IS_BLANKZ_AT(parser->buffer, 1))) 
     1014             (CHECK(parser->input, '?') || CHECK(parser->input, ':')) 
     1015             && !IS_BLANKZ_AT(parser->input, 1))) 
    10391016        return yaml_parser_fetch_plain_scalar(parser); 
    10401017 
     
    10431020     */ 
    10441021 
    1045     return yaml_parser_set_scanner_error(parser, 
    1046             "while scanning for the next token", parser->mark, 
    1047             "found character that cannot start any token"); 
     1022    return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     1023            "while scanning for the next token", start_mark, 
     1024            "found character that cannot start any token", parser->mark); 
    10481025} 
    10491026 
     
    10561033yaml_parser_stale_simple_keys(yaml_parser_t *parser) 
    10571034{ 
    1058     yaml_simple_key_t *simple_key; 
     1035    size_t idx; 
    10591036 
    10601037    /* Check for a potential simple key for each flow level. */ 
    10611038 
    1062     for (simple_key = parser->simple_keys.start; 
    1063             simple_key != parser->simple_keys.top; simple_key ++) 
     1039    for (idx = 0; idx < parser->simple_keys.length; idx ++) 
    10641040    { 
     1041        yaml_simple_key_t *simple_key = parser->simple_keys.list + idx; 
     1042 
    10651043        /* 
    10661044         * The specification requires that a simple key 
     
    10701048         */ 
    10711049 
    1072         if (simple_key->possible 
     1050        if (simple_key->is_possible 
    10731051                && (simple_key->mark.line < parser->mark.line 
    10741052                    || simple_key->mark.index+1024 < parser->mark.index)) { 
     
    10761054            /* Check if the potential simple key to be removed is required. */ 
    10771055 
    1078             if (simple_key->required) { 
    1079                 return yaml_parser_set_scanner_error(parser, 
     1056            if (simple_key->is_required) { 
     1057                return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
    10801058                        "while scanning a simple key", simple_key->mark, 
    1081                         "could not found expected ':'"); 
     1059                        "could not found expected ':'", parser->mark); 
    10821060            } 
    10831061 
    1084             simple_key->possible = 0; 
     1062            simple_key->is_possible = 0; 
    10851063        } 
    10861064    } 
     
    11031081     */ 
    11041082 
    1105     int required = (!parser->flow_level 
     1083    int is_required = (!parser->flow_level 
    11061084            && parser->indent == (int)parser->mark.column); 
    11071085 
     
    11111089     */ 
    11121090 
    1113     assert(parser->simple_key_allowed || !required);    /* Impossible. */ 
     1091    assert(parser->is_simple_key_allowed || !is_required);  /* Impossible. */ 
    11141092 
    11151093    /* 
     
    11171095     */ 
    11181096 
    1119     if (parser->simple_key_allowed) 
     1097    if (parser->is_simple_key_allowed) 
    11201098    { 
    1121         yaml_simple_key_t simple_key = { 1, required, 
     1099        yaml_simple_key_t simple_key = { 1, is_required, 
    11221100            parser->tokens_parsed + parser->tokens.tail - parser->tokens.head, 
    11231101            { 0, 0, 0 } }; 
     
    11261104        if (!yaml_parser_remove_simple_key(parser)) return 0; 
    11271105 
    1128         *(parser->simple_keys.top-1) = simple_key; 
     1106        parser->simple_keys.list[parser->simple_keys.length-1] = simple_key; 
    11291107    } 
    11301108 
     
    11391117yaml_parser_remove_simple_key(yaml_parser_t *parser) 
    11401118{ 
    1141     yaml_simple_key_t *simple_key = parser->simple_keys.top-1; 
    1142  
    1143     if (simple_key->possible) 
     1119    yaml_simple_key_t *simple_key = 
     1120        parser->simple_keys.list + parser->simple_keys.length - 1; 
     1121 
     1122    if (simple_key->is_possible) 
    11441123    { 
    11451124        /* If the key is required, it is an error. */ 
    11461125 
    1147         if (simple_key->required) { 
    1148             return yaml_parser_set_scanner_error(parser, 
     1126        if (simple_key->is_required) { 
     1127            return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
    11491128                    "while scanning a simple key", simple_key->mark, 
    1150                     "could not found expected ':'"); 
     1129                    "could not found expected ':'", parser->mark); 
    11511130        } 
    11521131    } 
     
    11541133    /* Remove the key from the stack. */ 
    11551134 
    1156     simple_key->possible = 0; 
     1135    simple_key->is_possible = 0; 
    11571136 
    11581137    return 1; 
     
    13021281    /* A simple key is allowed at the beginning of the stream. */ 
    13031282 
    1304     parser->simple_key_allowed = 1; 
     1283    parser->is_simple_key_allowed = 1; 
    13051284 
    13061285    /* We have started. */ 
    13071286 
    1308     parser->stream_start_produced = 1; 
     1287    parser->is_stream_start_produced = 1; 
    13091288 
    13101289    /* Create the STREAM-START token and append it to the queue. */ 
     
    13451324        return 0; 
    13461325 
    1347     parser->simple_key_allowed = 0; 
     1326    parser->is_simple_key_allowed = 0; 
    13481327 
    13491328    /* Create the STREAM-END token and append it to the queue. */ 
     
    13761355        return 0; 
    13771356 
    1378     parser->simple_key_allowed = 0; 
     1357    parser->is_simple_key_allowed = 0; 
    13791358 
    13801359    /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */ 
     
    14141393        return 0; 
    14151394 
    1416     parser->simple_key_allowed = 0; 
     1395    parser->is_simple_key_allowed = 0; 
    14171396 
    14181397    /* Consume the token. */ 
     
    14611440    /* A simple key may follow the indicators '[' and '{'. */ 
    14621441 
    1463     parser->simple_key_allowed = 1; 
     1442    parser->is_simple_key_allowed = 1; 
    14641443 
    14651444    /* Consume the token. */ 
     
    15041483    /* No simple keys after the indicators ']' and '}'. */ 
    15051484 
    1506     parser->simple_key_allowed = 0; 
     1485    parser->is_simple_key_allowed = 0; 
    15071486 
    15081487    /* Consume the token. */ 
     
    15411520    /* Simple keys are allowed after ','. */ 
    15421521 
    1543     parser->simple_key_allowed = 1; 
     1522    parser->is_simple_key_allowed = 1; 
    15441523 
    15451524    /* Consume the token. */ 
     
    15751554        /* Check if we are allowed to start a new entry. */ 
    15761555 
    1577         if (!parser->simple_key_allowed) { 
    1578             return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 
    1579                     "block sequence entries are not allowed in this context"); 
     1556        if (!parser->is_simple_key_allowed) { 
     1557            return SCANNER_ERROR_INIT(parser, 
     1558                    "block sequence entries are not allowed in this context", 
     1559                    parser->mark); 
    15801560        } 
    15811561 
     
    16021582    /* Simple keys are allowed after '-'. */ 
    16031583 
    1604     parser->simple_key_allowed = 1; 
     1584    parser->is_simple_key_allowed = 1; 
    16051585 
    16061586    /* Consume the token. */ 
     
    16361616        /* Check if we are allowed to start a new key (not nessesary simple). */ 
    16371617 
    1638         if (!parser->simple_key_allowed) { 
    1639             return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 
    1640                     "mapping keys are not allowed in this context"); 
     1618        if (!parser->is_simple_key_allowed) { 
     1619            return SCANNER_ERROR_INIT(parser, 
     1620                    "mapping keys are not allowed in this context", parser->mark); 
    16411621        } 
    16421622 
     
    16551635    /* Simple keys are allowed after '?' in the block context. */ 
    16561636 
    1657     parser->simple_key_allowed = (!parser->flow_level); 
     1637    parser->is_simple_key_allowed = (!parser->flow_level); 
    16581638 
    16591639    /* Consume the token. */ 
     
    16821662    yaml_mark_t start_mark, end_mark; 
    16831663    yaml_token_t token; 
    1684     yaml_simple_key_t *simple_key = parser->simple_keys.top-1; 
     1664    yaml_simple_key_t *simple_key = 
     1665        parser->simple_keys.list + parser->simple_keys.length - 1; 
    16851666 
    16861667    /* Have we found a simple key? */ 
    16871668 
    1688     if (simple_key->possible) 
     1669    if (simple_key->is_possible) 
    16891670    { 
    16901671 
     
    17061687        /* Remove the simple key. */ 
    17071688 
    1708         simple_key->possible = 0; 
     1689        simple_key->is_possible = 0; 
    17091690 
    17101691        /* A simple key cannot follow another simple key. */ 
    17111692 
    1712         parser->simple_key_allowed = 0; 
     1693        parser->is_simple_key_allowed = 0; 
    17131694    } 
    17141695    else 
     
    17221703            /* Check if we are allowed to start a complex value. */ 
    17231704 
    1724             if (!parser->simple_key_allowed) { 
    1725                 return yaml_parser_set_scanner_error(parser, NULL, parser->mark, 
    1726                         "mapping values are not allowed in this context"); 
     1705            if (!parser->is_simple_key_allowed) { 
     1706                return SCANNER_ERROR_INIT(parser, 
     1707                        "mapping values are not allowed in this context", 
     1708                        parser->mark); 
    17271709            } 
    17281710 
     
    17361718        /* Simple keys after ':' are allowed in the block context. */ 
    17371719 
    1738         parser->simple_key_allowed = (!parser->flow_level); 
     1720        parser->is_simple_key_allowed = (!parser->flow_level); 
    17391721    } 
    17401722 
     
    17711753    /* A simple key cannot follow an anchor or an alias. */ 
    17721754 
    1773     parser->simple_key_allowed = 0; 
     1755    parser->is_simple_key_allowed = 0; 
    17741756 
    17751757    /* Create the ALIAS or ANCHOR token and append it to the queue. */ 
     
    18011783    /* A simple key cannot follow a tag. */ 
    18021784 
    1803     parser->simple_key_allowed = 0; 
     1785    parser->is_simple_key_allowed = 0; 
    18041786 
    18051787    /* Create the TAG token and append it to the queue. */ 
     
    18321814    /* A simple key may follow a block scalar. */ 
    18331815 
    1834     parser->simple_key_allowed = 1; 
     1816    parser->is_simple_key_allowed = 1; 
    18351817 
    18361818    /* Create the SCALAR token and append it to the queue. */ 
     
    18631845    /* A simple key cannot follow a flow scalar. */ 
    18641846 
    1865     parser->simple_key_allowed = 0; 
     1847    parser->is_simple_key_allowed = 0; 
    18661848 
    18671849    /* Create the SCALAR token and append it to the queue. */ 
     
    18941876    /* A simple key cannot follow a flow scalar. */ 
    18951877 
    1896     parser->simple_key_allowed = 0; 
     1878    parser->is_simple_key_allowed = 0; 
    18971879 
    18981880    /* Create the SCALAR token and append it to the queue. */ 
     
    19241906        if (!CACHE(parser, 1)) return 0; 
    19251907 
    1926         if (parser->mark.column == 0 && IS_BOM(parser->buffer)) 
     1908        if (parser->mark.column == 0 && IS_BOM(parser->input)) 
    19271909            SKIP(parser); 
    19281910 
     
    19391921        if (!CACHE(parser, 1)) return 0; 
    19401922 
    1941         while (CHECK(parser->buffer,' ') || 
    1942                 ((parser->flow_level || !parser->simple_key_allowed) && 
    1943                  CHECK(parser->buffer, '\t'))) { 
     1923        while (CHECK(parser->input,' ') || 
     1924                ((parser->flow_level || !parser->is_simple_key_allowed) && 
     1925                 CHECK(parser->input, '\t'))) { 
    19441926            SKIP(parser); 
    19451927            if (!CACHE(parser, 1)) return 0; 
     
    19481930        /* Eat a comment until a line break. */ 
    19491931 
    1950         if (CHECK(parser->buffer, '#')) { 
    1951             while (!IS_BREAKZ(parser->buffer)) { 
     1932        if (CHECK(parser->input, '#')) { 
     1933            while (!IS_BREAKZ(parser->input)) { 
    19521934                SKIP(parser); 
    19531935                if (!CACHE(parser, 1)) return 0; 
     
    19571939        /* If it is a line break, eat it. */ 
    19581940 
    1959         if (IS_BREAK(parser->buffer)) 
     1941        if (IS_BREAK(parser->input)) 
    19601942        { 
    19611943            if (!CACHE(parser, 2)) return 0; 
     
    19651947 
    19661948            if (!parser->flow_level) { 
    1967                 parser->simple_key_allowed = 1; 
     1949                parser->is_simple_key_allowed = 1; 
    19681950            } 
    19691951        } 
     
    20482030    else 
    20492031    { 
    2050         yaml_parser_set_scanner_error(parser, "while scanning a directive", 
    2051                 start_mark, "found uknown directive name"); 
     2032        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2033                "while scanning a directive", start_mark, 
     2034                "found uknown directive name", parser->mark); 
    20522035        goto error; 
    20532036    } 
     
    20572040    if (!CACHE(parser, 1)) goto error; 
    20582041 
    2059     while (IS_BLANK(parser->buffer)) { 
     2042    while (IS_BLANK(parser->input)) { 
    20602043        SKIP(parser); 
    20612044        if (!CACHE(parser, 1)) goto error; 
    20622045    } 
    20632046 
    2064     if (CHECK(parser->buffer, '#')) { 
    2065         while (!IS_BREAKZ(parser->buffer)) { 
     2047    if (CHECK(parser->input, '#')) { 
     2048        while (!IS_BREAKZ(parser->input)) { 
    20662049            SKIP(parser); 
    20672050            if (!CACHE(parser, 1)) goto error; 
     
    20712054    /* Check if we are at the end of the line. */ 
    20722055 
    2073     if (!IS_BREAKZ(parser->buffer)) { 
    2074         yaml_parser_set_scanner_error(parser, "while scanning a directive", 
    2075                 start_mark, "did not found expected comment or line break"); 
     2056    if (!IS_BREAKZ(parser->input)) { 
     2057        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2058                "while scanning a directive", start_mark, 
     2059                "did not found expected comment or line break", parser->mark); 
    20762060        goto error; 
    20772061    } 
     
    20792063    /* Eat a line break. */ 
    20802064 
    2081     if (IS_BREAK(parser->buffer)) { 
     2065    if (IS_BREAK(parser->input)) { 
    20822066        if (!CACHE(parser, 2)) goto error; 
    20832067        SKIP_LINE(parser); 
     
    21112095    yaml_string_t string = NULL_STRING; 
    21122096 
    2113     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
     2097    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2098        goto error; 
    21142099 
    21152100    /* Consume the directive name. */ 
     
    21172102    if (!CACHE(parser, 1)) goto error; 
    21182103 
    2119     while (IS_ALPHA(parser->buffer)) 
     2104    while (IS_ALPHA(parser->input)) 
    21202105    { 
    21212106        if (!READ(parser, string)) goto error; 
     
    21252110    /* Check if the name is empty. */ 
    21262111 
    2127     if (string.start == string.pointer) { 
    2128         yaml_parser_set_scanner_error(parser, "while scanning a directive", 
    2129                 start_mark, "cannot found expected directive name"); 
     2112    if (!string.pointer) { 
     2113        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2114                "while scanning a directive", start_mark, 
     2115                "cannot found expected directive name", parser->mark); 
    21302116        goto error; 
    21312117    } 
     
    21332119    /* Check for an blank character after the name. */ 
    21342120 
    2135     if (!IS_BLANKZ(parser->buffer)) { 
    2136         yaml_parser_set_scanner_error(parser, "while scanning a directive", 
    2137                 start_mark, "found unexpected non-alphabetical character"); 
     2121    if (!IS_BLANKZ(parser->input)) { 
     2122        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2123                "while scanning a directive", start_mark, 
     2124                "found unexpected non-alphabetical character", parser->mark); 
    21382125        goto error; 
    21392126    } 
    21402127 
    2141     *name = string.start; 
     2128    *name = string.buffer; 
    21422129 
    21432130    return 1; 
     
    21642151    if (!CACHE(parser, 1)) return 0; 
    21652152 
    2166     while (IS_BLANK(parser->buffer)) { 
     2153    while (IS_BLANK(parser->input)) { 
    21672154        SKIP(parser); 
    21682155        if (!CACHE(parser, 1)) return 0; 
     
    21762163    /* Eat '.'. */ 
    21772164 
    2178     if (!CHECK(parser->buffer, '.')) { 
    2179         return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", 
    2180                 start_mark, "did not find expected digit or '.' character"); 
     2165    if (!CHECK(parser->input, '.')) { 
     2166        return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2167                "while scanning a %YAML directive", start_mark, 
     2168                "did not find expected digit or '.' character", parser->mark); 
    21812169    } 
    21822170 
     
    22142202    if (!CACHE(parser, 1)) return 0; 
    22152203 
    2216     while (IS_DIGIT(parser->buffer)) 
     2204    while (IS_DIGIT(parser->input)) 
    22172205    { 
    22182206        /* Check if the number is too long. */ 
    22192207 
    22202208        if (++length > MAX_NUMBER_LENGTH) { 
    2221             return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", 
    2222                     start_mark, "found extremely long version number"); 
    2223         } 
    2224  
    2225         value = value*10 + AS_DIGIT(parser->buffer); 
     2209            return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2210                    "while scanning a %YAML directive", start_mark, 
     2211                    "found extremely long version number", parser->mark); 
     2212        } 
     2213 
     2214        value = value*10 + AS_DIGIT(parser->input); 
    22262215 
    22272216        SKIP(parser); 
     
    22332222 
    22342223    if (!length) { 
    2235         return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", 
    2236                 start_mark, "did not find expected version number"); 
     2224        return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2225                "while scanning a %YAML directive", start_mark, 
     2226                "did not find expected version number", parser->mark); 
    22372227    } 
    22382228 
     
    22612251    if (!CACHE(parser, 1)) goto error; 
    22622252 
    2263     while (IS_BLANK(parser->buffer)) { 
     2253    while (IS_BLANK(parser->input)) { 
    22642254        SKIP(parser); 
    22652255        if (!CACHE(parser, 1)) goto error; 
     
    22752265    if (!CACHE(parser, 1)) goto error; 
    22762266 
    2277     if (!IS_BLANK(parser->buffer)) { 
    2278         yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", 
    2279                 start_mark, "did not find expected whitespace"); 
     2267    if (!IS_BLANK(parser->input)) { 
     2268        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2269                "while scanning a %TAG directive", start_mark, 
     2270                "did not find expected whitespace", parser->mark); 
    22802271        goto error; 
    22812272    } 
     
    22832274    /* Eat whitespaces. */ 
    22842275 
    2285     while (IS_BLANK(parser->buffer)) { 
     2276    while (IS_BLANK(parser->input)) { 
    22862277        SKIP(parser); 
    22872278        if (!CACHE(parser, 1)) goto error; 
     
    22972288    if (!CACHE(parser, 1)) goto error; 
    22982289 
    2299     if (!IS_BLANKZ(parser->buffer)) { 
    2300         yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", 
    2301                 start_mark, "did not find expected whitespace or line break"); 
     2290    if (!IS_BLANKZ(parser->input)) { 
     2291        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2292                "while scanning a %TAG directive", start_mark, 
     2293                "did not find expected whitespace or line break", parser->mark); 
    23022294        goto error; 
    23032295    } 
     
    23222314    yaml_string_t string = NULL_STRING; 
    23232315 
    2324     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
     2316    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2317        goto error; 
    23252318 
    23262319    /* Eat the indicator character. */ 
     
    23342327    if (!CACHE(parser, 1)) goto error; 
    23352328 
    2336     while (IS_ALPHA(parser->buffer)) { 
     2329    while (IS_ALPHA(parser->input)) { 
    23372330        if (!READ(parser, string)) goto error; 
    23382331        if (!CACHE(parser, 1)) goto error; 
     
    23492342     */ 
    23502343 
    2351     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?') 
    2352                 || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',') 
    2353                 || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}') 
    2354                 || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@') 
    2355                 || CHECK(parser->buffer, '`'))) { 
    2356         yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ? 
    2357                 "while scanning an anchor" : "while scanning an alias", start_mark, 
    2358                 "did not find expected alphabetic or numeric character"); 
     2344    if (!length || !(IS_BLANKZ(parser->input) || CHECK(parser->input, '?') 
     2345                || CHECK(parser->input, ':') || CHECK(parser->input, ',') 
     2346                || CHECK(parser->input, ']') || CHECK(parser->input, '}') 
     2347                || CHECK(parser->input, '%') || CHECK(parser->input, '@') 
     2348                || CHECK(parser->input, '`'))) { 
     2349        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, type == YAML_ANCHOR_TOKEN ? 
     2350                "while scanning an anchor" : "while scanning an alias", 
     2351                start_mark, 
     2352                "did not find expected alphabetic or numeric character", 
     2353                parser->mark); 
    23592354        goto error; 
    23602355    } 
     
    23632358 
    23642359    if (type == YAML_ANCHOR_TOKEN) { 
    2365         ANCHOR_TOKEN_INIT(*token, string.start, start_mark, end_mark); 
     2360        ANCHOR_TOKEN_INIT(*token, string.buffer, start_mark, end_mark); 
    23662361    } 
    23672362    else { 
    2368         ALIAS_TOKEN_INIT(*token, string.start, start_mark, end_mark); 
     2363        ALIAS_TOKEN_INIT(*token, string.buffer, start_mark, end_mark); 
    23692364    } 
    23702365 
     
    23932388    if (!CACHE(parser, 2)) goto error; 
    23942389 
    2395     if (CHECK_AT(parser->buffer, '<', 1)) 
     2390    if (CHECK_AT(parser->input, '<', 1)) 
    23962391    { 
    23972392        /* Set the handle to '' */ 
     
    24132408        /* Check for '>' and eat it. */ 
    24142409 
    2415         if (!CHECK(parser->buffer, '>')) { 
    2416             yaml_parser_set_scanner_error(parser, "while scanning a tag", 
    2417                     start_mark, "did not find the expected '>'"); 
     2410        if (!CHECK(parser->input, '>')) { 
     2411            SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2412                    "while scanning a tag", start_mark, 
     2413                    "did not find the expected '>'", parser->mark); 
    24182414            goto error; 
    24192415        } 
     
    24712467    if (!CACHE(parser, 1)) goto error; 
    24722468 
    2473     if (!IS_BLANKZ(parser->buffer)) { 
    2474         yaml_parser_set_scanner_error(parser, "while scanning a tag", 
    2475                 start_mark, "did not found expected whitespace or line break"); 
     2469    if (!IS_BLANKZ(parser->input)) { 
     2470        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2471                "while scanning a tag", start_mark, 
     2472                "did not found expected whitespace or line break", parser->mark); 
    24762473        goto error; 
    24772474    } 
     
    25012498    yaml_string_t string = NULL_STRING; 
    25022499 
    2503     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
     2500    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2501        goto error; 
    25042502 
    25052503    /* Check the initial '!' character. */ 
     
    25072505    if (!CACHE(parser, 1)) goto error; 
    25082506 
    2509     if (!CHECK(parser->buffer, '!')) { 
    2510         yaml_parser_set_scanner_error(parser, directive ? 
     2507    if (!CHECK(parser->input, '!')) { 
     2508        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, directive ? 
    25112509                "while scanning a tag directive" : "while scanning a tag", 
    2512                 start_mark, "did not find expected '!'"); 
     2510                start_mark, "did not find expected '!'", parser->mark); 
    25132511        goto error; 
    25142512    } 
     
    25222520    if (!CACHE(parser, 1)) goto error; 
    25232521 
    2524     while (IS_ALPHA(parser->buffer)) 
     2522    while (IS_ALPHA(parser->input)) 
    25252523    { 
    25262524        if (!READ(parser, string)) goto error; 
     
    25302528    /* Check if the trailing character is '!' and copy it. */ 
    25312529 
    2532     if (CHECK(parser->buffer, '!')) 
     2530    if (CHECK(parser->input, '!')) 
    25332531    { 
    25342532        if (!READ(parser, string)) goto error; 
     
    25422540         */ 
    25432541 
    2544         if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) { 
    2545             yaml_parser_set_scanner_error(parser, "while parsing a tag directive", 
    2546                     start_mark, "did not find expected '!'"); 
     2542        if (directive && 
     2543                !(string.buffer[0] == '!' && string.buffer[1] == '\0')) { 
     2544            SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2545                    "while parsing a tag directive", start_mark, 
     2546                    "did not find expected '!'", parser->mark); 
    25472547            goto error; 
    25482548        } 
    25492549    } 
    25502550 
    2551     *handle = string.start; 
     2551    *handle = string.buffer; 
    25522552 
    25532553    return 1; 
     
    25692569    yaml_string_t string = NULL_STRING; 
    25702570 
    2571     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
     2571    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2572        goto error; 
    25722573 
    25732574    /* Resize the string to include the head. */ 
    25742575 
    2575     while (string.end - string.start <= (int)length) { 
    2576         if (!yaml_string_extend(&string.start, &string.pointer, &string.end)) { 
    2577             parser->error = YAML_MEMORY_ERROR; 
     2576    while (string.capacity <= length) { 
     2577        if (!yaml_string_extend(&string.buffer, &string.capacity)) { 
     2578            MEMORY_ERROR_INIT(parser); 
    25782579            goto error; 
    25792580        } 
     
    25872588 
    25882589    if (length > 1) { 
    2589         memcpy(string.start, head+1, length-1); 
     2590        memcpy(string.buffer, head+1, length-1); 
    25902591        string.pointer += length-1; 
    25912592    } 
     
    26032604     */ 
    26042605 
    2605     while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';') 
    2606             || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?') 
    2607             || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@') 
    2608             || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=') 
    2609             || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$') 
    2610             || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '.') 
    2611             || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~') 
    2612             || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'') 
    2613             || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')') 
    2614             || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']') 
    2615             || CHECK(parser->buffer, '%')) 
     2606    while (IS_ALPHA(parser->input) || CHECK(parser->input, ';') 
     2607            || CHECK(parser->input, '/') || CHECK(parser->input, '?') 
     2608            || CHECK(parser->input, ':') || CHECK(parser->input, '@') 
     2609            || CHECK(parser->input, '&') || CHECK(parser->input, '=') 
     2610            || CHECK(parser->input, '+') || CHECK(parser->input, '$') 
     2611            || CHECK(parser->input, ',') || CHECK(parser->input, '.') 
     2612            || CHECK(parser->input, '!') || CHECK(parser->input, '~') 
     2613            || CHECK(parser->input, '*') || CHECK(parser->input, '\'') 
     2614            || CHECK(parser->input, '(') || CHECK(parser->input, ')') 
     2615            || CHECK(parser->input, '[') || CHECK(parser->input, ']') 
     2616            || CHECK(parser->input, '%')) 
    26162617    { 
    26172618        /* Check if it is a URI-escape sequence. */ 
    26182619 
    2619         if (CHECK(parser->buffer, '%')) { 
     2620        if (CHECK(parser->input, '%')) { 
    26202621            if (!yaml_parser_scan_uri_escapes(parser, 
    26212622                        directive, start_mark, &string)) goto error; 
     
    26352636            goto error; 
    26362637 
    2637         yaml_parser_set_scanner_error(parser, directive ? 
     2638        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, directive ? 
    26382639                "while parsing a %TAG directive" : "while parsing a tag", 
    2639                 start_mark, "did not find expected tag URI"); 
     2640                start_mark, "did not find expected tag URI", parser->mark); 
    26402641        goto error; 
    26412642    } 
    26422643 
    2643     *uri = string.start; 
     2644    *uri = string.buffer; 
    26442645 
    26452646    return 1; 
     
    26632664 
    26642665    do { 
    2665  
    26662666        unsigned char octet = 0; 
    26672667 
     
    26702670        if (!CACHE(parser, 3)) return 0; 
    26712671 
    2672         if (!(CHECK(parser->buffer, '%') 
    2673                     && IS_HEX_AT(parser->buffer, 1) 
    2674                     && IS_HEX_AT(parser->buffer, 2))) { 
    2675             return yaml_parser_set_scanner_error(parser, directive ? 
     2672        if (!(CHECK(parser->input, '%') 
     2673                    && IS_HEX_AT(parser->input, 1) 
     2674                    && IS_HEX_AT(parser->input, 2))) { 
     2675            return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, directive ? 
    26762676                    "while parsing a %TAG directive" : "while parsing a tag", 
    2677                     start_mark, "did not find URI escaped octet"); 
     2677                    start_mark, "did not find URI escaped octet", parser->mark); 
    26782678        } 
    26792679 
    26802680        /* Get the octet. */ 
    26812681 
    2682         octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2); 
     2682        octet = (AS_HEX_AT(parser->input, 1) << 4) + AS_HEX_AT(parser->input, 2); 
    26832683 
    26842684        /* If it is the leading octet, determine the length of the UTF-8 sequence. */ 
     
    26912691                    (octet & 0xF8) == 0xF0 ? 4 : 0; 
    26922692            if (!width) { 
    2693                 return yaml_parser_set_scanner_error(parser, directive ? 
     2693                return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, directive ? 
    26942694                        "while parsing a %TAG directive" : "while parsing a tag", 
    2695                         start_mark, "found an incorrect leading UTF-8 octet"); 
     2695                        start_mark, "found an incorrect leading UTF-8 octet", 
     2696                        parser->mark); 
    26962697            } 
    26972698        } 
     
    27012702 
    27022703            if ((octet & 0xC0) != 0x80) { 
    2703                 return yaml_parser_set_scanner_error(parser, directive ? 
     2704                return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, directive ? 
    27042705                        "while parsing a %TAG directive" : "while parsing a tag", 
    2705                         start_mark, "found an incorrect trailing UTF-8 octet"); 
     2706                        start_mark, "found an incorrect trailing UTF-8 octet", 
     2707                        parser->mark); 
    27062708            } 
    27072709        } 
     
    27092711        /* Copy the octet and move the pointers. */ 
    27102712 
    2711         *(string->pointer++) = octet; 
     2713        JOIN_OCTET(*string, octet); 
    27122714        SKIP(parser); 
    27132715        SKIP(parser); 
     
    27382740    int trailing_blank = 0; 
    27392741 
    2740     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
    2741     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; 
    2742     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; 
     2742    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2743        goto error; 
     2744    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
     2745        goto error; 
     2746    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
     2747        goto error; 
    27432748 
    27442749    /* Eat the indicator '|' or '>'. */ 
     
    27542759    /* Check for a chomping indicator. */ 
    27552760 
    2756     if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) 
     2761    if (CHECK(parser->input, '+') || CHECK(parser->input, '-')) 
    27572762    { 
    27582763        /* Set the chomping method and eat the indicator. */ 
    27592764 
    2760         chomping = CHECK(parser->buffer, '+') ? +1 : -1; 
     2765        chomping = CHECK(parser->input, '+') ? +1 : -1; 
    27612766 
    27622767        SKIP(parser); 
     
    27662771        if (!CACHE(parser, 1)) goto error; 
    27672772 
    2768         if (IS_DIGIT(parser->buffer)) 
     2773        if (IS_DIGIT(parser->input)) 
    27692774        { 
    27702775            /* Check that the intendation is greater than 0. */ 
    27712776 
    2772             if (CHECK(parser->buffer, '0')) { 
    2773                 yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 
    2774                         start_mark, "found an intendation indicator equal to 0"); 
     2777            if (CHECK(parser->input, '0')) { 
     2778                SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2779                        "while scanning a block scalar", start_mark, 
     2780                        "found an intendation indicator equal to 0", parser->mark); 
    27752781                goto error; 
    27762782            } 
     
    27782784            /* Get the intendation level and eat the indicator. */ 
    27792785 
    2780             increment = AS_DIGIT(parser->buffer); 
     2786            increment = AS_DIGIT(parser->input); 
    27812787 
    27822788            SKIP(parser); 
     
    27862792    /* Do the same as above, but in the opposite order. */ 
    27872793 
    2788     else if (IS_DIGIT(parser->buffer)) 
     2794    else if (IS_DIGIT(parser->input)) 
    27892795    { 
    2790         if (CHECK(parser->buffer, '0')) { 
    2791             yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 
    2792                     start_mark, "found an intendation indicator equal to 0"); 
     2796        if (CHECK(parser->input, '0')) { 
     2797            SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2798                    "while scanning a block scalar", start_mark, 
     2799                    "found an intendation indicator equal to 0", parser->mark); 
    27932800            goto error; 
    27942801        } 
    27952802 
    2796         increment = AS_DIGIT(parser->buffer); 
     2803        increment = AS_DIGIT(parser->input); 
    27972804 
    27982805        SKIP(parser); 
     
    28002807        if (!CACHE(parser, 1)) goto error; 
    28012808 
    2802         if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) { 
    2803             chomping = CHECK(parser->buffer, '+') ? +1 : -1; 
     2809        if (CHECK(parser->input, '+') || CHECK(parser->input, '-')) { 
     2810            chomping = CHECK(parser->input, '+') ? +1 : -1; 
    28042811 
    28052812            SKIP(parser); 
     
    28112818    if (!CACHE(parser, 1)) goto error; 
    28122819 
    2813     while (IS_BLANK(parser->buffer)) { 
     2820    while (IS_BLANK(parser->input)) { 
    28142821        SKIP(parser); 
    28152822        if (!CACHE(parser, 1)) goto error; 
    28162823    } 
    28172824 
    2818     if (CHECK(parser->buffer, '#')) { 
    2819         while (!IS_BREAKZ(parser->buffer)) { 
     2825    if (CHECK(parser->input, '#')) { 
     2826        while (!IS_BREAKZ(parser->input)) { 
    28202827            SKIP(parser); 
    28212828            if (!CACHE(parser, 1)) goto error; 
     
    28252832    /* Check if we are at the end of the line. */ 
    28262833 
    2827     if (!IS_BREAKZ(parser->buffer)) { 
    2828         yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 
    2829                 start_mark, "did not found expected comment or line break"); 
     2834    if (!IS_BREAKZ(parser->input)) { 
     2835        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2836                "while scanning a block scalar", start_mark, 
     2837                "did not found expected comment or line break", parser->mark); 
    28302838        goto error; 
    28312839    } 
     
    28332841    /* Eat a line break. */ 
    28342842 
    2835     if (IS_BREAK(parser->buffer)) { 
     2843    if (IS_BREAK(parser->input)) { 
    28362844        if (!CACHE(parser, 2)) goto error; 
    28372845        SKIP_LINE(parser); 
     
    28552863    if (!CACHE(parser, 1)) goto error; 
    28562864 
    2857     while ((int)parser->mark.column == indent && !IS_Z(parser->buffer)) 
     2865    while ((int)parser->mark.column == indent && !IS_Z(parser->input)) 
    28582866    { 
    28592867        /* 
     
    28632871        /* Is it a trailing whitespace? */ 
    28642872 
    2865         trailing_blank = IS_BLANK(parser->buffer); 
     2873        trailing_blank = IS_BLANK(parser->input); 
    28662874 
    28672875        /* Check if we need to fold the leading line break. */ 
    28682876 
    2869         if (!literal && (*leading_break.start == '\n') 
     2877        if (!literal && (*leading_break.buffer == '\n') 
    28702878                && !leading_blank && !trailing_blank) 
    28712879        { 
    28722880            /* Do we need to join the lines by space? */ 
    28732881 
    2874             if (*trailing_breaks.start == '\0') { 
     2882            if (*trailing_breaks.buffer == '\0') { 
    28752883                if (!STRING_EXTEND(parser, string)) goto error; 
    2876                 *(string.pointer ++) = ' '; 
     2884                JOIN_OCTET(string, ' '); 
    28772885            } 
    28782886 
     
    28912899        /* Is it a leading whitespace? */ 
    28922900 
    2893         leading_blank = IS_BLANK(parser->buffer); 
     2901        leading_blank = IS_BLANK(parser->input); 
    28942902 
    28952903        /* Consume the current line. */ 
    28962904 
    2897         while (!IS_BREAKZ(parser->buffer)) { 
     2905        while (!IS_BREAKZ(parser->input)) { 
    28982906            if (!READ(parser, string)) goto error; 
    28992907            if (!CACHE(parser, 1)) goto error; 
     
    29232931    /* Create a token. */ 
    29242932 
    2925     SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, 
     2933    SCALAR_TOKEN_INIT(*token, string.buffer, string.pointer, 
    29262934            literal ? YAML_LITERAL_SCALAR_STYLE : YAML_FOLDED_SCALAR_STYLE, 
    29272935            start_mark, end_mark); 
     
    29632971 
    29642972        while ((!*indent || (int)parser->mark.column < *indent) 
    2965                 && IS_SPACE(parser->buffer)) { 
     2973                && IS_SPACE(parser->input)) { 
    29662974            SKIP(parser); 
    29672975            if (!CACHE(parser, 1)) return 0; 
     
    29742982 
    29752983        if ((!*indent || (int)parser->mark.column < *indent) 
    2976                 && IS_TAB(parser->buffer)) { 
    2977             return yaml_parser_set_scanner_error(parser, "while scanning a block scalar", 
    2978                     start_mark, "found a tab character where an intendation space is expected"); 
     2984                && IS_TAB(parser->input)) { 
     2985            return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     2986                    "while scanning a block scalar", start_mark, 
     2987                    "found a tab character where an intendation space is expected", 
     2988                    parser->mark); 
    29792989        } 
    29802990 
    29812991        /* Have we found a non-empty line? */ 
    29822992 
    2983         if (!IS_BREAK(parser->buffer)) break; 
     2993        if (!IS_BREAK(parser->input)) break; 
    29842994 
    29852995        /* Consume the line break. */ 
     
    30193029    int leading_blanks; 
    30203030 
    3021     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
    3022     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; 
    3023     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; 
    3024     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error; 
     3031    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     3032        goto error; 
     3033    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
     3034        goto error; 
     3035    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
     3036        goto error; 
     3037    if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) 
     3038        goto error; 
    30253039 
    30263040    /* Eat the left quote. */ 
     
    30393053 
    30403054        if (parser->mark.column == 0 && 
    3041             ((CHECK_AT(parser->buffer, '-', 0) && 
    3042               CHECK_AT(parser->buffer, '-', 1) && 
    3043               CHECK_AT(parser->buffer, '-', 2)) || 
    3044              (CHECK_AT(parser->buffer, '.', 0) && 
    3045               CHECK_AT(parser->buffer, '.', 1) && 
    3046               CHECK_AT(parser->buffer, '.', 2))) && 
    3047             IS_BLANKZ_AT(parser->buffer, 3)) 
     3055            ((CHECK_AT(parser->input, '-', 0) && 
     3056              CHECK_AT(parser->input, '-', 1) && 
     3057              CHECK_AT(parser->input, '-', 2)) || 
     3058             (CHECK_AT(parser->input, '.', 0) && 
     3059              CHECK_AT(parser->input, '.', 1) && 
     3060              CHECK_AT(parser->input, '.', 2))) && 
     3061            IS_BLANKZ_AT(parser->input, 3)) 
    30483062        { 
    3049             yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", 
    3050                     start_mark, "found unexpected document indicator"); 
     3063            SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     3064                    "while scanning a quoted scalar", start_mark, 
     3065                    "found unexpected document indicator", parser->mark); 
    30513066            goto error; 
    30523067        } 
     
    30543069        /* Check for EOF. */ 
    30553070 
    3056         if (IS_Z(parser->buffer)) { 
    3057             yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", 
    3058                     start_mark, "found unexpected end of stream"); 
     3071        if (IS_Z(parser->input)) { 
     3072            SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     3073                    "while scanning a quoted scalar", start_mark, 
     3074                    "found unexpected end of stream", parser->mark); 
    30593075            goto error; 
    30603076        } 
     
    30663082        leading_blanks = 0; 
    30673083 
    3068         while (!IS_BLANKZ(parser->buffer)) 
     3084        while (!IS_BLANKZ(parser->input)) 
    30693085        { 
    30703086            /* Check for an escaped single quote. */ 
    30713087 
    3072             if (single && CHECK_AT(parser->buffer, '\'', 0) 
    3073                     && CHECK_AT(parser->buffer, '\'', 1)) 
     3088            if (single && CHECK_AT(parser->input, '\'', 0) 
     3089                    && CHECK_AT(parser->input, '\'', 1)) 
    30743090            { 
    30753091                if (!STRING_EXTEND(parser, string)) goto error; 
    3076                 *(string.pointer++) = '\''; 
     3092                JOIN_OCTET(string, '\''); 
    30773093                SKIP(parser); 
    30783094                SKIP(parser); 
     
    30813097            /* Check for the right quote. */ 
    30823098 
    3083             else if (CHECK(parser->buffer, single ? '\'' : '"')) 
     3099            else if (CHECK(parser->input, single ? '\'' : '"')) 
    30843100            { 
    30853101                break; 
     
    30883104            /* Check for an escaped line break. */ 
    30893105 
    3090             else if (!single && CHECK(parser->buffer, '\\') 
    3091                     && IS_BREAK_AT(parser->buffer, 1)) 
     3106            else if (!single && CHECK(parser->input, '\\') 
     3107                    && IS_BREAK_AT(parser->input, 1)) 
    30923108            { 
    30933109                if (!CACHE(parser, 3)) goto error; 
     
    31003116            /* Check for an escape sequence. */ 
    31013117 
    3102             else if (!single && CHECK(parser->buffer, '\\')) 
     3118            else if (!single && CHECK(parser->input, '\\')) 
    31033119            { 
    31043120                size_t code_length = 0; 
     
    31083124                /* Check the escape character. */ 
    31093125 
    3110                 switch (parser->buffer.pointer[1]) 
     3126                switch (OCTET_AT(parser->input, 1)) 
    31113127                { 
    31123128                    case '0': 
    3113                         *(string.pointer++) = '\0'; 
     3129                        JOIN_OCTET(string, '\0'); 
    31143130                        break; 
    31153131 
    31163132                    case 'a': 
    3117                         *(string.pointer++) = '\x07'; 
     3133                        JOIN_OCTET(string, '\x07'); 
    31183134                        break; 
    31193135 
    31203136                    case 'b': 
    3121                         *(string.pointer++) = '\x08'; 
     3137                        JOIN_OCTET(string, '\x08'); 
    31223138                        break; 
    31233139 
    31243140                    case 't': 
    31253141                    case '\t': 
    3126                         *(string.pointer++) = '\x09'; 
     3142                        JOIN_OCTET(string, '\x09'); 
    31273143                        break; 
    31283144 
    31293145                    case 'n': 
    3130                         *(string.pointer++) = '\x0A'; 
     3146                        JOIN_OCTET(string, '\x0A'); 
    31313147                        break; 
    31323148 
    31333149                    case 'v': 
    3134                         *(string.pointer++) = '\x0B'; 
     3150                        JOIN_OCTET(string, '\x0B'); 
    31353151                        break; 
    31363152 
    31373153                    case 'f': 
    3138                         *(string.pointer++) = '\x0C'; 
     3154                        JOIN_OCTET(string, '\x0C'); 
    31393155                        break; 
    31403156 
    31413157                    case 'r': 
    3142                         *(string.pointer++) = '\x0D'; 
     3158                        JOIN_OCTET(string, '\x0D'); 
    31433159                        break; 
    31443160 
    31453161                    case 'e': 
    3146                         *(string.pointer++) = '\x1B'; 
     3162                        JOIN_OCTET(string, '\x1B'); 
    31473163                        break; 
    31483164 
    31493165                    case ' ': 
    3150                         *(string.pointer++) = '\x20'; 
     3166                        JOIN_OCTET(string, '\x20'); 
    31513167                        break; 
    31523168 
    31533169                    case '"': 
    3154                         *(string.pointer++) = '"'; 
     3170                        JOIN_OCTET(string, '"'); 
    31553171                        break; 
    31563172 
    31573173                    case '\'': 
    3158                         *(string.pointer++) = '\''; 
     3174                        JOIN_OCTET(string, '\''); 
    31593175                        break; 
    31603176 
    31613177                    case '\\': 
    3162                         *(string.pointer++) = '\\'; 
     3178                        JOIN_OCTET(string, '\\'); 
    31633179                        break; 
    31643180 
    31653181                    case 'N':   /* NEL (#x85) */ 
    3166                         *(string.pointer++) = '\xC2'; 
    3167                         *(string.pointer++) = '\x85'; 
     3182                        JOIN_OCTET(string, '\xC2'); 
     3183                        JOIN_OCTET(string, '\x85'); 
    31683184                        break; 
    31693185 
    31703186                    case '_':   /* #xA0 */ 
    3171                         *(string.pointer++) = '\xC2'; 
    3172                         *(string.pointer++) = '\xA0'; 
     3187                        JOIN_OCTET(string, '\xC2'); 
     3188                        JOIN_OCTET(string, '\xA0'); 
    31733189                        break; 
    31743190 
    31753191                    case 'L':   /* LS (#x2028) */ 
    3176                         *(string.pointer++) = '\xE2'; 
    3177                         *(string.pointer++) = '\x80'; 
    3178                         *(string.pointer++) = '\xA8'; 
     3192                        JOIN_OCTET(string, '\xE2'); 
     3193                        JOIN_OCTET(string, '\x80'); 
     3194                        JOIN_OCTET(string, '\xA8'); 
    31793195                        break; 
    31803196 
    31813197                    case 'P':   /* PS (#x2029) */ 
    3182                         *(string.pointer++) = '\xE2'; 
    3183                         *(string.pointer++) = '\x80'; 
    3184                         *(string.pointer++) = '\xA9'; 
     3198                        JOIN_OCTET(string, '\xE2'); 
     3199                        JOIN_OCTET(string, '\x80'); 
     3200                        JOIN_OCTET(string, '\xA9'); 
    31853201                        break; 
    31863202 
     
    31983214 
    31993215                    default: 
    3200                         yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", 
    3201                                 start_mark, "found unknown escape character"); 
     3216                        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     3217                                "while parsing a quoted scalar", start_mark, 
     3218                                "found unknown escape character", parser->mark); 
    32023219                        goto error; 
    32033220                } 
     
    32113228                { 
    32123229                    unsigned int value = 0; 
    3213                     size_t k; 
     3230                    size_t idx; 
    32143231 
    32153232                    /* Scan the character value. */ 
     
    32173234                    if (!CACHE(parser, code_length)) goto error; 
    32183235 
    3219                     for (k = 0; k < code_length; k ++) { 
    3220                         if (!IS_HEX_AT(parser->buffer, k)) { 
    3221                             yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", 
    3222                                     start_mark, "did not find expected hexdecimal number"); 
     3236                    for (idx = 0; idx < code_length; idx ++) { 
     3237                        if (!IS_HEX_AT(parser->input, idx)) { 
     3238                            SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     3239                                    "while parsing a quoted scalar", start_mark, 
     3240                                    "did not find expected hexdecimal number", 
     3241                                    parser->mark); 
    32233242                            goto error; 
    32243243                        } 
    3225                         value = (value << 4) + AS_HEX_AT(parser->buffer, k); 
     3244                        value = (value << 4) + AS_HEX_AT(parser->input, idx); 
    32263245                    } 
    32273246 
     
    32293248 
    32303249                    if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) { 
    3231                         yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", 
    3232                                 start_mark, "found invalid Unicode character escape code"); 
     3250                        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     3251                                "while parsing a quoted scalar", start_mark, 
     3252                                "found invalid Unicode character escape code", 
     3253                                parser->mark); 
    32333254                        goto error; 
    32343255                    } 
    32353256 
    32363257                    if (value <= 0x7F) { 
    3237                         *(string.pointer++) = value; 
     3258                        JOIN_OCTET(string, value); 
    32383259                    } 
    32393260                    else if (value <= 0x7FF) { 
    3240                         *(string.pointer++) = 0xC0 + (value >> 6); 
    3241                         *(string.pointer++) = 0x80 + (value & 0x3F); 
     3261                        JOIN_OCTET(string, 0xC0 + (value >> 6)); 
     3262                        JOIN_OCTET(string, 0x80 + (value & 0x3F)); 
    32423263                    } 
    32433264                    else if (value <= 0xFFFF) { 
    3244                         *(string.pointer++) = 0xE0 + (value >> 12); 
    3245                         *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F); 
    3246                         *(string.pointer++) = 0x80 + (value & 0x3F); 
     3265                        JOIN_OCTET(string, 0xE0 + (value >> 12)); 
     3266                        JOIN_OCTET(string, 0x80 + ((value >> 6) & 0x3F)); 
     3267                        JOIN_OCTET(string, 0x80 + (value & 0x3F)); 
    32473268                    } 
    32483269                    else { 
    3249                         *(string.pointer++) = 0xF0 + (value >> 18); 
    3250                         *(string.pointer++) = 0x80 + ((value >> 12) & 0x3F); 
    3251                         *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F); 
    3252                         *(string.pointer++) = 0x80 + (value & 0x3F); 
     3270                        JOIN_OCTET(string, 0xF0 + (value >> 18)); 
     3271                        JOIN_OCTET(string, 0x80 + ((value >> 12) & 0x3F)); 
     3272                        JOIN_OCTET(string, 0x80 + ((value >> 6) & 0x3F)); 
     3273                        JOIN_OCTET(string, 0x80 + (value & 0x3F)); 
    32533274                    } 
    32543275 
    32553276                    /* Advance the pointer. */ 
    32563277 
    3257                     for (k = 0; k < code_length; k ++) { 
     3278                    for (idx = 0; idx < code_length; idx ++) { 
    32583279                        SKIP(parser); 
    32593280                    } 
     
    32733294        /* Check if we are at the end of the scalar. */ 
    32743295 
    3275         if (CHECK(parser->buffer, single ? '\'' : '"')) 
     3296        if (CHECK(parser->input, single ? '\'' : '"')) 
    32763297            break; 
    32773298 
     
    32803301        if (!CACHE(parser, 1)) goto error; 
    32813302 
    3282         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) 
     3303        while (IS_BLANK(parser->input) || IS_BREAK(parser->input)) 
    32833304        { 
    3284             if (IS_BLANK(parser->buffer)) 
     3305            if (IS_BLANK(parser->input)) 
    32853306            { 
    32863307                /* Consume a space or a tab character. */ 
     
    33193340            /* Do we need to fold line breaks? */ 
    33203341 
    3321             if (leading_break.start[0] == '\n') { 
    3322                 if (trailing_breaks.start[0] == '\0') { 
     3342            if (leading_break.buffer[0] == '\n') { 
     3343                if (trailing_breaks.buffer[0] == '\0') { 
    33233344                    if (!STRING_EXTEND(parser, string)) goto error; 
    3324                     *(string.pointer++) = ' '; 
     3345                    JOIN_OCTET(string, ' '); 
    33253346                } 
    33263347                else { 
     
    33523373    /* Create a token. */ 
    33533374 
    3354     SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, 
     3375    SCALAR_TOKEN_INIT(*token, string.buffer, string.pointer, 
    33553376            single ? YAML_SINGLE_QUOTED_SCALAR_STYLE : YAML_DOUBLE_QUOTED_SCALAR_STYLE, 
    33563377            start_mark, end_mark); 
     
    33873408    int indent = parser->indent+1; 
    33883409 
    3389     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error; 
    3390     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error; 
    3391     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error; 
    3392     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error; 
     3410    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     3411        goto error; 
     3412    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
     3413        goto error; 
     3414    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
     3415        goto error; 
     3416    if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) 
     3417        goto error; 
    33933418 
    33943419    start_mark = end_mark = parser->mark; 
     
    34033428 
    34043429        if (parser->mark.column == 0 && 
    3405             ((CHECK_AT(parser->buffer, '-', 0) && 
    3406               CHECK_AT(parser->buffer, '-', 1) && 
    3407               CHECK_AT(parser->buffer, '-', 2)) || 
    3408              (CHECK_AT(parser->buffer, '.', 0) && 
    3409               CHECK_AT(parser->buffer, '.', 1) && 
    3410               CHECK_AT(parser->buffer, '.', 2))) && 
    3411             IS_BLANKZ_AT(parser->buffer, 3)) break; 
     3430            ((CHECK_AT(parser->input, '-', 0) && 
     3431              CHECK_AT(parser->input, '-', 1) && 
     3432              CHECK_AT(parser->input, '-', 2)) || 
     3433             (CHECK_AT(parser->input, '.', 0) && 
     3434              CHECK_AT(parser->input, '.', 1) && 
     3435              CHECK_AT(parser->input, '.', 2))) && 
     3436            IS_BLANKZ_AT(parser->input, 3)) break; 
    34123437 
    34133438        /* Check for a comment. */ 
    34143439 
    3415         if (CHECK(parser->buffer, '#')) 
     3440        if (CHECK(parser->input, '#')) 
    34163441            break; 
    34173442 
    34183443        /* Consume non-blank characters. */ 
    34193444 
    3420         while (!IS_BLANKZ(parser->buffer)) 
     3445        while (!IS_BLANKZ(parser->input)) 
    34213446        { 
    34223447            /* Check for 'x:x' in the flow context. TODO: Fix the test "spec-08-13". */ 
    34233448 
    34243449            if (parser->flow_level 
    3425                     && CHECK(parser->buffer, ':') 
    3426                     && !IS_BLANKZ_AT(parser->buffer, 1)) { 
    3427                 yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", 
    3428                         start_mark, "found unexpected ':'"); 
     3450                    && CHECK(parser->input, ':') 
     3451                    && !IS_BLANKZ_AT(parser->input, 1)) { 
     3452                SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     3453                        "while scanning a plain scalar", start_mark, 
     3454                        "found unexpected ':'", parser->mark); 
    34293455                goto error; 
    34303456            } 
     
    34323458            /* Check for indicators that may end a plain scalar. */ 
    34333459 
    3434             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1)) 
     3460            if ((CHECK(parser->input, ':') && IS_BLANKZ_AT(parser->input, 1)) 
    34353461                    || (parser->flow_level && 
    3436                         (CHECK(parser->buffer, ',') || CHECK(parser->buffer, ':') 
    3437                          || CHECK(parser->buffer, '?') || CHECK(parser->buffer, '[') 
    3438                          || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{') 
    3439                          || CHECK(parser->buffer, '}')))) 
     3462                        (CHECK(parser->input, ',') || CHECK(parser->input, ':') 
     3463                         || CHECK(parser->input, '?') || CHECK(parser->input, '[') 
     3464                         || CHECK(parser->input, ']') || CHECK(parser->input, '{') 
     3465                         || CHECK(parser->input, '}')))) 
    34403466                break; 
    34413467 
    34423468            /* Check if we need to join whitespaces and breaks. */ 
    34433469 
    3444             if (leading_blanks || whitespaces.start != whitespaces.pointer) 
     3470            if (leading_blanks || whitespaces.pointer > 0) 
    34453471            { 
    34463472                if (leading_blanks) 
     
    34483474                    /* Do we need to fold line breaks? */ 
    34493475 
    3450                     if (leading_break.start[0] == '\n') { 
    3451                         if (trailing_breaks.start[0] == '\0') { 
     3476                    if (leading_break.buffer[0] == '\n') { 
     3477                        if (trailing_breaks.buffer[0] == '\0') { 
    34523478                            if (!STRING_EXTEND(parser, string)) goto error; 
    3453                             *(string.pointer++) = ' '; 
     3479                            JOIN_OCTET(string, ' '); 
    34543480                        } 
    34553481                        else { 
     
    34863512        /* Is it the end? */ 
    34873513 
    3488         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))) 
     3514        if (!(IS_BLANK(parser->input) || IS_BREAK(parser->input))) 
    34893515            break; 
    34903516 
     
    34933519        if (!CACHE(parser, 1)) goto error; 
    34943520 
    3495         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)) 
     3521        while (IS_BLANK(parser->input) || IS_BREAK(parser->input)) 
    34963522        { 
    3497             if (IS_BLANK(parser->buffer)) 
     3523            if (IS_BLANK(parser->input)) 
    34983524            { 
    34993525                /* Check for tab character that abuse intendation. */ 
    35003526 
    35013527                if (leading_blanks && (int)parser->mark.column < indent 
    3502                         && IS_TAB(parser->buffer)) { 
    3503                     yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", 
    3504                             start_mark, "found a tab character that violate intendation"); 
     3528                        && IS_TAB(parser->input)) { 
     3529                    SCANNER_ERROR_WITH_CONTEXT_INIT(parser, 
     3530                            "while scanning a plain scalar", start_mark, 
     3531                            "found a tab character that violate intendation", 
     3532                            parser->mark); 
    35053533                    goto error; 
    35063534                } 
     
    35433571    /* Create a token. */ 
    35443572 
    3545     SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start, 
     3573    SCALAR_TOKEN_INIT(*token, string.buffer, string.pointer, 
    35463574            YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark); 
    35473575 
    3548     /* Note that we change the 'simple_key_allowed' flag. */ 
     3576    /* Note that we change the 'is_simple_key_allowed' flag. */ 
    35493577 
    35503578    if (leading_blanks) { 
    3551         parser->simple_key_allowed = 1; 
     3579        parser->is_simple_key_allowed = 1; 
    35523580    } 
    35533581 
Note: See TracChangeset for help on using the changeset viewer.