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/yaml_private.h

    r263 r264  
    2929 */ 
    3030 
    31 #define ERROR_INIT(error,error_type)                                            \ 
    32     (memset(&(error), 0, sizeof(error)),                                        \ 
    33      (error).type = (error_type),                                               \ 
     31/* 
     32 * Generic error initializers; not to be used directly. 
     33 */ 
     34 
     35#define ERROR_INIT(error, _type)                                                \ 
     36    (memset(&(error), 0, sizeof(yaml_error_t)),                                 \ 
     37     (error).type = (_type),                                                    \ 
    3438     0) 
    3539 
    36 #define READING_ERROR_INIT(error,error_type,error_problem,error_offset,error_value) \ 
    37     (memset(&(error), 0, sizeof(error)),                                        \ 
    38      (error).type = (error_type),                                               \ 
    39      (error).data.reading.problem = (error_problem),                            \ 
    40      (error).data.reading.offset = (error_offset),                              \ 
    41      (error).data.reading.value = (error_value),                                \ 
     40#define READING_ERROR_INIT(error, _type, _problem, _offset, _value)             \ 
     41    (ERROR_INIT(error, _type),                                                  \ 
     42     (error).data.reading.problem = (_problem),                                 \ 
     43     (error).data.reading.offset = (_offset),                                   \ 
     44     (error).data.reading.value = (_value),                                     \ 
    4245     0) 
    4346 
    44 #define LOADING_ERROR_INIT(error,error_type,error_problem,error_problem_mark)   \ 
    45     (memset(&(error), 0, sizeof(error)),                                        \ 
    46      (error).type = (error_type),                                               \ 
     47#define LOADING_ERROR_INIT(error, _type, _problem, _problem_mark)               \ 
     48    (ERROR_INIT(error, _type),                                                  \ 
    4749     (error).data.loading.context = NULL,                                       \ 
    4850     (error).data.loading.context_mark.index = 0,                               \ 
    4951     (error).data.loading.context_mark.line = 0,                                \ 
    5052     (error).data.loading.context_mark.column = 0,                              \ 
    51      (error).data.loading.problem = (error_problem),                            \ 
    52      (error).data.loading.problem_mark = (error_problem_mark),                  \ 
     53     (error).data.loading.problem = (_problem),                                 \ 
     54     (error).data.loading.problem_mark = (_problem_mark),                       \ 
    5355     0) 
    5456 
    55 #define LOADING_ERROR_WITH_CONTEXT_INIT(error,error_type,error_context,error_context_mark,error_problem,error_problem_mark) \ 
    56     (memset(&(error), 0, sizeof(error)),                                        \ 
    57      (error).type = (error_type),                                               \ 
    58      (error).data.loading.context = (error_context),                            \ 
    59      (error).data.loading.context_mark = (error_context_mark),                  \ 
    60      (error).data.loading.problem = (error_problem),                            \ 
    61      (error).data.loading.problem_mark = (error_problem_mark),                  \ 
     57#define LOADING_ERROR_WITH_CONTEXT_INIT(error, _type, _context, _context_mark, \ 
     58        _problem, _problem_mark)                                                \ 
     59    (ERROR_INIT(error, _type),                                                  \ 
     60     (error).data.loading.context = (_context),                                 \ 
     61     (error).data.loading.context_mark = (_context_mark),                       \ 
     62     (error).data.loading.problem = (_problem),                                 \ 
     63     (error).data.loading.problem_mark = (_problem_mark),                       \ 
    6264     0) 
    6365 
    64 #define WRITING_ERROR_INIT(error,error_type,error_problem,error_offset)         \ 
    65     (memset(&(error), 0, sizeof(error)),                                        \ 
    66      (error).type = (error_type),                                               \ 
    67      (error).data.writing.problem = (error_problem),                            \ 
    68      (error).data.writing.offset = (error_offset),                              \ 
     66#define WRITING_ERROR_INIT(error, _type, _problem, _offset)                     \ 
     67    (ERROR_INIT(error, _type),                                                  \ 
     68     (error).data.writing.problem = (_problem),                                 \ 
     69     (error).data.writing.offset = (_offset),                                   \ 
    6970     0) 
    7071 
    71 #define DUMPING_ERROR_INIT(error,error_type,error_problem)                      \ 
    72     (memset(&(error), 0, sizeof(error)),                                        \ 
    73      (error).type = (error_type),                                               \ 
    74      (error).data.dumping.problem = (error_problem),                            \ 
     72#define DUMPING_ERROR_INIT(error, _type, _problem)                              \ 
     73    (ERROR_INIT(error, _type),                                                  \ 
     74     (error).data.dumping.problem = (_problem),                                 \ 
    7575     0) 
    7676 
     77#define RESOLVING_ERROR_INIT(error, _type, _problem)                            \ 
     78    (ERROR_INIT(error, _type),                                                  \ 
     79     (error).data.resolving.problem = (_problem),                               \ 
     80     0) 
     81 
     82/* 
     83 * Specific error initializers. 
     84 */ 
     85 
    7786#define MEMORY_ERROR_INIT(self)                                                 \ 
    78     ERROR_INIT((self)->error,YAML_MEMORY_ERROR) 
    79  
    80 #define READER_ERROR_INIT(self,problem,offset)                                  \ 
    81     READING_ERROR_INIT((self)->error,YAML_READER_ERROR,problem,offset,-1) 
    82  
    83 #define DECODER_ERROR_INIT(self,problem,offset,value)                           \ 
    84     READING_ERROR_INIT((self)->error,YAML_DECODER_ERROR,problem,offset,value) 
    85  
    86 #define SCANNER_ERROR_INIT(self,problem,problem_mark)                           \ 
    87     LOADING_ERROR_INIT((self)->error,YAML_SCANNER_ERROR,problem,problem_mark) 
    88  
    89 #define SCANNER_ERROR_WITH_CONTEXT_INIT(self,context,context_mark,problem,problem_mark) \ 
    90     LOADING_ERROR_WITH_CONTEXT_INIT((self)->error,YAML_SCANNER_ERROR,context,context_mark,problem,problem_mark) 
    91  
    92 #define PARSER_ERROR_INIT(self,problem,problem_mark)                            \ 
    93     LOADING_ERROR_INIT((self)->error,YAML_PARSER_ERROR,problem,problem_mark) 
    94  
    95 #define PARSER_ERROR_WITH_CONTEXT_INIT(self,context,context_mark,problem,problem_mark)  \ 
    96     LOADING_ERROR_WITH_CONTEXT_INIT((self)->error,YAML_PARSER_ERROR,context,context_mark,problem,problem_mark) 
    97  
    98 #define COMPOSER_ERROR_INIT(self,problem,problem_mark)                          \ 
    99     LOADING_ERROR_INIT((self)->error,YAML_COMPOSER_ERROR,problem,problem_mark) 
    100  
    101 #define COMPOSER_ERROR_WITH_CONTEXT_INIT(self,context,context_mark,problem,problem_mark)    \ 
    102     LOADING_ERROR_WITH_CONTEXT_INIT((self)->error,YAML_COMPOSER_ERROR,context,context_mark,problem,problem_mark) 
    103  
    104 #define WRITER_ERROR_INIT(self,problem,offset)                                  \ 
    105     WRITING_ERROR_INIT((self)->error,YAML_WRITER_ERROR,problem,offset) 
    106  
    107 #define EMITTER_ERROR_INIT(self,problem)                                        \ 
    108     DUMPING_ERROR_INIT((self)->error,YAML_EMITTER_ERROR,problem) 
    109  
    110 #define SERIALIZER_ERROR_INIT(self,context)                                     \ 
    111     DUMPING_ERROR_INIT((self)->error,YAML_SERIALIZER_ERROR,problem) 
     87    ERROR_INIT((self)->error, YAML_MEMORY_ERROR) 
     88 
     89#define READER_ERROR_INIT(self, _problem, _offset)                              \ 
     90    READING_ERROR_INIT((self)->error, YAML_READER_ERROR, _problem, _offset, -1) 
     91 
     92#define DECODER_ERROR_INIT(self, _problem, _offset, _value)                     \ 
     93    READING_ERROR_INIT((self)->error, YAML_DECODER_ERROR, _problem, _offset, _value) 
     94 
     95#define SCANNER_ERROR_INIT(self, _problem, _problem_mark)                       \ 
     96    LOADING_ERROR_INIT((self)->error, YAML_SCANNER_ERROR, _problem, _problem_mark) 
     97 
     98#define SCANNER_ERROR_WITH_CONTEXT_INIT(self, _context, _context_mark,          \ 
     99        _problem, _problem_mark)                                                \ 
     100    LOADING_ERROR_WITH_CONTEXT_INIT((self)->error, YAML_SCANNER_ERROR,          \ 
     101            _context, _context_mark, _problem, _problem_mark) 
     102 
     103#define PARSER_ERROR_INIT(self, _problem, _problem_mark)                        \ 
     104    LOADING_ERROR_INIT((self)->error, YAML_PARSER_ERROR, _problem, _problem_mark) 
     105 
     106#define PARSER_ERROR_WITH_CONTEXT_INIT(self, _context, _context_mark,           \ 
     107        _problem, _problem_mark)                                                \ 
     108    LOADING_ERROR_WITH_CONTEXT_INIT((self)->error, YAML_PARSER_ERROR,           \ 
     109            _context, _context_mark, _problem, _problem_mark) 
     110 
     111#define COMPOSER_ERROR_INIT(self, _problem, _problem_mark)                      \ 
     112    LOADING_ERROR_INIT((self)->error, YAML_COMPOSER_ERROR, _problem, _problem_mark) 
     113 
     114#define COMPOSER_ERROR_WITH_CONTEXT_INIT(self, _context, _context_mark,         \ 
     115        _problem, _problem_mark)                                                \ 
     116    LOADING_ERROR_WITH_CONTEXT_INIT((self)->error, YAML_COMPOSER_ERROR,         \ 
     117            _context, _context_mark, _problem, _problem_mark) 
     118 
     119#define WRITER_ERROR_INIT(self, _problem, _offset)                              \ 
     120    WRITING_ERROR_INIT((self)->error, YAML_WRITER_ERROR, _problem, _offset) 
     121 
     122#define EMITTER_ERROR_INIT(self, _problem)                                      \ 
     123    DUMPING_ERROR_INIT((self)->error, YAML_EMITTER_ERROR, _problem) 
     124 
     125#define SERIALIZER_ERROR_INIT(self, _problem)                                   \ 
     126    DUMPING_ERROR_INIT((self)->error, YAML_SERIALIZER_ERROR, _problem) 
     127 
     128#define RESOLVER_ERROR_INIT(self, _problem)                                     \ 
     129    RESOLVER_ERROR_INIT((self)->error, YAML_RESOLVER_ERROR, _problem) 
    112130 
    113131/* 
     
    153171 */ 
    154172 
    155 typedef struct yaml_string_s { 
     173/* 
     174 * An immutable string used as an input buffer. 
     175 */ 
     176 
     177typedef struct yaml_istring_s { 
     178    const yaml_char_t *buffer; 
     179    size_t pointer; 
     180    size_t length; 
     181} yaml_istring_t; 
     182 
     183/* 
     184 * A string that is used as an output buffer. 
     185 */ 
     186 
     187typedef struct yaml_ostring_s { 
    156188    yaml_char_t *buffer; 
    157189    size_t pointer; 
    158190    size_t capacity; 
    159 } yaml_string_t; 
     191} yaml_ostring_t; 
     192 
     193/* 
     194 * A string that could be used both as an input and an output buffer. 
     195 */ 
     196 
     197typedef struct yaml_iostring_s { 
     198    yaml_char_t *buffer; 
     199    size_t pointer; 
     200    size_t length; 
     201    size_t capacity; 
     202} yaml_iostring_t; 
     203 
     204/* 
     205 * Separate type for non-UTF-8 i/o strings. 
     206 */ 
     207 
     208typedef struct yaml_raw_iostring_s { 
     209    unsigned char *buffer; 
     210    size_t pointer; 
     211    size_t length; 
     212    size_t capacity; 
     213} yaml_raw_iostring_t; 
    160214 
    161215YAML_DECLARE(int) 
    162 yaml_string_extend(yaml_char_t **buffer, size_t *capacity); 
     216yaml_ostring_extend(yaml_char_t **buffer, size_t *capacity); 
    163217 
    164218YAML_DECLARE(int) 
    165 yaml_string_join( 
     219yaml_ostring_join( 
    166220        yaml_char_t **base_buffer, size_t *base_pointer, size_t *base_capacity, 
    167         yaml_char_t *adj_buffer, size_t adj_pointer, size_t adj_capacity); 
    168  
    169 #define NULL_STRING { NULL, 0, 0 } 
    170  
    171 #define STRING(string,capacity)   { (string), 0, (capacity) } 
    172  
    173 #define STRING_INIT(self,string,string_capacity)                                \ 
    174     (((string).buffer = yaml_malloc(string_capacity)) ?                         \ 
    175         ((string).pointer = 0,                                                  \ 
    176          (string).capacity = (string_capacity),                                 \ 
    177          memset((string).buffer, 0, (string_capacity)),                         \ 
     221        yaml_char_t *adj_buffer, size_t adj_pointer); 
     222 
     223#define ISTRING(buffer, length) { (buffer), 0, (length) } 
     224 
     225#define NULL_OSTRING { NULL, 0, 0 } 
     226 
     227#define IOSTRING_INIT(self, string, _capacity)                                  \ 
     228    (((string).buffer = yaml_malloc(_capacity)) ?                               \ 
     229        ((string).pointer = (string).length = 0,                                \ 
     230         (string).capacity = (_capacity),                                       \ 
     231         memset((string).buffer, 0, (_capacity)),                               \ 
    178232         1) :                                                                   \ 
    179233        ((self)->error.type = YAML_MEMORY_ERROR,                                \ 
    180234         0)) 
    181235 
    182 #define STRING_DEL(self,string)                                                 \ 
     236#define IOSTRING_DEL(self, string)                                              \ 
     237    (yaml_free((string).buffer),                                                \ 
     238     (string).buffer = NULL,                                                    \ 
     239     ((string).pointer = (string).length = (string).capacity = 0)) 
     240 
     241#define OSTRING_INIT(self, string, _capacity)                                   \ 
     242    (((string).buffer = yaml_malloc(_capacity)) ?                               \ 
     243        ((string).pointer = 0,                                                  \ 
     244         (string).capacity = (_capacity),                                       \ 
     245         memset((string).buffer, 0, (_capacity)),                               \ 
     246         1) :                                                                   \ 
     247        ((self)->error.type = YAML_MEMORY_ERROR,                                \ 
     248         0)) 
     249 
     250#define OSTRING_DEL(self, string)                                               \ 
    183251    (yaml_free((string).buffer),                                                \ 
    184252     (string).buffer = NULL,                                                    \ 
    185253     ((string).pointer = (string).capacity = 0)) 
    186254 
    187 #define STRING_EXTEND(self,string)                                              \ 
     255#define OSTRING_EXTEND(self, string)                                            \ 
    188256    ((((string).pointer+5 < (string).capacity)                                  \ 
    189         || yaml_string_extend(&(string).buffer, &(string).capacity)) ?          \ 
     257        || yaml_ostring_extend(&(string).buffer, &(string).capacity)) ?         \ 
    190258     1 :                                                                        \ 
    191259     ((self)->error.type = YAML_MEMORY_ERROR,                                   \ 
    192260      0)) 
    193261 
    194 #define CLEAR(self,string)                                                      \ 
     262#define CLEAR(self, string)                                                     \ 
    195263    ((string).pointer = 0,                                                      \ 
    196264     memset((string).buffer, 0, (string).capacity)) 
    197265 
    198 #define JOIN(self,base_string,adj_string)                                       \ 
    199     ((yaml_string_join(&(base_string).buffer, &(base_string).pointer,           \ 
    200                        &(base_string).capacity, (adj_string).buffer,            \ 
    201                        (adj_string).pointer, (adj_string).capacity)) ?          \ 
     266#define JOIN(self, base_string, adj_string)                                     \ 
     267    ((yaml_ostring_join(&(base_string).buffer, &(base_string).pointer,          \ 
     268                       &(base_string).capacity,                                 \ 
     269                       (adj_string).buffer, (adj_string).pointer)) ?            \ 
    202270        ((adj_string).pointer = 0,                                              \ 
    203271         1) :                                                                   \ 
     
    213281 */ 
    214282 
    215 #define OCTET_AT(string,offset)                                                 \ 
     283#define OCTET_AT(string, offset)                                                \ 
    216284    ((string).buffer[(string).pointer+(offset)]) 
    217285 
     
    220288 */ 
    221289 
    222 #define OCTET(string)   OCTET_AT((string),0) 
     290#define OCTET(string)   OCTET_AT((string), 0) 
    223291 
    224292/* 
     
    226294 */ 
    227295 
    228 #define CHECK_AT(string,octet,offset)                                           \ 
    229     (OCTET_AT((string),(offset)) == (yaml_char_t)(octet)) 
     296#define CHECK_AT(string, octet, offset)                                         \ 
     297    (OCTET_AT((string), (offset)) == (yaml_char_t)(octet)) 
    230298 
    231299/* 
     
    233301 */ 
    234302 
    235 #define CHECK(string,octet) CHECK_AT((string),(octet),0) 
     303#define CHECK(string, octet)    CHECK_AT((string), (octet), 0) 
    236304 
    237305/* 
     
    240308 */ 
    241309 
    242 #define IS_ALPHA_AT(string,offset)                                              \ 
    243      ((OCTET_AT((string),(offset)) >= (yaml_char_t) '0' &&                      \ 
    244        OCTET_AT((string),(offset)) <= (yaml_char_t) '9') ||                     \ 
    245       (OCTET_AT((string),(offset)) >= (yaml_char_t) 'A' &&                      \ 
    246        OCTET_AT((string),(offset)) <= (yaml_char_t) 'Z') ||                     \ 
    247       (OCTET_AT((string),(offset)) >= (yaml_char_t) 'a' &&                      \ 
    248        OCTET_AT((string),(offset)) <= (yaml_char_t) 'z') ||                     \ 
    249       OCTET_AT((string),(offset)) == '_' ||                                     \ 
    250       OCTET_AT((string),(offset)) == '-') 
    251  
    252 #define IS_ALPHA(string)    IS_ALPHA_AT((string),0) 
     310#define IS_ALPHA_AT(string, offset)                                             \ 
     311     ((OCTET_AT((string), (offset)) >= (yaml_char_t) '0' &&                     \ 
     312       OCTET_AT((string), (offset)) <= (yaml_char_t) '9') ||                    \ 
     313      (OCTET_AT((string), (offset)) >= (yaml_char_t) 'A' &&                     \ 
     314       OCTET_AT((string), (offset)) <= (yaml_char_t) 'Z') ||                    \ 
     315      (OCTET_AT((string), (offset)) >= (yaml_char_t) 'a' &&                     \ 
     316       OCTET_AT((string), (offset)) <= (yaml_char_t) 'z') ||                    \ 
     317      OCTET_AT((string), (offset)) == '_' ||                                    \ 
     318      OCTET_AT((string), (offset)) == '-') 
     319 
     320#define IS_ALPHA(string)    IS_ALPHA_AT((string), 0) 
    253321 
    254322/* 
     
    256324 */ 
    257325 
    258 #define IS_DIGIT_AT(string,offset)                                              \ 
    259      ((OCTET_AT((string),(offset)) >= (yaml_char_t) '0' &&                      \ 
    260        OCTET_AT((string),(offset)) <= (yaml_char_t) '9')) 
    261  
    262 #define IS_DIGIT(string)    IS_DIGIT_AT((string),0) 
     326#define IS_DIGIT_AT(string, offset)                                             \ 
     327     ((OCTET_AT((string), (offset)) >= (yaml_char_t) '0' &&                     \ 
     328       OCTET_AT((string), (offset)) <= (yaml_char_t) '9')) 
     329 
     330#define IS_DIGIT(string)    IS_DIGIT_AT((string), 0) 
    263331 
    264332/* 
     
    266334 */ 
    267335 
    268 #define AS_DIGIT_AT(string,offset)                                              \ 
    269      (OCTET_AT((string),(offset)) - (yaml_char_t) '0') 
    270  
    271 #define AS_DIGIT(string)    AS_DIGIT_AT((string),0) 
     336#define AS_DIGIT_AT(string, offset)                                             \ 
     337     (OCTET_AT((string), (offset)) - (yaml_char_t) '0') 
     338 
     339#define AS_DIGIT(string)    AS_DIGIT_AT((string), 0) 
    272340 
    273341/* 
     
    275343 */ 
    276344 
    277 #define IS_HEX_AT(string,offset)                                                \ 
    278      ((OCTET_AT((string),(offset)) >= (yaml_char_t) '0' &&                      \ 
    279        OCTET_AT((string),(offset)) <= (yaml_char_t) '9') ||                     \ 
    280       (OCTET_AT((string),(offset)) >= (yaml_char_t) 'A' &&                      \ 
    281        OCTET_AT((string),(offset)) <= (yaml_char_t) 'F') ||                     \ 
    282       (OCTET_AT((string),(offset)) >= (yaml_char_t) 'a' &&                      \ 
    283        OCTET_AT((string),(offset)) <= (yaml_char_t) 'f')) 
    284  
    285 #define IS_HEX(string)    IS_HEX_AT((string),0) 
     345#define IS_HEX_AT(string, offset)                                               \ 
     346     ((OCTET_AT((string), (offset)) >= (yaml_char_t) '0' &&                     \ 
     347       OCTET_AT((string), (offset)) <= (yaml_char_t) '9') ||                    \ 
     348      (OCTET_AT((string), (offset)) >= (yaml_char_t) 'A' &&                     \ 
     349       OCTET_AT((string), (offset)) <= (yaml_char_t) 'F') ||                    \ 
     350      (OCTET_AT((string), (offset)) >= (yaml_char_t) 'a' &&                     \ 
     351       OCTET_AT((string), (offset)) <= (yaml_char_t) 'f')) 
     352 
     353#define IS_HEX(string)    IS_HEX_AT((string), 0) 
    286354 
    287355/* 
     
    289357 */ 
    290358 
    291 #define AS_HEX_AT(string,offset)                                                \ 
    292       ((OCTET_AT((string),(offset)) >= (yaml_char_t) 'A' &&                     \ 
    293         OCTET_AT((string),(offset)) <= (yaml_char_t) 'F') ?                     \ 
    294        (OCTET_AT((string),(offset)) - (yaml_char_t) 'A' + 10) :                 \ 
    295        (OCTET_AT((string),(offset)) >= (yaml_char_t) 'a' &&                     \ 
    296         OCTET_AT((string),(offset)) <= (yaml_char_t) 'f') ?                     \ 
    297        (OCTET_AT((string),(offset)) - (yaml_char_t) 'a' + 10) :                 \ 
    298        (OCTET_AT((string),(offset)) - (yaml_char_t) '0')) 
     359#define AS_HEX_AT(string, offset)                                               \ 
     360      ((OCTET_AT((string), (offset)) >= (yaml_char_t) 'A' &&                    \ 
     361        OCTET_AT((string), (offset)) <= (yaml_char_t) 'F') ?                    \ 
     362       (OCTET_AT((string), (offset)) - (yaml_char_t) 'A' + 10) :                \ 
     363       (OCTET_AT((string), (offset)) >= (yaml_char_t) 'a' &&                    \ 
     364        OCTET_AT((string), (offset)) <= (yaml_char_t) 'f') ?                    \ 
     365       (OCTET_AT((string), (offset)) - (yaml_char_t) 'a' + 10) :                \ 
     366       (OCTET_AT((string), (offset)) - (yaml_char_t) '0')) 
    299367  
    300 #define AS_HEX(string)  AS_HEX_AT((string),0) 
     368#define AS_HEX(string)  AS_HEX_AT((string), 0) 
    301369  
    302370/* 
     
    304372 */ 
    305373 
    306 #define IS_ASCII_AT(string,offset)                                              \ 
    307     (OCTET_AT((string),(offset)) <= (yaml_char_t) '\x7F') 
    308  
    309 #define IS_ASCII(string)    IS_ASCII_AT((string),0) 
     374#define IS_ASCII_AT(string, offset)                                             \ 
     375    (OCTET_AT((string), (offset)) <= (yaml_char_t) '\x7F') 
     376 
     377#define IS_ASCII(string)    IS_ASCII_AT((string), 0) 
    310378 
    311379/* 
     
    313381 */ 
    314382 
    315 #define IS_PRINTABLE_AT(string,offset)                                          \ 
    316     ((OCTET_AT((string),(offset)) == 0x0A)          /* . == #x0A */             \ 
    317      || (OCTET_AT((string),(offset)) >= 0x20        /* #x20 <= . <= #x7E */     \ 
    318          && OCTET_AT((string),(offset)) <= 0x7E)                                \ 
    319      || (OCTET_AT((string),(offset)) == 0xC2        /* #0xA0 <= . <= #xD7FF */  \ 
    320          && OCTET_AT((string),(offset)+1) >= 0xA0)                              \ 
    321      || (OCTET_AT((string),(offset)) > 0xC2                                     \ 
    322          && OCTET_AT((string),(offset)) < 0xED)                                 \ 
    323      || (OCTET_AT((string),(offset)) == 0xED                                    \ 
    324          && OCTET_AT((string),(offset)+1) < 0xA0)                               \ 
    325      || (OCTET_AT((string),(offset)) == 0xEE)                                   \ 
    326      || (OCTET_AT((string),(offset)) == 0xEF        /* #xE000 <= . <= #xFFFD */ \ 
    327          && !(OCTET_AT((string),(offset)+1) == 0xBB        /* && . != #xFEFF */ \ 
    328              && OCTET_AT((string),(offset)+2) == 0xBF)                          \ 
    329          && !(OCTET_AT((string),(offset)+1) == 0xBF                             \ 
    330              && (OCTET_AT((string),(offset)+2) == 0xBE                          \ 
    331                  || OCTET_AT((string),(offset)+2) == 0xBF)))) 
    332  
    333 #define IS_PRINTABLE(string)    IS_PRINTABLE_AT((string),0) 
     383#define IS_PRINTABLE_AT(string, offset)                                         \ 
     384    ((OCTET_AT((string), (offset)) == 0x0A)         /* . == #x0A */             \ 
     385     || (OCTET_AT((string), (offset)) >= 0x20       /* #x20 <= . <= #x7E */     \ 
     386         && OCTET_AT((string), (offset)) <= 0x7E)                               \ 
     387     || (OCTET_AT((string), (offset)) == 0xC2       /* #0xA0 <= . <= #xD7FF */  \ 
     388         && OCTET_AT((string), (offset)+1) >= 0xA0)                             \ 
     389     || (OCTET_AT((string), (offset)) > 0xC2                                    \ 
     390         && OCTET_AT((string), (offset)) < 0xED)                                \ 
     391     || (OCTET_AT((string), (offset)) == 0xED                                   \ 
     392         && OCTET_AT((string), (offset)+1) < 0xA0)                              \ 
     393     || (OCTET_AT((string), (offset)) == 0xEE)                                  \ 
     394     || (OCTET_AT((string), (offset)) == 0xEF       /* #xE000 <= . <= #xFFFD */ \ 
     395         && !(OCTET_AT((string), (offset)+1) == 0xBB       /* && . != #xFEFF */ \ 
     396             && OCTET_AT((string), (offset)+2) == 0xBF)                         \ 
     397         && !(OCTET_AT((string), (offset)+1) == 0xBF                            \ 
     398             && (OCTET_AT((string), (offset)+2) == 0xBE                         \ 
     399                 || OCTET_AT((string), (offset)+2) == 0xBF)))) 
     400 
     401#define IS_PRINTABLE(string)    IS_PRINTABLE_AT((string), 0) 
    334402 
    335403/* 
     
    337405 */ 
    338406 
    339 #define IS_Z_AT(string,offset)    CHECK_AT((string),'\0',(offset)) 
    340  
    341 #define IS_Z(string)    IS_Z_AT((string),0) 
     407#define IS_Z_AT(string, offset)   CHECK_AT((string), '\0', (offset)) 
     408 
     409#define IS_Z(string)    IS_Z_AT((string), 0) 
    342410 
    343411/* 
     
    345413 */ 
    346414 
    347 #define IS_BOM_AT(string,offset)                                                \ 
    348      (CHECK_AT((string),'\xEF',(offset))                                        \ 
    349       && CHECK_AT((string),'\xBB',(offset)+1)                                   \ 
    350       && CHECK_AT((string),'\xBF',(offset)+2))  /* BOM (#xFEFF) */ 
    351  
    352 #define IS_BOM(string)  IS_BOM_AT(string,0) 
     415#define IS_BOM_AT(string, offset)                                               \ 
     416     (CHECK_AT((string), '\xEF', (offset))                                      \ 
     417      && CHECK_AT((string), '\xBB', (offset)+1)                                 \ 
     418      && CHECK_AT((string), '\xBF', (offset)+2))    /* BOM (#xFEFF) */ 
     419 
     420#define IS_BOM(string)  IS_BOM_AT(string, 0) 
    353421 
    354422/* 
     
    356424 */ 
    357425 
    358 #define IS_SPACE_AT(string,offset)  CHECK_AT((string),' ',(offset)) 
    359  
    360 #define IS_SPACE(string)    IS_SPACE_AT((string),0) 
     426#define IS_SPACE_AT(string, offset) CHECK_AT((string), ' ', (offset)) 
     427 
     428#define IS_SPACE(string)    IS_SPACE_AT((string), 0) 
    361429 
    362430/* 
     
    364432 */ 
    365433 
    366 #define IS_TAB_AT(string,offset)    CHECK_AT((string),'\t',(offset)) 
    367  
    368 #define IS_TAB(string)  IS_TAB_AT((string),0) 
     434#define IS_TAB_AT(string, offset)   CHECK_AT((string), '\t', (offset)) 
     435 
     436#define IS_TAB(string)  IS_TAB_AT((string), 0) 
    369437 
    370438/* 
     
    372440 */ 
    373441 
    374 #define IS_BLANK_AT(string,offset)                                              \ 
    375     (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) 
    376  
    377 #define IS_BLANK(string)    IS_BLANK_AT((string),0) 
     442#define IS_BLANK_AT(string, offset)                                             \ 
     443    (IS_SPACE_AT((string), (offset)) || IS_TAB_AT((string), (offset))) 
     444 
     445#define IS_BLANK(string)    IS_BLANK_AT((string), 0) 
    378446 
    379447/* 
     
    381449 */ 
    382450 
    383 #define IS_BREAK_AT(string,offset)                                              \ 
    384     (CHECK_AT((string),'\r',(offset))               /* CR (#xD)*/               \ 
    385      || CHECK_AT((string),'\n',(offset))            /* LF (#xA) */              \ 
    386      || (CHECK_AT((string),'\xC2',(offset))                                     \ 
    387          && CHECK_AT((string),'\x85',(offset)+1))   /* NEL (#x85) */            \ 
    388      || (CHECK_AT((string),'\xE2',(offset))                                     \ 
    389          && CHECK_AT((string),'\x80',(offset)+1)                                \ 
    390          && CHECK_AT((string),'\xA8',(offset)+2))   /* LS (#x2028) */           \ 
    391      || (CHECK_AT((string),'\xE2',(offset))                                     \ 
    392          && CHECK_AT((string),'\x80',(offset)+1)                                \ 
    393          && CHECK_AT((string),'\xA9',(offset)+2)))  /* PS (#x2029) */ 
    394  
    395 #define IS_BREAK(string)    IS_BREAK_AT((string),0) 
    396  
    397 #define IS_CRLF_AT(string,offset)                                               \ 
    398      (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) 
    399  
    400 #define IS_CRLF(string) IS_CRLF_AT((string),0) 
     451#define IS_BREAK_AT(string, offset)                                             \ 
     452    (CHECK_AT((string), '\r', (offset))                 /* CR (#xD)*/           \ 
     453     || CHECK_AT((string), '\n', (offset))              /* LF (#xA) */          \ 
     454     || (CHECK_AT((string), '\xC2', (offset))                                   \ 
     455         && CHECK_AT((string), '\x85', (offset)+1))     /* NEL (#x85) */        \ 
     456     || (CHECK_AT((string), '\xE2', (offset))                                   \ 
     457         && CHECK_AT((string), '\x80', (offset)+1)                              \ 
     458         && CHECK_AT((string), '\xA8', (offset)+2))     /* LS (#x2028) */       \ 
     459     || (CHECK_AT((string), '\xE2', (offset))                                   \ 
     460         && CHECK_AT((string), '\x80', (offset)+1)                              \ 
     461         && CHECK_AT((string), '\xA9', (offset)+2)))    /* PS (#x2029) */ 
     462 
     463#define IS_BREAK(string)    IS_BREAK_AT((string), 0) 
     464 
     465#define IS_CRLF_AT(string, offset)                                              \ 
     466     (CHECK_AT((string), '\r', (offset)) && CHECK_AT((string), '\n', (offset)+1)) 
     467 
     468#define IS_CRLF(string) IS_CRLF_AT((string), 0) 
    401469 
    402470/* 
     
    404472 */ 
    405473 
    406 #define IS_BREAKZ_AT(string,offset)                                             \ 
    407     (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) 
    408  
    409 #define IS_BREAKZ(string)   IS_BREAKZ_AT((string),0) 
     474#define IS_BREAKZ_AT(string, offset)                                            \ 
     475    (IS_BREAK_AT((string), (offset)) || IS_Z_AT((string), (offset))) 
     476 
     477#define IS_BREAKZ(string)   IS_BREAKZ_AT((string), 0) 
    410478 
    411479/* 
     
    413481 */ 
    414482 
    415 #define IS_SPACEZ_AT(string,offset)                                             \ 
    416     (IS_SPACE_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) 
    417  
    418 #define IS_SPACEZ(string)   IS_SPACEZ_AT((string),0) 
     483#define IS_SPACEZ_AT(string, offset)                                            \ 
     484    (IS_SPACE_AT((string), (offset)) || IS_BREAKZ_AT((string), (offset))) 
     485 
     486#define IS_SPACEZ(string)   IS_SPACEZ_AT((string), 0) 
    419487 
    420488/* 
     
    422490 */ 
    423491 
    424 #define IS_BLANKZ_AT(string,offset)                                             \ 
    425     (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) 
    426  
    427 #define IS_BLANKZ(string)   IS_BLANKZ_AT((string),0) 
     492#define IS_BLANKZ_AT(string, offset)                                            \ 
     493    (IS_BLANK_AT((string), (offset)) || IS_BREAKZ_AT((string), (offset))) 
     494 
     495#define IS_BLANKZ(string)   IS_BLANKZ_AT((string), 0) 
    428496 
    429497/* 
     
    431499 */ 
    432500 
    433 #define WIDTH_AT(string,offset)                                                 \ 
    434      ((OCTET_AT((string),(offset)) & 0x80) == 0x00 ? 1 :                        \ 
    435       (OCTET_AT((string),(offset)) & 0xE0) == 0xC0 ? 2 :                        \ 
    436       (OCTET_AT((string),(offset)) & 0xF0) == 0xE0 ? 3 :                        \ 
    437       (OCTET_AT((string),(offset)) & 0xF8) == 0xF0 ? 4 : 0) 
    438  
    439 #define WIDTH(string)   WIDTH_AT((string),0) 
     501#define WIDTH_AT(string, offset)                                                \ 
     502     ((OCTET_AT((string), (offset)) & 0x80) == 0x00 ? 1 :                       \ 
     503      (OCTET_AT((string), (offset)) & 0xE0) == 0xC0 ? 2 :                       \ 
     504      (OCTET_AT((string), (offset)) & 0xF0) == 0xE0 ? 3 :                       \ 
     505      (OCTET_AT((string), (offset)) & 0xF8) == 0xF0 ? 4 : 0) 
     506 
     507#define WIDTH(string)   WIDTH_AT((string), 0) 
    440508 
    441509/* 
     
    449517 */ 
    450518 
    451 #define JOIN_OCTET(string,octet)                                                \ 
     519#define JOIN_OCTET(string, octet)                                               \ 
    452520    ((string).buffer[(string).pointer++] = (octet)) 
    453521 
     
    456524 */ 
    457525 
    458 #define COPY_OCTET(string_a,string_b)                                           \ 
    459     ((string_a).buffer[(string_a).pointer++]                                    \ 
    460      = (string_b).buffer[(string_b).pointer++]) 
     526#define COPY_OCTET(target_string, source_string)                                \ 
     527    ((target_string).buffer[(target_string).pointer++]                          \ 
     528     = (source_string).buffer[(source_string).pointer++]) 
    461529 
    462530/* 
     
    464532 */ 
    465533 
    466 #define COPY(string_a,string_b)                                                 \ 
    467     ((OCTET(string_b) & 0x80) == 0x00 ?                                         \ 
    468      COPY_OCTET((string_a),(string_b)) :                                        \ 
    469      (OCTET(string_b) & 0xE0) == 0xC0 ?                                         \ 
    470      (COPY_OCTET((string_a),(string_b)),                                        \ 
    471       COPY_OCTET((string_a),(string_b))) :                                      \ 
    472      (OCTET(string_b) & 0xF0) == 0xE0 ?                                         \ 
    473      (COPY_OCTET((string_a),(string_b)),                                        \ 
    474       COPY_OCTET((string_a),(string_b)),                                        \ 
    475       COPY_OCTET((string_a),(string_b))) :                                      \ 
    476      (OCTET(string_b) & 0xF8) == 0xF0 ?                                         \ 
    477      (COPY_OCTET((string_a),(string_b)),                                        \ 
    478       COPY_OCTET((string_a),(string_b)),                                        \ 
    479       COPY_OCTET((string_a),(string_b)),                                        \ 
    480       COPY_OCTET((string_a),(string_b))) : 0)                                   \ 
     534#define COPY(target_string, source_string)                                      \ 
     535    ((OCTET(source_string) & 0x80) == 0x00 ?                                    \ 
     536     COPY_OCTET((target_string), (source_string)) :                             \ 
     537     (OCTET(source_string) & 0xE0) == 0xC0 ?                                    \ 
     538     (COPY_OCTET((target_string), (source_string)),                             \ 
     539      COPY_OCTET((target_string), (source_string))) :                           \ 
     540     (OCTET(source_string) & 0xF0) == 0xE0 ?                                    \ 
     541     (COPY_OCTET((target_string), (source_string)),                             \ 
     542      COPY_OCTET((target_string), (source_string)),                             \ 
     543      COPY_OCTET((target_string), (source_string))) :                           \ 
     544     (OCTET(source_string) & 0xF8) == 0xF0 ?                                    \ 
     545     (COPY_OCTET((target_string), (source_string)),                             \ 
     546      COPY_OCTET((target_string), (source_string)),                             \ 
     547      COPY_OCTET((target_string), (source_string)),                             \ 
     548      COPY_OCTET((target_string), (source_string))) : 0) 
    481549 
    482550/* 
     
    491559        size_t *head, size_t *tail, size_t *capacity); 
    492560 
    493 #define STACK_INIT(self,stack,stack_capacity)                                   \ 
    494     (((stack).list = yaml_malloc((stack_capacity)*sizeof(*(stack).list))) ?     \ 
     561#define STACK_INIT(self, stack, _capacity)                                      \ 
     562    (((stack).list = yaml_malloc((_capacity)*sizeof(*(stack).list))) ?          \ 
    495563        ((stack).length = 0,                                                    \ 
    496          (stack).capacity = (stack_capacity),                                   \ 
     564         (stack).capacity = (_capacity),                                        \ 
    497565         1) :                                                                   \ 
    498566        ((self)->error.type = YAML_MEMORY_ERROR,                                \ 
    499567         0)) 
    500568 
    501 #define STACK_DEL(self,stack)                                                   \ 
     569#define STACK_DEL(self, stack)                                                  \ 
    502570    (yaml_free((stack).list),                                                   \ 
    503571     (stack).list = NULL,                                                       \ 
    504572     (stack).length = (stack).capacity = 0) 
    505573 
    506 #define STACK_EMPTY(self,stack)                                                 \ 
     574#define STACK_EMPTY(self, stack)                                                \ 
    507575    ((stack).length == 0) 
    508576 
    509 #define PUSH(self,stack,value)                                                  \ 
     577#define STACK_ITER(self, stack, index)                                          \ 
     578    ((stack).list + index) 
     579 
     580#define PUSH(self, stack, value)                                                \ 
    510581    (((stack).length < (stack).capacity                                         \ 
    511582      || yaml_stack_extend((void **)&(stack).list, sizeof(*(stack).list),       \ 
     
    516587         0)) 
    517588 
    518 #define POP(self,stack)                                                         \ 
     589#define POP(self, stack)                                                        \ 
    519590    ((stack).list[--(stack).length]) 
    520591 
    521 #define QUEUE_INIT(self,queue,queue_capacity)                                   \ 
    522     (((queue).list = yaml_malloc((queue_capacity)*sizeof(*(queue).list))) ?     \ 
     592#define QUEUE_INIT(self, queue, _capacity)                                      \ 
     593    (((queue).list = yaml_malloc((_capacity)*sizeof(*(queue).list))) ?          \ 
    523594        ((queue).head = (queue).tail = 0,                                       \ 
    524          (queue).capacity = (queue_capacity),                                   \ 
     595         (queue).capacity = (_capacity),                                        \ 
    525596         1) :                                                                   \ 
    526597        ((self)->error.type = YAML_MEMORY_ERROR,                                \ 
    527598         0)) 
    528599 
    529 #define QUEUE_DEL(self,queue)                                                   \ 
     600#define QUEUE_DEL(self, queue)                                                  \ 
    530601    (yaml_free((queue).list),                                                   \ 
    531602     (queue).list = NULL,                                                       \ 
    532603     (queue).head = (queue).tail = (queue).capacity = 0) 
    533604 
    534 #define QUEUE_EMPTY(self,queue)                                                 \ 
     605#define QUEUE_EMPTY(self, queue)                                                \ 
    535606    ((queue).head == (queue).tail) 
    536607 
    537 #define ENQUEUE(self,queue,value)                                               \ 
     608#define QUEUE_ITER(self, queue, index)                                          \ 
     609    ((queue).list + (queue).head + index) 
     610 
     611#define ENQUEUE(self, queue, value)                                             \ 
    538612    (((queue).tail != (queue).capacity                                          \ 
    539613      || yaml_queue_extend((void **)&(queue).list, sizeof(*(queue).list),       \ 
     
    544618         0)) 
    545619 
    546 #define DEQUEUE(self,queue)                                                     \ 
     620#define DEQUEUE(self, queue)                                                    \ 
    547621    ((queue).list[(queue).head++]) 
    548622 
    549 #define QUEUE_INSERT(self,queue,index,value)                                    \ 
     623#define QUEUE_INSERT(self, queue, index, value)                                 \ 
    550624    (((queue).tail != (queue).capacity                                          \ 
    551625      || yaml_queue_extend((void **)&(queue).list, sizeof(*(queue).list),       \ 
     
    564638 */ 
    565639 
    566 #define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark)            \ 
     640#define TOKEN_INIT(token, _type, _start_mark, _end_mark)                        \ 
    567641    (memset(&(token), 0, sizeof(yaml_token_t)),                                 \ 
    568      (token).type = (token_type),                                               \ 
    569      (token).start_mark = (token_start_mark),                                   \ 
    570      (token).end_mark = (token_end_mark)) 
    571  
    572 #define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark)       \ 
    573     (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)),       \ 
    574      (token).data.stream_start.encoding = (token_encoding)) 
    575  
    576 #define STREAM_END_TOKEN_INIT(token,start_mark,end_mark)                        \ 
    577     (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark))) 
    578  
    579 #define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark)                 \ 
    580     (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)),              \ 
    581      (token).data.alias.value = (token_value)) 
    582  
    583 #define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark)                \ 
    584     (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)),             \ 
    585      (token).data.anchor.value = (token_value)) 
    586  
    587 #define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark)     \ 
    588     (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)),                \ 
    589      (token).data.tag.handle = (token_handle),                                  \ 
    590      (token).data.tag.suffix = (token_suffix)) 
    591  
    592 #define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark)   \ 
    593     (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)),             \ 
    594      (token).data.scalar.value = (token_value),                                 \ 
    595      (token).data.scalar.length = (token_length),                               \ 
    596      (token).data.scalar.style = (token_style)) 
    597  
    598 #define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark)    \ 
    599     (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ 
    600      (token).data.version_directive.major = (token_major),                      \ 
    601      (token).data.version_directive.minor = (token_minor)) 
    602  
    603 #define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark)       \ 
    604     (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)),      \ 
    605      (token).data.tag_directive.handle = (token_handle),                        \ 
    606      (token).data.tag_directive.prefix = (token_prefix)) 
     642     (token).type = (_type),                                                    \ 
     643     (token).start_mark = (_start_mark),                                        \ 
     644     (token).end_mark = (_end_mark)) 
     645 
     646#define STREAM_START_TOKEN_INIT(token, _encoding, _start_mark, _end_mark)       \ 
     647    (TOKEN_INIT((token), YAML_STREAM_START_TOKEN, (_start_mark), (_end_mark)),  \ 
     648     (token).data.stream_start.encoding = (_encoding)) 
     649 
     650#define STREAM_END_TOKEN_INIT(token, _start_mark, _end_mark)                    \ 
     651    (TOKEN_INIT((token), YAML_STREAM_END_TOKEN, (_start_mark), (_end_mark))) 
     652 
     653#define ALIAS_TOKEN_INIT(token, _value, _start_mark, _end_mark)                 \ 
     654    (TOKEN_INIT((token), YAML_ALIAS_TOKEN, (_start_mark), (_end_mark)),         \ 
     655     (token).data.alias.value = (_value)) 
     656 
     657#define ANCHOR_TOKEN_INIT(token, _value, _start_mark, _end_mark)                \ 
     658    (TOKEN_INIT((token), YAML_ANCHOR_TOKEN, (_start_mark), (_end_mark)),        \ 
     659     (token).data.anchor.value = (_value)) 
     660 
     661#define TAG_TOKEN_INIT(token, _handle, _suffix, _start_mark, _end_mark)         \ 
     662    (TOKEN_INIT((token), YAML_TAG_TOKEN, (_start_mark), (_end_mark)),           \ 
     663     (token).data.tag.handle = (_handle),                                       \ 
     664     (token).data.tag.suffix = (_suffix)) 
     665 
     666#define SCALAR_TOKEN_INIT(token, _value, _length, _style, _start_mark, _end_mark)   \ 
     667    (TOKEN_INIT((token), YAML_SCALAR_TOKEN, (_start_mark), (_end_mark)),        \ 
     668     (token).data.scalar.value = (_value),                                      \ 
     669     (token).data.scalar.length = (_length),                                    \ 
     670     (token).data.scalar.style = (_style)) 
     671 
     672#define VERSION_DIRECTIVE_TOKEN_INIT(token, _major, _minor, _start_mark, _end_mark) \ 
     673    (TOKEN_INIT((token), YAML_VERSION_DIRECTIVE_TOKEN, (_start_mark), (_end_mark)), \ 
     674     (token).data.version_directive.major = (_major),                           \ 
     675     (token).data.version_directive.minor = (_minor)) 
     676 
     677#define TAG_DIRECTIVE_TOKEN_INIT(token, _handle, _prefix, _start_mark, _end_mark)   \ 
     678    (TOKEN_INIT((token), YAML_TAG_DIRECTIVE_TOKEN, (_start_mark), (_end_mark)), \ 
     679     (token).data.tag_directive.handle = (_handle),                             \ 
     680     (token).data.tag_directive.prefix = (_prefix)) 
    607681 
    608682/* 
     
    610684 */ 
    611685 
    612 #define EVENT_INIT(event,event_type,event_start_mark,event_end_mark)            \ 
     686#define EVENT_INIT(event, _type, _start_mark, _end_mark)                        \ 
    613687    (memset(&(event), 0, sizeof(yaml_event_t)),                                 \ 
    614      (event).type = (event_type),                                               \ 
    615      (event).start_mark = (event_start_mark),                                   \ 
    616      (event).end_mark = (event_end_mark)) 
    617  
    618 #define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark)       \ 
    619     (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)),       \ 
    620      (event).data.stream_start.encoding = (event_encoding)) 
    621  
    622 #define STREAM_END_EVENT_INIT(event,start_mark,end_mark)                        \ 
    623     (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) 
    624  
    625 #define DOCUMENT_START_EVENT_INIT(event,event_version_directive,                \ 
    626         event_tag_directives_list,event_tag_directives_length,                  \ 
    627         event_tag_directives_capacity,event_is_implicit,start_mark,end_mark)    \ 
    628     (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)),     \ 
    629      (event).data.document_start.version_directive = (event_version_directive), \ 
    630      (event).data.document_start.tag_directives.list = (event_tag_directives_list), \ 
    631      (event).data.document_start.tag_directives.length = (event_tag_directives_length), \ 
    632      (event).data.document_start.tag_directives.capacity = (event_tag_directives_capacity), \ 
    633      (event).data.document_start.is_implicit = (event_is_implicit)) 
    634  
    635 #define DOCUMENT_END_EVENT_INIT(event,event_is_implicit,start_mark,end_mark)    \ 
    636     (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)),       \ 
    637      (event).data.document_end.is_implicit = (event_is_implicit)) 
    638  
    639 #define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark)                \ 
    640     (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)),              \ 
    641      (event).data.alias.anchor = (event_anchor)) 
    642  
    643 #define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,             \ 
    644         event_length,event_is_plain_implicit,event_is_quoted_implicit,          \ 
    645         event_style,start_mark,end_mark)                                        \ 
    646     (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)),             \ 
    647      (event).data.scalar.anchor = (event_anchor),                               \ 
    648      (event).data.scalar.tag = (event_tag),                                     \ 
    649      (event).data.scalar.value = (event_value),                                 \ 
    650      (event).data.scalar.length = (event_length),                               \ 
    651      (event).data.scalar.is_plain_implicit = (event_is_plain_implicit),         \ 
    652      (event).data.scalar.is_quoted_implicit = (event_is_quoted_implicit),       \ 
    653      (event).data.scalar.style = (event_style)) 
    654  
    655 #define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag,                 \ 
    656         event_is_implicit,event_style,start_mark,end_mark)                      \ 
    657     (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)),     \ 
    658      (event).data.sequence_start.anchor = (event_anchor),                       \ 
    659      (event).data.sequence_start.tag = (event_tag),                             \ 
    660      (event).data.sequence_start.is_implicit = (event_is_implicit),             \ 
    661      (event).data.sequence_start.style = (event_style)) 
    662  
    663 #define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark)                      \ 
    664     (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) 
    665  
    666 #define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag,                  \ 
    667         event_is_implicit,event_style,start_mark,end_mark)                      \ 
    668     (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)),      \ 
    669      (event).data.mapping_start.anchor = (event_anchor),                        \ 
    670      (event).data.mapping_start.tag = (event_tag),                              \ 
    671      (event).data.mapping_start.is_implicit = (event_is_implicit),              \ 
    672      (event).data.mapping_start.style = (event_style)) 
    673  
    674 #define MAPPING_END_EVENT_INIT(event,start_mark,end_mark)                       \ 
    675     (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) 
     688     (event).type = (_type),                                                    \ 
     689     (event).start_mark = (_start_mark),                                        \ 
     690     (event).end_mark = (_end_mark)) 
     691 
     692#define STREAM_START_EVENT_INIT(event, _encoding, _start_mark, _end_mark)       \ 
     693    (EVENT_INIT((event), YAML_STREAM_START_EVENT, (_start_mark), (_end_mark)),  \ 
     694     (event).data.stream_start.encoding = (_encoding)) 
     695 
     696#define STREAM_END_EVENT_INIT(event, _start_mark, _end_mark)                    \ 
     697    (EVENT_INIT((event), YAML_STREAM_END_EVENT, (_start_mark), (_end_mark))) 
     698 
     699#define DOCUMENT_START_EVENT_INIT(event, _version_directive,                    \ 
     700        _tag_directives_list, _tag_directives_length, _tag_directives_capacity, \ 
     701        _is_implicit, _start_mark, _end_mark)                                   \ 
     702    (EVENT_INIT((event), YAML_DOCUMENT_START_EVENT, (_start_mark),(_end_mark)), \ 
     703     (event).data.document_start.version_directive = (_version_directive),      \ 
     704     (event).data.document_start.tag_directives.list = (_tag_directives_list),  \ 
     705     (event).data.document_start.tag_directives.length = (_tag_directives_length),  \ 
     706     (event).data.document_start.tag_directives.capacity = (_tag_directives_capacity),  \ 
     707     (event).data.document_start.is_implicit = (_is_implicit)) 
     708 
     709#define DOCUMENT_END_EVENT_INIT(event, _is_implicit, _start_mark, _end_mark)    \ 
     710    (EVENT_INIT((event), YAML_DOCUMENT_END_EVENT, (_start_mark), (_end_mark)),  \ 
     711     (event).data.document_end.is_implicit = (_is_implicit)) 
     712 
     713#define ALIAS_EVENT_INIT(event, _anchor, _start_mark, _end_mark)                \ 
     714    (EVENT_INIT((event), YAML_ALIAS_EVENT, (_start_mark), (_end_mark)),         \ 
     715     (event).data.alias.anchor = (_anchor)) 
     716 
     717#define SCALAR_EVENT_INIT(event, _anchor, _tag, _value, _length,                \ 
     718        _is_plain_implicit, _is_quoted_implicit, _style, _start_mark, _end_mark)    \ 
     719    (EVENT_INIT((event), YAML_SCALAR_EVENT, (_start_mark), (_end_mark)),        \ 
     720     (event).data.scalar.anchor = (_anchor),                                    \ 
     721     (event).data.scalar.tag = (_tag),                                          \ 
     722     (event).data.scalar.value = (_value),                                      \ 
     723     (event).data.scalar.length = (_length),                                    \ 
     724     (event).data.scalar.is_plain_implicit = (_is_plain_implicit),              \ 
     725     (event).data.scalar.is_quoted_implicit = (_is_quoted_implicit),            \ 
     726     (event).data.scalar.style = (_style)) 
     727 
     728#define SEQUENCE_START_EVENT_INIT(event, _anchor, _tag, _is_implicit, _style,   \ 
     729        _start_mark, _end_mark)                                                 \ 
     730    (EVENT_INIT((event), YAML_SEQUENCE_START_EVENT, (_start_mark), (_end_mark)),    \ 
     731     (event).data.sequence_start.anchor = (_anchor),                            \ 
     732     (event).data.sequence_start.tag = (_tag),                                  \ 
     733     (event).data.sequence_start.is_implicit = (_is_implicit),                  \ 
     734     (event).data.sequence_start.style = (_style)) 
     735 
     736#define SEQUENCE_END_EVENT_INIT(event, _start_mark, _end_mark)                  \ 
     737    (EVENT_INIT((event), YAML_SEQUENCE_END_EVENT, (_start_mark), (_end_mark))) 
     738 
     739#define MAPPING_START_EVENT_INIT(event, _anchor, _tag, _is_implicit, _style,    \ 
     740        _start_mark, _end_mark)                                                 \ 
     741    (EVENT_INIT((event), YAML_MAPPING_START_EVENT, (_start_mark), (_end_mark)), \ 
     742     (event).data.mapping_start.anchor = (_anchor),                             \ 
     743     (event).data.mapping_start.tag = (_tag),                                   \ 
     744     (event).data.mapping_start.is_implicit = (_is_implicit),                   \ 
     745     (event).data.mapping_start.style = (_style)) 
     746 
     747#define MAPPING_END_EVENT_INIT(event, _start_mark, _end_mark)                   \ 
     748    (EVENT_INIT((event), YAML_MAPPING_END_EVENT, (_start_mark), (_end_mark))) 
     749 
     750#if 0 
    676751 
    677752/* 
     
    728803     (node).data.mapping.pairs.top = (node_pairs_start),                        \ 
    729804     (node).data.mapping.style = (node_style)) 
     805 
     806#endif 
    730807 
    731808/* 
     
    818895typedef union yaml_standard_reader_data_u { 
    819896    /* String input data. */ 
    820     yaml_string_t string; 
     897    yaml_istring_t string; 
    821898    /* File input data. */ 
    822899    FILE *file; 
     
    852929 
    853930    /* The working buffer. */ 
    854     struct { 
    855         yaml_char_t *buffer; 
    856         size_t pointer; 
    857         size_t capacity; 
    858     } input; 
     931    yaml_iostring_t input; 
    859932 
    860933    /* The number of unread characters in the buffer. */ 
     
    862935 
    863936    /* The raw buffer. */ 
    864     struct { 
    865         unsigned char *buffer; 
    866         size_t pointer; 
    867         size_t capacity; 
    868     } raw_input; 
     937    yaml_raw_iostring_t raw_input; 
    869938 
    870939    /* The input encoding. */ 
     
    10231092typedef union yaml_standard_writer_data_u { 
    10241093    /* String output data. */ 
    1025     yaml_string_t string; 
     1094    yaml_ostring_t string; 
    10261095    size_t *length; 
    10271096    /* File output data. */ 
     
    10551124 
    10561125    /* The working buffer. */ 
    1057     struct { 
    1058         yaml_char_t *buffer; 
    1059         size_t pointer; 
    1060         size_t capacity; 
    1061     } output; 
     1126    yaml_iostring_t output; 
    10621127 
    10631128    /* The raw buffer. */ 
    1064     struct { 
    1065         yaml_char_t *buffer; 
    1066         size_t pointer; 
    1067         size_t capacity; 
    1068     } raw_output; 
     1129    yaml_raw_iostring_t raw_output; 
    10691130 
    10701131    /* The offset of the current position (in bytes). */ 
     
    11481209    struct { 
    11491210        /* The anchor value. */ 
    1150         yaml_char_t *anchor; 
     1211        const yaml_char_t *anchor; 
    11511212        /* The anchor length. */ 
    11521213        size_t anchor_length; 
     
    11581219    struct { 
    11591220        /* The tag handle. */ 
    1160         yaml_char_t *handle; 
     1221        const yaml_char_t *handle; 
    11611222        /* The tag handle length. */ 
    11621223        size_t handle_length; 
    11631224        /* The tag suffix. */ 
    1164         yaml_char_t *suffix; 
     1225        const yaml_char_t *suffix; 
    11651226        /* The tag suffix length. */ 
    11661227        size_t suffix_length; 
     
    11701231    struct { 
    11711232        /* The scalar value. */ 
    1172         yaml_char_t *value; 
     1233        const yaml_char_t *value; 
    11731234        /* The scalar length. */ 
    11741235        size_t length; 
Note: See TracChangeset for help on using the changeset viewer.