Ignore:
Timestamp:
12/27/07 12:14:01 (7 years ago)
Author:
xi
Message:

Another round of API update.

File:
1 edited

Legend:

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

    r263 r264  
    3636    /* Ensure that we had enough bytes in the raw buffer. */ 
    3737 
    38     while (!parser->is_eof && parser->raw_input.capacity < 3) { 
     38    while (!parser->is_eof && parser->raw_input.length < 3) { 
    3939        if (!yaml_parser_update_raw_buffer(parser)) { 
    4040            return 0; 
     
    4444    /* Determine the encoding. */ 
    4545 
    46     if (parser->raw_input.capacity >= 2 
     46    if (parser->raw_input.length >= 2 
    4747            && !memcmp(parser->raw_input.buffer, BOM_UTF16LE, 2)) { 
    4848        parser->encoding = YAML_UTF16LE_ENCODING; 
     
    5050        parser->offset = 2; 
    5151    } 
    52     else if (parser->raw_input.capacity >= 2 
     52    else if (parser->raw_input.length >= 2 
    5353            && !memcmp(parser->raw_input.buffer, BOM_UTF16BE, 2)) { 
    5454        parser->encoding = YAML_UTF16BE_ENCODING; 
     
    5656        parser->offset = 2; 
    5757    } 
    58     else if (parser->raw_input.capacity >= 3 
     58    else if (parser->raw_input.length >= 3 
    5959            && !memcmp(parser->raw_input.buffer, BOM_UTF8, 3)) { 
    6060        parser->encoding = YAML_UTF8_ENCODING; 
     
    8181 
    8282    if (parser->raw_input.pointer == 0 && 
    83             parser->raw_input.capacity == RAW_INPUT_BUFFER_CAPACITY) 
     83            parser->raw_input.length == parser->raw_input.capacity) 
    8484        return 1; 
    8585 
     
    9292 
    9393    if (parser->raw_input.pointer > 0 && 
    94             parser->raw_input.pointer < parser->raw_input.capacity) { 
     94            parser->raw_input.pointer < parser->raw_input.length) { 
    9595        memmove(parser->raw_input.buffer, 
    9696                parser->raw_input.buffer + parser->raw_input.pointer, 
    97                 parser->raw_input.capacity - parser->raw_input.pointer); 
    98     } 
    99     parser->raw_input.capacity -= parser->raw_input.pointer; 
     97                parser->raw_input.length - parser->raw_input.pointer); 
     98    } 
     99    parser->raw_input.length -= parser->raw_input.pointer; 
    100100    parser->raw_input.pointer = 0; 
    101101 
     
    103103 
    104104    if (!parser->reader(parser->reader_data, 
    105                 parser->raw_input.buffer + parser->raw_input.capacity, 
    106                 RAW_INPUT_BUFFER_CAPACITY - parser->raw_input.capacity, 
     105                parser->raw_input.buffer + parser->raw_input.length, 
     106                parser->raw_input.capacity - parser->raw_input.length, 
    107107                &length)) { 
    108         return READER_ERROR_INIT(parser, "Input error", parser->offset); 
    109     } 
    110     parser->raw_input.capacity += length; 
     108        return READER_ERROR_INIT(parser, "read handler error", parser->offset); 
     109    } 
     110    parser->raw_input.length += length; 
    111111    if (!length) { 
    112112        parser->is_eof = 1; 
     
    126126yaml_parser_update_buffer(yaml_parser_t *parser, size_t length) 
    127127{ 
    128     size_t old_capacity; 
    129  
    130128    assert(parser->reader); /* Read handler must be set. */ 
    131129 
    132130    /* If the EOF flag is set and the raw buffer is empty, do nothing. */ 
    133131 
    134     if (parser->is_eof && parser->raw_input.pointer == parser->raw_input.capacity) 
     132    if (parser->is_eof && parser->raw_input.pointer == parser->raw_input.length) 
    135133        return 1; 
    136134 
     
    150148 
    151149    if (parser->input.pointer > 0 && 
    152             parser->input.pointer < parser->input.capacity) { 
     150            parser->input.pointer < parser->input.length) { 
    153151        memmove(parser->input.buffer, 
    154152                parser->input.buffer + parser->input.pointer, 
    155                 parser->input.capacity - parser->input.pointer); 
    156         parser->input.capacity -= parser->input.pointer; 
    157     } 
    158     else if (parser->input.pointer == parser->input.capacity) { 
    159         parser->input.capacity = 0; 
    160     } 
    161  
    162     /* Set the pointer to the end of the buffer. */ 
    163  
    164     parser->input.pointer = parser->input.capacity; 
     153                parser->input.length - parser->input.pointer); 
     154        parser->input.length -= parser->input.pointer; 
     155    } 
     156    else if (parser->input.pointer == parser->input.length) { 
     157        parser->input.length = 0; 
     158    } 
     159 
     160    /* Switch the buffer to the output mode. */ 
     161 
     162    parser->input.pointer = parser->input.length; 
    165163 
    166164    /* Fill the buffer until it has enough characters. */ 
     
    174172        /* Decode the raw buffer. */ 
    175173 
    176         while (parser->raw_input.pointer != parser->raw_input.capacity) 
     174        while (parser->raw_input.pointer < parser->raw_input.length) 
    177175        { 
    178176            size_t raw_unread = 
    179                 parser->raw_input.capacity - parser->raw_input.pointer; 
     177                parser->raw_input.length - parser->raw_input.pointer; 
    180178            unsigned int value = 0, value2 = 0; 
    181179            int is_incomplete = 0; 
     
    223221                    if (!width) 
    224222                        return DECODER_ERROR_INIT(parser, 
    225                                 "Invalid leading UTF-8 octet", 
     223                                "invalid leading UTF-8 octet", 
    226224                                parser->offset, octet); 
    227225 
     
    231229                        if (parser->is_eof) { 
    232230                            return DECODER_ERROR_INIT(parser, 
    233                                     "Incomplete UTF-8 octet sequence", 
     231                                    "incomplete UTF-8 octet sequence", 
    234232                                    parser->offset, -1); 
    235233                        } 
     
    255253                        if ((octet & 0xC0) != 0x80) 
    256254                            return DECODER_ERROR_INIT(parser, 
    257                                     "Invalid trailing UTF-8 octet", 
     255                                    "invalid trailing UTF-8 octet", 
    258256                                    parser->offset+idx, octet); 
    259257 
     
    270268                            (width == 4 && value >= 0x10000))) 
    271269                        return DECODER_ERROR_INIT(parser, 
    272                                 "Invalid length of a UTF-8 sequence", 
     270                                "invalid length of a UTF-8 sequence", 
    273271                                parser->offset, -1); 
    274272 
     
    277275                    if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) 
    278276                        return DECODER_ERROR_INIT(parser, 
    279                                 "Invalid Unicode character", 
     277                                "invalid Unicode character", 
    280278                                parser->offset, value); 
    281279 
     
    319317                        if (parser->is_eof) { 
    320318                            return DECODER_ERROR_INIT(parser, 
    321                                     "Incomplete UTF-16 character", 
     319                                    "incomplete UTF-16 character", 
    322320                                    parser->offset, -1); 
    323321                        } 
     
    335333                    if ((value & 0xFC00) == 0xDC00) 
    336334                        return DECODER_ERROR_INIT(parser, 
    337                                 "Unexpected low surrogate area", 
     335                                "unexpected low surrogate area", 
    338336                                parser->offset, value); 
    339337 
     
    349347                            if (parser->is_eof) { 
    350348                                return DECODER_ERROR_INIT(parser, 
    351                                         "Incomplete UTF-16 surrogate pair", 
     349                                        "incomplete UTF-16 surrogate pair", 
    352350                                        parser->offset, -1); 
    353351                            } 
     
    365363                        if ((value2 & 0xFC00) != 0xDC00) 
    366364                            return DECODER_ERROR_INIT(parser, 
    367                                     "Expected low surrogate area", 
     365                                    "expected low surrogate area", 
    368366                                    parser->offset+2, value2); 
    369367 
     
    380378 
    381379                default: 
    382                     assert(1);      /* Impossible. */ 
     380                    assert(0);      /* Impossible. */ 
    383381            } 
    384382 
     
    401399                        || (value >= 0x10000 && value <= 0x10FFFF))) 
    402400                return DECODER_ERROR_INIT(parser, 
    403                         "Control characters are not allowed", 
     401                        "control characters are not allowed", 
    404402                        parser->offset, value); 
    405403 
     
    446444 
    447445    } 
    448     /* Swap the pointer with the end of the buffer. */ 
    449  
    450     old_capacity = parser->input.capacity; 
    451     parser->input.capacity = parser->input.pointer; 
    452     parser->input.pointer = old_capacity; 
     446 
     447    /* Switch the the buffer back to the input mode. */ 
     448 
     449    parser->input.length = parser->input.pointer; 
     450    parser->input.pointer = 0; 
    453451 
    454452    return 1; 
Note: See TracChangeset for help on using the changeset viewer.