Ignore:
Timestamp:
07/28/06 16:09:34 (8 years ago)
Author:
xi
Message:

Implement everything except tag and scalar writers.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libyaml/trunk/src/yaml_private.h

    r213 r214  
    112112#define NULL_STRING { NULL, NULL, NULL } 
    113113 
     114#define STRING(string,length)   { (string), (string)+(length), (string) } 
     115 
    114116#define STRING_INIT(context,string,size)                                        \ 
    115117    (((string).start = yaml_malloc(size)) ?                                     \ 
     
    142144        ((context)->error = YAML_MEMORY_ERROR,                                  \ 
    143145         0)) 
     146 
     147/* 
     148 * String check operations. 
     149 */ 
     150 
     151/* 
     152 * Check the octet at the specified position. 
     153 */ 
     154 
     155#define CHECK_AT(string,octet,offset)                                           \ 
     156    ((string).pointer[offset] == (yaml_char_t)(octet)) 
     157 
     158/* 
     159 * Check the current octet in the buffer. 
     160 */ 
     161 
     162#define CHECK(string,octet) CHECK_AT((string),(octet),0) 
     163 
     164/* 
     165 * Check if the character at the specified position is an alphabetical 
     166 * character, a digit, '_', or '-'. 
     167 */ 
     168 
     169#define IS_ALPHA_AT(string,offset)                                              \ 
     170     (((string).pointer[offset] >= (yaml_char_t) '0' &&                         \ 
     171       (string).pointer[offset] <= (yaml_char_t) '9') ||                        \ 
     172      ((string).pointer[offset] >= (yaml_char_t) 'A' &&                         \ 
     173       (string).pointer[offset] <= (yaml_char_t) 'Z') ||                        \ 
     174      ((string).pointer[offset] >= (yaml_char_t) 'a' &&                         \ 
     175       (string).pointer[offset] <= (yaml_char_t) 'z') ||                        \ 
     176      (string).pointer[offset] == '_' ||                                        \ 
     177      (string).pointer[offset] == '-') 
     178 
     179#define IS_ALPHA(string)    IS_ALPHA_AT((string),0) 
     180 
     181/* 
     182 * Check if the character at the specified position is a digit. 
     183 */ 
     184 
     185#define IS_DIGIT_AT(string,offset)                                              \ 
     186     (((string).pointer[offset] >= (yaml_char_t) '0' &&                         \ 
     187       (string).pointer[offset] <= (yaml_char_t) '9')) 
     188 
     189#define IS_DIGIT(string)    IS_DIGIT_AT((string),0) 
     190 
     191/* 
     192 * Get the value of a digit. 
     193 */ 
     194 
     195#define AS_DIGIT_AT(string,offset)                                              \ 
     196     ((string).pointer[offset] - (yaml_char_t) '0') 
     197 
     198#define AS_DIGIT(string)    AS_DIGIT_AT((string),0) 
     199 
     200/* 
     201 * Check if the character at the specified position is a hex-digit. 
     202 */ 
     203 
     204#define IS_HEX_AT(string,offset)                                                \ 
     205     (((string).pointer[offset] >= (yaml_char_t) '0' &&                         \ 
     206       (string).pointer[offset] <= (yaml_char_t) '9') ||                        \ 
     207      ((string).pointer[offset] >= (yaml_char_t) 'A' &&                         \ 
     208       (string).pointer[offset] <= (yaml_char_t) 'F') ||                        \ 
     209      ((string).pointer[offset] >= (yaml_char_t) 'a' &&                         \ 
     210       (string).pointer[offset] <= (yaml_char_t) 'f')) 
     211 
     212#define IS_HEX(string)    IS_HEX_AT((string),0) 
     213 
     214/* 
     215 * Get the value of a hex-digit. 
     216 */ 
     217 
     218#define AS_HEX_AT(string,offset)                                                \ 
     219      (((string).pointer[offset] >= (yaml_char_t) 'A' &&                        \ 
     220        (string).pointer[offset] <= (yaml_char_t) 'F') ?                        \ 
     221       ((string).pointer[offset] - (yaml_char_t) 'A' + 10) :                    \ 
     222       ((string).pointer[offset] >= (yaml_char_t) 'a' &&                        \ 
     223        (string).pointer[offset] <= (yaml_char_t) 'f') ?                        \ 
     224       ((string).pointer[offset] - (yaml_char_t) 'a' + 10) :                    \ 
     225       ((string).pointer[offset] - (yaml_char_t) '0')) 
     226  
     227#define AS_HEX(string)  AS_HEX_AT((string),0) 
     228  
     229/* 
     230 * Check if the character is ASCII. 
     231 */ 
     232 
     233#define IS_ASCII_AT(string,offset)                                              \ 
     234    ((string).pointer[offset] <= (yaml_char_t) '\x7F') 
     235 
     236#define IS_ASCII(string)    IS_ASCII_AT((string),0) 
     237 
     238/* 
     239 * Check if the character can be printed unescaped. 
     240 */ 
     241 
     242#define IS_PRINTABLE_AT(string,offset)                                          \ 
     243    (((string).pointer[offset] == 0x0A)         /* . == #x0A */                 \ 
     244     || ((string).pointer[offset] >= 0x20       /* #x20 <= . <= #x7E */         \ 
     245         && (string).pointer[offset] <= 0x7E)                                   \ 
     246     || ((string).pointer[offset] == 0xC2       /* #0xA0 <= . <= #xD7FF */      \ 
     247         && (string).pointer[offset+1] >= 0xA0)                                 \ 
     248     || ((string).pointer[offset] > 0xC2                                        \ 
     249         && (string).pointer[offset] < 0xED)                                    \ 
     250     || ((string).pointer[offset] == 0xED                                       \ 
     251         && (string).pointer[offset+1] < 0xA0)                                  \ 
     252     || ((string).pointer[offset] == 0xEE)                                      \ 
     253     || ((string).pointer[offset] == 0xEF      /* #xE000 <= . <= #xFFFD */      \ 
     254         && !((string).pointer[offset+1] == 0xBB        /* && . != #xFEFF */    \ 
     255             && (string).pointer[offset+2] == 0xBF)                             \ 
     256         && !((string).pointer[offset+1] == 0xBF                                \ 
     257             && ((string).pointer[offset+2] == 0xBE                             \ 
     258                 || (string).pointer[offset+2] == 0xBF)))) 
     259 
     260#define IS_PRINTABLE(string)    IS_PRINTABLE_AT((string),0) 
     261 
     262/* 
     263 * Check if the character at the specified position is NUL. 
     264 */ 
     265 
     266#define IS_Z_AT(string,offset)    CHECK_AT((string),'\0',(offset)) 
     267 
     268#define IS_Z(string)    IS_Z_AT((string),0) 
     269 
     270/* 
     271 * Check if the character at the specified position is BOM. 
     272 */ 
     273 
     274#define IS_BOM_AT(string,offset)                                                \ 
     275     (CHECK_AT((string),'\xEF',(offset))                                        \ 
     276      && CHECK_AT((string),'\xBB',(offset)+1)                                   \ 
     277      && CHECK_AT((string),'\xBF',(offset)+2))  /* BOM (#xFEFF) */ 
     278 
     279#define IS_BOM(string)  IS_BOM_AT(string,0) 
     280 
     281/* 
     282 * Check if the character at the specified position is space. 
     283 */ 
     284 
     285#define IS_SPACE_AT(string,offset)  CHECK_AT((string),' ',(offset)) 
     286 
     287#define IS_SPACE(string)    IS_SPACE_AT((string),0) 
     288 
     289/* 
     290 * Check if the character at the specified position is tab. 
     291 */ 
     292 
     293#define IS_TAB_AT(string,offset)    CHECK_AT((string),'\t',(offset)) 
     294 
     295#define IS_TAB(string)  IS_TAB_AT((string),0) 
     296 
     297/* 
     298 * Check if the character at the specified position is blank (space or tab). 
     299 */ 
     300 
     301#define IS_BLANK_AT(string,offset)                                              \ 
     302    (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) 
     303 
     304#define IS_BLANK(string)    IS_BLANK_AT((string),0) 
     305 
     306/* 
     307 * Check if the character at the specified position is a line break. 
     308 */ 
     309 
     310#define IS_BREAK_AT(string,offset)                                              \ 
     311    (CHECK_AT((string),'\r',(offset))               /* CR (#xD)*/               \ 
     312     || CHECK_AT((string),'\n',(offset))            /* LF (#xA) */              \ 
     313     || (CHECK_AT((string),'\xC2',(offset))                                     \ 
     314         && CHECK_AT((string),'\x85',(offset)+1))   /* NEL (#x85) */            \ 
     315     || (CHECK_AT((string),'\xE2',(offset))                                     \ 
     316         && CHECK_AT((string),'\x80',(offset)+1)                                \ 
     317         && CHECK_AT((string),'\xA8',(offset)+2))   /* LS (#x2028) */           \ 
     318     || (CHECK_AT((string),'\xE2',(offset))                                     \ 
     319         && CHECK_AT((string),'\x80',(offset)+1)                                \ 
     320         && CHECK_AT((string),'\xA9',(offset)+2)))  /* PS (#x2029) */ 
     321 
     322#define IS_BREAK(string)    IS_BREAK_AT((string),0) 
     323 
     324#define IS_CRLF_AT(string,offset)                                               \ 
     325     (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) 
     326 
     327#define IS_CRLF(string) IS_CRLF_AT((string),0) 
     328 
     329/* 
     330 * Check if the character is a line break or NUL. 
     331 */ 
     332 
     333#define IS_BREAKZ_AT(string,offset)                                             \ 
     334    (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) 
     335 
     336#define IS_BREAKZ(string)   IS_BREAKZ_AT((string),0) 
     337 
     338/* 
     339 * Check if the character is a line break, space, or NUL. 
     340 */ 
     341 
     342#define IS_SPACEZ_AT(string,offset)                                             \ 
     343    (IS_SPACE_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) 
     344 
     345#define IS_SPACEZ(string)   IS_SPACEZ_AT((string),0) 
     346 
     347/* 
     348 * Check if the character is a line break, space, tab, or NUL. 
     349 */ 
     350 
     351#define IS_BLANKZ_AT(string,offset)                                             \ 
     352    (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) 
     353 
     354#define IS_BLANKZ(string)   IS_BLANKZ_AT((string),0) 
     355 
     356/* 
     357 * Determine the width of the character. 
     358 */ 
     359 
     360#define WIDTH_AT(string,offset)                                                 \ 
     361     (((string).pointer[offset] & 0x80) == 0x00 ? 1 :                           \ 
     362      ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 :                           \ 
     363      ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 :                           \ 
     364      ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0) 
     365 
     366#define WIDTH(string)   WIDTH_AT((string),0) 
     367 
     368/* 
     369 * Move the string pointer to the next character. 
     370 */ 
     371 
     372#define MOVE(string)    ((string).pointer += WIDTH((string))) 
     373 
     374/* 
     375 * Copy a character and move the pointers of both strings. 
     376 */ 
     377 
     378#define COPY(string_a,string_b)                                                 \ 
     379    ((*(string_b).pointer & 0x80) == 0x00 ?                                     \ 
     380     (*((string_a).pointer++) = *((string_b).pointer++)) :                      \ 
     381     (*(string_b).pointer & 0xE0) == 0xC0 ?                                     \ 
     382     (*((string_a).pointer++) = *((string_b).pointer++),                        \ 
     383      *((string_a).pointer++) = *((string_b).pointer++)) :                      \ 
     384     (*(string_b).pointer & 0xF0) == 0xE0 ?                                     \ 
     385     (*((string_a).pointer++) = *((string_b).pointer++),                        \ 
     386      *((string_a).pointer++) = *((string_b).pointer++),                        \ 
     387      *((string_a).pointer++) = *((string_b).pointer++)) :                      \ 
     388     (*(string_b).pointer & 0xF8) == 0xF0 ?                                     \ 
     389     (*((string_a).pointer++) = *((string_b).pointer++),                        \ 
     390      *((string_a).pointer++) = *((string_b).pointer++),                        \ 
     391      *((string_a).pointer++) = *((string_b).pointer++),                        \ 
     392      *((string_a).pointer++) = *((string_b).pointer++)) : 0) 
    144393 
    145394/* 
Note: See TracChangeset for help on using the changeset viewer.