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

Completed the first phase of API refactoring.

File:
1 edited

Legend:

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

    r262 r263  
    3636    /* Ensure that we had enough bytes in the raw buffer. */ 
    3737 
    38     while (!parser->is_eof && parser->raw_input.length < 3) { 
     38    while (!parser->is_eof && parser->raw_input.capacity < 3) { 
    3939        if (!yaml_parser_update_raw_buffer(parser)) { 
    4040            return 0; 
     
    4444    /* Determine the encoding. */ 
    4545 
    46     if (parser->raw_input.length >= 2 
     46    if (parser->raw_input.capacity >= 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.length >= 2 
     52    else if (parser->raw_input.capacity >= 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.length >= 3 
     58    else if (parser->raw_input.capacity >= 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.length == parser->raw_input.capacity) 
     83            parser->raw_input.capacity == RAW_INPUT_BUFFER_CAPACITY) 
    8484        return 1; 
    8585 
     
    9292 
    9393    if (parser->raw_input.pointer > 0 && 
    94             parser->raw_input.pointer < parser->raw_input.length) { 
     94            parser->raw_input.pointer < parser->raw_input.capacity) { 
    9595        memmove(parser->raw_input.buffer, 
    9696                parser->raw_input.buffer + parser->raw_input.pointer, 
    97                 parser->raw_input.length - parser->raw_input.pointer); 
    98     } 
     97                parser->raw_input.capacity - parser->raw_input.pointer); 
     98    } 
     99    parser->raw_input.capacity -= parser->raw_input.pointer; 
    99100    parser->raw_input.pointer = 0; 
    100101 
     
    102103 
    103104    if (!parser->reader(parser->reader_data, 
    104                 parser->raw_input.buffer + parser->raw_input.length, 
    105                 parser->raw_input.capacity - parser->raw_input.length, 
     105                parser->raw_input.buffer + parser->raw_input.capacity, 
     106                RAW_INPUT_BUFFER_CAPACITY - parser->raw_input.capacity, 
    106107                &length)) { 
    107108        return READER_ERROR_INIT(parser, "Input error", parser->offset); 
    108109    } 
    109     parser->raw_input.length += length; 
     110    parser->raw_input.capacity += length; 
    110111    if (!length) { 
    111112        parser->is_eof = 1; 
     
    125126yaml_parser_update_buffer(yaml_parser_t *parser, size_t length) 
    126127{ 
     128    size_t old_capacity; 
     129 
    127130    assert(parser->reader); /* Read handler must be set. */ 
    128131 
    129132    /* If the EOF flag is set and the raw buffer is empty, do nothing. */ 
    130133 
    131     if (parser->is_eof && parser->raw_input.pointer == parser->raw_input.length) 
     134    if (parser->is_eof && parser->raw_input.pointer == parser->raw_input.capacity) 
    132135        return 1; 
    133136 
     
    147150 
    148151    if (parser->input.pointer > 0 && 
    149             parser->input.pointer < parser->input.length) { 
     152            parser->input.pointer < parser->input.capacity) { 
    150153        memmove(parser->input.buffer, 
    151154                parser->input.buffer + parser->input.pointer, 
    152                 parser->input.length - parser->input.pointer); 
    153         parser->input.length -= parser->input.pointer; 
    154         parser->input.pointer = 0; 
    155     } 
    156     else if (parser->input.pointer == parser->input.length) { 
    157         parser->input.pointer = parser->input.length = 0; 
    158     } 
     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; 
    159165 
    160166    /* Fill the buffer until it has enough characters. */ 
     
    168174        /* Decode the raw buffer. */ 
    169175 
    170         while (parser->raw_input.pointer != parser->raw_input.length) 
     176        while (parser->raw_input.pointer != parser->raw_input.capacity) 
    171177        { 
    172             unsigned char *raw_buffer = 
    173                 parser->raw_input.buffer + parser->raw_input.pointer; 
    174178            size_t raw_unread = 
    175                 parser->raw_input.length - parser->raw_input.pointer; 
     179                parser->raw_input.capacity - parser->raw_input.pointer; 
    176180            unsigned int value = 0, value2 = 0; 
    177181            int is_incomplete = 0; 
     
    179183            unsigned int width = 0; 
    180184            int low, high; 
    181             size_t k; 
     185            size_t idx; 
    182186 
    183187            /* Decode the next character. */ 
     
    209213                    /* Determine the length of the UTF-8 sequence. */ 
    210214 
    211                     octet = *raw_buffer; 
     215                    octet = OCTET(parser->raw_input); 
    212216                    width = (octet & 0x80) == 0x00 ? 1 : 
    213217                            (octet & 0xE0) == 0xC0 ? 2 : 
     
    243247                    /* Check and decode the trailing octets. */ 
    244248 
    245                     for (k = 1; k < width; k ++) 
     249                    for (idx = 1; idx < width; idx ++) 
    246250                    { 
    247                         octet = raw_buffer[k]; 
     251                        octet = OCTET_AT(parser->raw_input, idx); 
    248252 
    249253                        /* Check if the octet is valid. */ 
     
    252256                            return DECODER_ERROR_INIT(parser, 
    253257                                    "Invalid trailing UTF-8 octet", 
    254                                     parser->offset+k, octet); 
     258                                    parser->offset+idx, octet); 
    255259 
    256260                        /* Decode the octet. */ 
     
    324328                    /* Get the character. */ 
    325329 
    326                     value = raw_buffer[low] + (raw_buffer[high] << 8); 
     330                    value = OCTET_AT(parser->raw_input, low) 
     331                        + (OCTET_AT(parser->raw_input, high) << 8); 
    327332 
    328333                    /* Check for unexpected low surrogate area. */ 
     
    353358                        /* Get the next character. */ 
    354359 
    355                         value2 = raw_buffer[low+2] + (raw_buffer[high+2] << 8); 
     360                        value2 = OCTET_AT(parser->raw_input, low+2) 
     361                            + (OCTET_AT(parser->raw_input, high+2) << 8); 
    356362 
    357363                        /* Check for a low surrogate area. */ 
     
    407413            /* 0000 0000-0000 007F -> 0xxxxxxx */ 
    408414            if (value <= 0x7F) { 
    409                 parser->input.buffer[parser->input.length++] = value; 
     415                JOIN_OCTET(parser->input, value); 
    410416            } 
    411417            /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */ 
    412418            else if (value <= 0x7FF) { 
    413                 parser->input.buffer[parser->input.length++] = 0xC0 + (value >> 6); 
    414                 parser->input.buffer[parser->input.length++] = 0x80 + (value & 0x3F); 
     419                JOIN_OCTET(parser->input, 0xC0 + (value >> 6)); 
     420                JOIN_OCTET(parser->input, 0x80 + (value & 0x3F)); 
    415421            } 
    416422            /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */ 
    417423            else if (value <= 0xFFFF) { 
    418                 parser->input.buffer[parser->input.length++] = 0xE0 + (value >> 12); 
    419                 parser->input.buffer[parser->input.length++] = 0x80 + ((value >> 6) & 0x3F); 
    420                 parser->input.buffer[parser->input.length++] = 0x80 + (value & 0x3F); 
     424                JOIN_OCTET(parser->input, 0xE0 + (value >> 12)); 
     425                JOIN_OCTET(parser->input, 0x80 + ((value >> 6) & 0x3F)); 
     426                JOIN_OCTET(parser->input, 0x80 + (value & 0x3F)); 
    421427            } 
    422428            /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 
    423429            else { 
    424                 parser->input.buffer[parser->input.length++] = 0xF0 + (value >> 18); 
    425                 parser->input.buffer[parser->input.length++] = 0x80 + ((value >> 12) & 0x3F); 
    426                 parser->input.buffer[parser->input.length++] = 0x80 + ((value >> 6) & 0x3F); 
    427                 parser->input.buffer[parser->input.length++] = 0x80 + (value & 0x3F); 
     430                JOIN_OCTET(parser->input, 0xF0 + (value >> 18)); 
     431                JOIN_OCTET(parser->input, 0x80 + ((value >> 12) & 0x3F)); 
     432                JOIN_OCTET(parser->input, 0x80 + ((value >> 6) & 0x3F)); 
     433                JOIN_OCTET(parser->input, 0x80 + (value & 0x3F)); 
    428434            } 
    429435 
     
    431437        } 
    432438 
    433         /* On EOF, put NUL into the buffer and return. */ 
     439        /* On EOF, put NUL into the buffer and stop. */ 
    434440 
    435441        if (parser->is_eof) { 
    436             parser->input.buffer[parser->input.length++] = '\0'; 
     442            JOIN_OCTET(parser->input, '\0'); 
    437443            parser->unread ++; 
    438             return 1; 
     444            break; 
    439445        } 
    440446 
    441447    } 
     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; 
    442453 
    443454    return 1; 
Note: See TracChangeset for help on using the changeset viewer.