Ignore:
Timestamp:
12/26/07 08:46:43 (6 years ago)
Author:
xi
Message:

Updated reader.c to use the new API.

File:
1 edited

Legend:

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

    r239 r262  
    77 
    88static int 
    9 yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem, 
    10         size_t offset, int value); 
    11  
    12 static int 
    139yaml_parser_update_raw_buffer(yaml_parser_t *parser); 
    1410 
     
    1814YAML_DECLARE(int) 
    1915yaml_parser_update_buffer(yaml_parser_t *parser, size_t length); 
    20  
    21 /* 
    22  * Set the reader error and return 0. 
    23  */ 
    24  
    25 static int 
    26 yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem, 
    27         size_t offset, int value) 
    28 { 
    29     parser->error = YAML_READER_ERROR; 
    30     parser->problem = problem; 
    31     parser->problem_offset = offset; 
    32     parser->problem_value = value; 
    33  
    34     return 0; 
    35 } 
    3616 
    3717/* 
     
    4626 * Determine the input stream encoding by checking the BOM symbol. If no BOM is 
    4727 * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure. 
     28 * 
     29 * This function is called at the beginning of the processing, so we could 
     30 * safely assume that the current offset value is 0. 
    4831 */ 
    4932 
     
    5336    /* Ensure that we had enough bytes in the raw buffer. */ 
    5437 
    55     while (!parser->eof  
    56             && parser->raw_buffer.last - parser->raw_buffer.pointer < 3) { 
     38    while (!parser->is_eof && parser->raw_input.length < 3) { 
    5739        if (!yaml_parser_update_raw_buffer(parser)) { 
    5840            return 0; 
     
    6244    /* Determine the encoding. */ 
    6345 
    64     if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 
    65             && !memcmp(parser->raw_buffer.pointer, BOM_UTF16LE, 2)) { 
     46    if (parser->raw_input.length >= 2 
     47            && !memcmp(parser->raw_input.buffer, BOM_UTF16LE, 2)) { 
    6648        parser->encoding = YAML_UTF16LE_ENCODING; 
    67         parser->raw_buffer.pointer += 2; 
    68         parser->offset += 2; 
    69     } 
    70     else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 
    71             && !memcmp(parser->raw_buffer.pointer, BOM_UTF16BE, 2)) { 
     49        parser->raw_input.pointer = 2; 
     50        parser->offset = 2; 
     51    } 
     52    else if (parser->raw_input.length >= 2 
     53            && !memcmp(parser->raw_input.buffer, BOM_UTF16BE, 2)) { 
    7254        parser->encoding = YAML_UTF16BE_ENCODING; 
    73         parser->raw_buffer.pointer += 2; 
    74         parser->offset += 2; 
    75     } 
    76     else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 3 
    77             && !memcmp(parser->raw_buffer.pointer, BOM_UTF8, 3)) { 
     55        parser->raw_input.pointer = 2; 
     56        parser->offset = 2; 
     57    } 
     58    else if (parser->raw_input.length >= 3 
     59            && !memcmp(parser->raw_input.buffer, BOM_UTF8, 3)) { 
    7860        parser->encoding = YAML_UTF8_ENCODING; 
    79         parser->raw_buffer.pointer += 3; 
    80         parser->offset += 3; 
     61        parser->raw_input.pointer = 3; 
     62        parser->offset = 3; 
    8163    } 
    8264    else { 
     
    9476yaml_parser_update_raw_buffer(yaml_parser_t *parser) 
    9577{ 
    96     size_t size_read = 0; 
     78    size_t length = 0; 
    9779 
    9880    /* Return if the raw buffer is full. */ 
    9981 
    100     if (parser->raw_buffer.start == parser->raw_buffer.pointer 
    101             && parser->raw_buffer.last == parser->raw_buffer.end) 
     82    if (parser->raw_input.pointer == 0 && 
     83            parser->raw_input.length == parser->raw_input.capacity) 
    10284        return 1; 
    10385 
    10486    /* Return on EOF. */ 
    10587 
    106     if (parser->eof) return 1; 
     88    if (parser->is_eof) 
     89        return 1; 
    10790 
    10891    /* Move the remaining bytes in the raw buffer to the beginning. */ 
    10992 
    110     if (parser->raw_buffer.start < parser->raw_buffer.pointer 
    111             && parser->raw_buffer.pointer < parser->raw_buffer.last) { 
    112         memmove(parser->raw_buffer.start, parser->raw_buffer.pointer, 
    113                 parser->raw_buffer.last - parser->raw_buffer.pointer); 
    114     } 
    115     parser->raw_buffer.last -= 
    116         parser->raw_buffer.pointer - parser->raw_buffer.start; 
    117     parser->raw_buffer.pointer = parser->raw_buffer.start; 
     93    if (parser->raw_input.pointer > 0 && 
     94            parser->raw_input.pointer < parser->raw_input.length) { 
     95        memmove(parser->raw_input.buffer, 
     96                parser->raw_input.buffer + parser->raw_input.pointer, 
     97                parser->raw_input.length - parser->raw_input.pointer); 
     98    } 
     99    parser->raw_input.pointer = 0; 
    118100 
    119101    /* Call the read handler to fill the buffer. */ 
    120102 
    121     if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last, 
    122                 parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) { 
    123         return yaml_parser_set_reader_error(parser, "Input error", 
    124                 parser->offset, -1); 
    125     } 
    126     parser->raw_buffer.last += size_read; 
    127     if (!size_read) { 
    128         parser->eof = 1; 
     103    if (!parser->reader(parser->reader_data, 
     104                parser->raw_input.buffer + parser->raw_input.length, 
     105                parser->raw_input.capacity - parser->raw_input.length, 
     106                &length)) { 
     107        return READER_ERROR_INIT(parser, "Input error", parser->offset); 
     108    } 
     109    parser->raw_input.length += length; 
     110    if (!length) { 
     111        parser->is_eof = 1; 
    129112    } 
    130113 
     
    142125yaml_parser_update_buffer(yaml_parser_t *parser, size_t length) 
    143126{ 
    144     assert(parser->read_handler);  /* Read handler must be set. */ 
     127    assert(parser->reader); /* Read handler must be set. */ 
    145128 
    146129    /* If the EOF flag is set and the raw buffer is empty, do nothing. */ 
    147130 
    148     if (parser->eof && parser->raw_buffer.pointer == parser->raw_buffer.last) 
     131    if (parser->is_eof && parser->raw_input.pointer == parser->raw_input.length) 
    149132        return 1; 
    150133 
     
    163146    /* Move the unread characters to the beginning of the buffer. */ 
    164147 
    165     if (parser->buffer.start < parser->buffer.pointer 
    166             && parser->buffer.pointer < parser->buffer.last) { 
    167         size_t size = parser->buffer.last - parser->buffer.pointer; 
    168         memmove(parser->buffer.start, parser->buffer.pointer, size); 
    169         parser->buffer.pointer = parser->buffer.start; 
    170         parser->buffer.last = parser->buffer.start + size; 
    171     } 
    172     else if (parser->buffer.pointer == parser->buffer.last) { 
    173         parser->buffer.pointer = parser->buffer.start; 
    174         parser->buffer.last = parser->buffer.start; 
     148    if (parser->input.pointer > 0 && 
     149            parser->input.pointer < parser->input.length) { 
     150        memmove(parser->input.buffer, 
     151                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; 
    175158    } 
    176159 
     
    185168        /* Decode the raw buffer. */ 
    186169 
    187         while (parser->raw_buffer.pointer != parser->raw_buffer.last) 
     170        while (parser->raw_input.pointer != parser->raw_input.length) 
    188171        { 
     172            unsigned char *raw_buffer = 
     173                parser->raw_input.buffer + parser->raw_input.pointer; 
     174            size_t raw_unread = 
     175                parser->raw_input.length - parser->raw_input.pointer; 
    189176            unsigned int value = 0, value2 = 0; 
    190             int incomplete = 0; 
     177            int is_incomplete = 0; 
    191178            unsigned char octet; 
    192179            unsigned int width = 0; 
    193180            int low, high; 
    194181            size_t k; 
    195             size_t raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer; 
    196182 
    197183            /* Decode the next character. */ 
     
    223209                    /* Determine the length of the UTF-8 sequence. */ 
    224210 
    225                     octet = parser->raw_buffer.pointer[0]; 
     211                    octet = *raw_buffer; 
    226212                    width = (octet & 0x80) == 0x00 ? 1 : 
    227213                            (octet & 0xE0) == 0xC0 ? 2 : 
     
    232218 
    233219                    if (!width) 
    234                         return yaml_parser_set_reader_error(parser, 
     220                        return DECODER_ERROR_INIT(parser, 
    235221                                "Invalid leading UTF-8 octet", 
    236222                                parser->offset, octet); 
     
    239225 
    240226                    if (width > raw_unread) { 
    241                         if (parser->eof) { 
    242                             return yaml_parser_set_reader_error(parser, 
     227                        if (parser->is_eof) { 
     228                            return DECODER_ERROR_INIT(parser, 
    243229                                    "Incomplete UTF-8 octet sequence", 
    244230                                    parser->offset, -1); 
    245231                        } 
    246                         incomplete = 1; 
     232                        is_incomplete = 1; 
    247233                        break; 
    248234                    } 
     
    259245                    for (k = 1; k < width; k ++) 
    260246                    { 
    261                         octet = parser->raw_buffer.pointer[k]; 
     247                        octet = raw_buffer[k]; 
    262248 
    263249                        /* Check if the octet is valid. */ 
    264250 
    265251                        if ((octet & 0xC0) != 0x80) 
    266                             return yaml_parser_set_reader_error(parser, 
     252                            return DECODER_ERROR_INIT(parser, 
    267253                                    "Invalid trailing UTF-8 octet", 
    268254                                    parser->offset+k, octet); 
     
    279265                            (width == 3 && value >= 0x800) || 
    280266                            (width == 4 && value >= 0x10000))) 
    281                         return yaml_parser_set_reader_error(parser, 
     267                        return DECODER_ERROR_INIT(parser, 
    282268                                "Invalid length of a UTF-8 sequence", 
    283269                                parser->offset, -1); 
     
    286272 
    287273                    if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) 
    288                         return yaml_parser_set_reader_error(parser, 
     274                        return DECODER_ERROR_INIT(parser, 
    289275                                "Invalid Unicode character", 
    290276                                parser->offset, value); 
     
    327313 
    328314                    if (raw_unread < 2) { 
    329                         if (parser->eof) { 
    330                             return yaml_parser_set_reader_error(parser, 
     315                        if (parser->is_eof) { 
     316                            return DECODER_ERROR_INIT(parser, 
    331317                                    "Incomplete UTF-16 character", 
    332318                                    parser->offset, -1); 
    333319                        } 
    334                         incomplete = 1; 
     320                        is_incomplete = 1; 
    335321                        break; 
    336322                    } 
     
    338324                    /* Get the character. */ 
    339325 
    340                     value = parser->raw_buffer.pointer[low] 
    341                         + (parser->raw_buffer.pointer[high] << 8); 
     326                    value = raw_buffer[low] + (raw_buffer[high] << 8); 
    342327 
    343328                    /* Check for unexpected low surrogate area. */ 
    344329 
    345330                    if ((value & 0xFC00) == 0xDC00) 
    346                         return yaml_parser_set_reader_error(parser, 
     331                        return DECODER_ERROR_INIT(parser, 
    347332                                "Unexpected low surrogate area", 
    348333                                parser->offset, value); 
     
    357342 
    358343                        if (raw_unread < 4) { 
    359                             if (parser->eof) { 
    360                                 return yaml_parser_set_reader_error(parser, 
     344                            if (parser->is_eof) { 
     345                                return DECODER_ERROR_INIT(parser, 
    361346                                        "Incomplete UTF-16 surrogate pair", 
    362347                                        parser->offset, -1); 
    363348                            } 
    364                             incomplete = 1; 
     349                            is_incomplete = 1; 
    365350                            break; 
    366351                        } 
     
    368353                        /* Get the next character. */ 
    369354 
    370                         value2 = parser->raw_buffer.pointer[low+2] 
    371                             + (parser->raw_buffer.pointer[high+2] << 8); 
     355                        value2 = raw_buffer[low+2] + (raw_buffer[high+2] << 8); 
    372356 
    373357                        /* Check for a low surrogate area. */ 
    374358 
    375359                        if ((value2 & 0xFC00) != 0xDC00) 
    376                             return yaml_parser_set_reader_error(parser, 
     360                            return DECODER_ERROR_INIT(parser, 
    377361                                    "Expected low surrogate area", 
    378362                                    parser->offset+2, value2); 
     
    395379            /* Check if the raw buffer contains enough bytes to form a character. */ 
    396380 
    397             if (incomplete) break; 
     381            if (is_incomplete) 
     382                break; 
    398383 
    399384            /* 
     
    409394                        || (value >= 0xE000 && value <= 0xFFFD) 
    410395                        || (value >= 0x10000 && value <= 0x10FFFF))) 
    411                 return yaml_parser_set_reader_error(parser, 
     396                return DECODER_ERROR_INIT(parser, 
    412397                        "Control characters are not allowed", 
    413398                        parser->offset, value); 
     
    415400            /* Move the raw pointers. */ 
    416401 
    417             parser->raw_buffer.pointer += width; 
     402            parser->raw_input.pointer += width; 
    418403            parser->offset += width; 
    419404 
     
    422407            /* 0000 0000-0000 007F -> 0xxxxxxx */ 
    423408            if (value <= 0x7F) { 
    424                 *(parser->buffer.last++) = value; 
     409                parser->input.buffer[parser->input.length++] = value; 
    425410            } 
    426411            /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */ 
    427412            else if (value <= 0x7FF) { 
    428                 *(parser->buffer.last++) = 0xC0 + (value >> 6); 
    429                 *(parser->buffer.last++) = 0x80 + (value & 0x3F); 
     413                parser->input.buffer[parser->input.length++] = 0xC0 + (value >> 6); 
     414                parser->input.buffer[parser->input.length++] = 0x80 + (value & 0x3F); 
    430415            } 
    431416            /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */ 
    432417            else if (value <= 0xFFFF) { 
    433                 *(parser->buffer.last++) = 0xE0 + (value >> 12); 
    434                 *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); 
    435                 *(parser->buffer.last++) = 0x80 + (value & 0x3F); 
     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); 
    436421            } 
    437422            /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 
    438423            else { 
    439                 *(parser->buffer.last++) = 0xF0 + (value >> 18); 
    440                 *(parser->buffer.last++) = 0x80 + ((value >> 12) & 0x3F); 
    441                 *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); 
    442                 *(parser->buffer.last++) = 0x80 + (value & 0x3F); 
     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); 
    443428            } 
    444429 
     
    448433        /* On EOF, put NUL into the buffer and return. */ 
    449434 
    450         if (parser->eof) { 
    451             *(parser->buffer.last++) = '\0'; 
     435        if (parser->is_eof) { 
     436            parser->input.buffer[parser->input.length++] = '\0'; 
    452437            parser->unread ++; 
    453438            return 1; 
Note: See TracChangeset for help on using the changeset viewer.