Ignore:
Timestamp:
07/21/06 09:50:32 (8 years ago)
Author:
xi
Message:

Refactor internal and external API.

File:
1 edited

Legend:

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

    r200 r208  
    11 
    2 #if HAVE_CONFIG_H 
    3 #include <config.h> 
    4 #endif 
    5  
    6 #include <yaml.h> 
    7  
    8 #include <assert.h> 
     2#include "yaml_private.h" 
     3 
     4/* 
     5 * Declarations. 
     6 */ 
     7 
     8static int 
     9yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem, 
     10        size_t offset, int value); 
     11 
     12static int 
     13yaml_parser_update_raw_buffer(yaml_parser_t *parser); 
     14 
     15static int 
     16yaml_parser_determine_encoding(yaml_parser_t *parser); 
     17 
     18YAML_DECLARE(int) 
     19yaml_parser_update_buffer(yaml_parser_t *parser, size_t length); 
    920 
    1021/* 
     
    2536 
    2637/* 
     38 * Byte order marks. 
     39 */ 
     40 
     41#define BOM_UTF8    "\xef\xbb\xbf" 
     42#define BOM_UTF16LE "\xff\xfe" 
     43#define BOM_UTF16BE "\xfe\xff" 
     44 
     45/* 
     46 * Determine the input stream encoding by checking the BOM symbol. If no BOM is 
     47 * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure. 
     48 */ 
     49 
     50static int 
     51yaml_parser_determine_encoding(yaml_parser_t *parser) 
     52{ 
     53    /* Ensure that we had enough bytes in the raw buffer. */ 
     54 
     55    while (!parser->eof  
     56            && parser->raw_buffer.last - parser->raw_buffer.pointer < 3) { 
     57        if (!yaml_parser_update_raw_buffer(parser)) { 
     58            return 0; 
     59        } 
     60    } 
     61 
     62    /* Determine the encoding. */ 
     63 
     64    if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2 
     65            && !memcmp(parser->raw_buffer.pointer, BOM_UTF16LE, 2)) { 
     66        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)) { 
     72        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)) { 
     78        parser->encoding = YAML_UTF8_ENCODING; 
     79        parser->raw_buffer.pointer += 3; 
     80        parser->offset += 3; 
     81    } 
     82    else { 
     83        parser->encoding = YAML_UTF8_ENCODING; 
     84    } 
     85 
     86    return 1; 
     87} 
     88 
     89/* 
    2790 * Update the raw buffer. 
    2891 */ 
     
    3598    /* Return if the raw buffer is full. */ 
    3699 
    37     if (parser->raw_unread == YAML_RAW_BUFFER_SIZE) return 1; 
     100    if (parser->raw_buffer.start == parser->raw_buffer.pointer 
     101            && parser->raw_buffer.last == parser->raw_buffer.end) 
     102        return 1; 
    38103 
    39104    /* Return on EOF. */ 
     
    43108    /* Move the remaining bytes in the raw buffer to the beginning. */ 
    44109 
    45     if (parser->raw_unread && parser->raw_buffer < parser->raw_pointer) { 
    46         memmove(parser->raw_buffer, parser->raw_pointer, parser->raw_unread); 
    47     } 
    48     parser->raw_pointer = parser->raw_buffer; 
     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; 
    49118 
    50119    /* Call the read handler to fill the buffer. */ 
    51120 
    52     if (!parser->read_handler(parser->read_handler_data, 
    53                 parser->raw_buffer + parser->raw_unread, 
    54                 YAML_RAW_BUFFER_SIZE - parser->raw_unread, 
    55                 &size_read)) { 
     121    if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last, 
     122                parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) { 
    56123        return yaml_parser_set_reader_error(parser, "Input error", 
    57124                parser->offset, -1); 
    58125    } 
    59     parser->raw_unread += size_read; 
     126    parser->raw_buffer.last += size_read; 
    60127    if (!size_read) { 
    61128        parser->eof = 1; 
     
    66133 
    67134/* 
    68  * Determine the input stream encoding by checking the BOM symbol. If no BOM is 
    69  * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure. 
    70  */ 
    71  
    72 #define BOM_UTF8    "\xef\xbb\xbf" 
    73 #define BOM_UTF16LE "\xff\xfe" 
    74 #define BOM_UTF16BE "\xfe\xff" 
    75  
    76 static int 
    77 yaml_parser_determine_encoding(yaml_parser_t *parser) 
    78 { 
    79     /* Ensure that we had enough bytes in the raw buffer. */ 
    80  
    81     while (!parser->eof && parser->raw_unread < 3) { 
    82         if (!yaml_parser_update_raw_buffer(parser)) { 
    83             return 0; 
    84         } 
    85     } 
    86  
    87     /* Determine the encoding. */ 
    88  
    89     if (parser->raw_unread >= 2 
    90             && !memcmp(parser->raw_pointer, BOM_UTF16LE, 2)) { 
    91         parser->encoding = YAML_UTF16LE_ENCODING; 
    92         parser->raw_pointer += 2; 
    93         parser->raw_unread -= 2; 
    94         parser->offset += 2; 
    95     } 
    96     else if (parser->raw_unread >= 2 
    97             && !memcmp(parser->raw_pointer, BOM_UTF16BE, 2)) { 
    98         parser->encoding = YAML_UTF16BE_ENCODING; 
    99         parser->raw_pointer += 2; 
    100         parser->raw_unread -= 2; 
    101         parser->offset += 2; 
    102     } 
    103     else if (parser->raw_unread >= 3 
    104             && !memcmp(parser->raw_pointer, BOM_UTF8, 3)) { 
    105         parser->encoding = YAML_UTF8_ENCODING; 
    106         parser->raw_pointer += 3; 
    107         parser->raw_unread -= 3; 
    108         parser->offset += 3; 
    109     } 
    110     else { 
    111         parser->encoding = YAML_UTF8_ENCODING; 
    112     } 
    113  
    114     return 1; 
    115 } 
    116  
    117 /* 
    118  * Ensure that the buffer contains at least length characters. 
     135 * Ensure that the buffer contains at least `length` characters. 
    119136 * Return 1 on success, 0 on failure. 
    120137 * 
     
    125142yaml_parser_update_buffer(yaml_parser_t *parser, size_t length) 
    126143{ 
     144    assert(parser->read_handler);   /* Read handler must be set. */ 
     145 
    127146    /* If the EOF flag is set and the raw buffer is empty, do nothing. */ 
    128147 
    129     if (parser->eof && !parser->raw_unread) 
     148    if (parser->eof && parser->raw_buffer.pointer == parser->raw_buffer.last) 
    130149        return 1; 
    131150 
     
    144163    /* Move the unread characters to the beginning of the buffer. */ 
    145164 
    146     if (parser->buffer < parser->pointer 
    147             && parser->pointer < parser->buffer_end) { 
    148         size_t size = parser->buffer_end - parser->pointer; 
    149         memmove(parser->buffer, parser->pointer, size); 
    150         parser->pointer = parser->buffer; 
    151         parser->buffer_end = parser->buffer + size; 
    152     } 
    153     else if (parser->pointer == parser->buffer_end) { 
    154         parser->pointer = parser->buffer; 
    155         parser->buffer_end = parser->buffer; 
     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; 
    156175    } 
    157176 
     
    166185        /* Decode the raw buffer. */ 
    167186 
    168         while (parser->raw_unread) 
     187        while (parser->raw_buffer.pointer != parser->raw_buffer.last) 
    169188        { 
    170189            unsigned int value, value2; 
     
    173192            unsigned int width; 
    174193            int k, low, high; 
     194            int raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer; 
    175195 
    176196            /* Decode the next character. */ 
     
    202222                    /* Determine the length of the UTF-8 sequence. */ 
    203223 
    204                     octet = parser->raw_pointer[0]; 
     224                    octet = parser->raw_buffer.pointer[0]; 
    205225                    width = (octet & 0x80) == 0x00 ? 1 : 
    206226                            (octet & 0xE0) == 0xC0 ? 2 : 
     
    217237                    /* Check if the raw buffer contains an incomplete character. */ 
    218238 
    219                     if (width > parser->raw_unread) { 
     239                    if (width > raw_unread) { 
    220240                        if (parser->eof) { 
    221241                            return yaml_parser_set_reader_error(parser, 
     
    238258                    for (k = 1; k < width; k ++) 
    239259                    { 
    240                         octet = parser->raw_pointer[k]; 
     260                        octet = parser->raw_buffer.pointer[k]; 
    241261 
    242262                        /* Check if the octet is valid. */ 
     
    305325                    /* Check for incomplete UTF-16 character. */ 
    306326 
    307                     if (parser->raw_unread < 2) { 
     327                    if (raw_unread < 2) { 
    308328                        if (parser->eof) { 
    309329                            return yaml_parser_set_reader_error(parser, 
     
    317337                    /* Get the character. */ 
    318338 
    319                     value = parser->raw_pointer[low] 
    320                         + (parser->raw_pointer[high] << 8); 
     339                    value = parser->raw_buffer.pointer[low] 
     340                        + (parser->raw_buffer.pointer[high] << 8); 
    321341 
    322342                    /* Check for unexpected low surrogate area. */ 
     
    335355                        /* Check for incomplete surrogate pair. */ 
    336356 
    337                         if (parser->raw_unread < 4) { 
     357                        if (raw_unread < 4) { 
    338358                            if (parser->eof) { 
    339359                                return yaml_parser_set_reader_error(parser, 
     
    347367                        /* Get the next character. */ 
    348368 
    349                         unsigned int value2 = parser->raw_pointer[low+2] 
    350                             + (parser->raw_pointer[high+2] << 8); 
     369                        unsigned int value2 = parser->raw_buffer.pointer[low+2] 
     370                            + (parser->raw_buffer.pointer[high+2] << 8); 
    351371 
    352372                        /* Check for a low surrogate area. */ 
     
    391411            /* Move the raw pointers. */ 
    392412 
    393             parser->raw_pointer += width; 
    394             parser->raw_unread -= width; 
     413            parser->raw_buffer.pointer += width; 
    395414            parser->offset += width; 
    396415 
     
    399418            /* 0000 0000-0000 007F -> 0xxxxxxx */ 
    400419            if (value <= 0x7F) { 
    401                 *(parser->buffer_end++) = value; 
     420                *(parser->buffer.last++) = value; 
    402421            } 
    403422            /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */ 
    404423            else if (value <= 0x7FF) { 
    405                 *(parser->buffer_end++) = 0xC0 + (value >> 6); 
    406                 *(parser->buffer_end++) = 0x80 + (value & 0x3F); 
     424                *(parser->buffer.last++) = 0xC0 + (value >> 6); 
     425                *(parser->buffer.last++) = 0x80 + (value & 0x3F); 
    407426            } 
    408427            /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */ 
    409428            else if (value <= 0xFFFF) { 
    410                 *(parser->buffer_end++) = 0xE0 + (value >> 12); 
    411                 *(parser->buffer_end++) = 0x80 + ((value >> 6) & 0x3F); 
    412                 *(parser->buffer_end++) = 0x80 + (value & 0x3F); 
     429                *(parser->buffer.last++) = 0xE0 + (value >> 12); 
     430                *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); 
     431                *(parser->buffer.last++) = 0x80 + (value & 0x3F); 
    413432            } 
    414433            /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 
    415434            else { 
    416                 *(parser->buffer_end++) = 0xF0 + (value >> 18); 
    417                 *(parser->buffer_end++) = 0x80 + ((value >> 12) & 0x3F); 
    418                 *(parser->buffer_end++) = 0x80 + ((value >> 6) & 0x3F); 
    419                 *(parser->buffer_end++) = 0x80 + (value & 0x3F); 
     435                *(parser->buffer.last++) = 0xF0 + (value >> 18); 
     436                *(parser->buffer.last++) = 0x80 + ((value >> 12) & 0x3F); 
     437                *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F); 
     438                *(parser->buffer.last++) = 0x80 + (value & 0x3F); 
    420439            } 
    421440 
     
    426445 
    427446        if (parser->eof) { 
    428             *(parser->buffer_end++) = '\0'; 
     447            *(parser->buffer.last++) = '\0'; 
    429448            parser->unread ++; 
    430449            return 1; 
Note: See TracChangeset for help on using the changeset viewer.