Changeset 264


Ignore:
Timestamp:
12/27/07 12:14:01 (7 years ago)
Author:
xi
Message:

Another round of API update.

Location:
libyaml/trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • libyaml/trunk/configure.ac

    r238 r264  
    33# Define the package version numbers and the bug reporting link. 
    44m4_define([YAML_MAJOR], 0) 
    5 m4_define([YAML_MINOR], 0) 
    6 m4_define([YAML_PATCH], 1) 
     5m4_define([YAML_MINOR], 2) 
     6m4_define([YAML_PATCH], 0) 
    77m4_define([YAML_BUGS], [http://pyyaml.org/newticket?component=libyaml]) 
    88 
     
    1919#           YAML_AGE = 0 
    2020m4_define([YAML_RELEASE], 0) 
    21 m4_define([YAML_CURRENT], 1) 
     21m4_define([YAML_CURRENT], 2) 
    2222m4_define([YAML_REVISION], 0) 
    2323m4_define([YAML_AGE], 0) 
     
    2929AC_CONFIG_HEADERS([config.h]) 
    3030AM_INIT_AUTOMAKE([1.9 foreign]) 
    31  
    32 # Define macro variables for the package version numbers. 
    33 AC_DEFINE(YAML_VERSION_MAJOR, YAML_MAJOR, [Define the major version number.]) 
    34 AC_DEFINE(YAML_VERSION_MINOR, YAML_MINOR, [Define the minor version number.]) 
    35 AC_DEFINE(YAML_VERSION_PATCH, YAML_PATCH, [Define the patch version number.]) 
    36 AC_DEFINE(YAML_VERSION_STRING, "YAML_MAJOR.YAML_MINOR.YAML_PATCH", [Define the version string.]) 
    3731 
    3832# Define substitutions for the libtool version numbers. 
  • libyaml/trunk/include/yaml.h

    r261 r264  
    4646 */ 
    4747 
    48 /** 
    49  * Get the library version as a string. 
    50  * 
    51  * @returns The function returns the pointer to a static string of the form 
    52  * @c "X.Y.Z", where @c X is the major version number, @c Y is a minor version 
    53  * number, and @c Z is the patch version number. 
    54  */ 
    55  
    56 YAML_DECLARE(const char *) 
    57 yaml_get_version_string(void); 
    58  
    59 /** 
    60  * Get the library version numbers. 
     48/** The major version number. */ 
     49#define YAML_VERSION_MAJOR  0 
     50 
     51/** The minor version number. */ 
     52#define YAML_VERSION_MINOR  2 
     53 
     54/** The patch version number. */ 
     55#define YAML_VERSION_PATCH  0 
     56 
     57/** The version string generator macro. */ 
     58#define YAML_VERSION_STRING_GENERATOR(major,minor,patch)                        \ 
     59    (#major "." #minor "." #patch) 
     60 
     61/** The version string. */ 
     62#define YAML_VERSION_STRING                                                     \ 
     63    YAML_VERSION_STRING_GENERATOR(YAML_VERSION_MAJOR,YAML_VERSION_MINOR,YAML_VERSION_PATCH) 
     64 
     65/** 
     66 * Get the library version numbers at runtime. 
    6167 * 
    6268 * @param[out]      major   Major version number. 
     
    6773YAML_DECLARE(void) 
    6874yaml_get_version(int *major, int *minor, int *patch); 
     75 
     76/** 
     77 * Get the library version as a string at runtime. 
     78 * 
     79 * @returns The function returns the pointer to a static string of the form 
     80 * @c "X.Y.Z", where @c X is the major version number, @c Y is the minor version 
     81 * number, and @c Z is the patch version number. 
     82 */ 
     83 
     84YAML_DECLARE(const char *) 
     85yaml_get_version_string(void); 
    6986 
    7087/** @} */ 
     
    87104    /** Cannot decode the input stream. */ 
    88105    YAML_DECODER_ERROR, 
    89  
    90106    /** Cannot scan a YAML token. */ 
    91107    YAML_SCANNER_ERROR, 
     
    97113    /** Cannot write into the output stream. */ 
    98114    YAML_WRITER_ERROR, 
    99  
    100115    /** Cannot emit a YAML event. */ 
    101116    YAML_EMITTER_ERROR, 
    102117    /** Cannot serialize a YAML document. */ 
    103     YAML_SERIALIZER_ERROR 
     118    YAML_SERIALIZER_ERROR, 
     119 
     120    /** Cannot resolve an implicit tag. */ 
     121    YAML_RESOLVER_ERROR 
    104122} yaml_error_type_t; 
    105123 
     
    143161         */ 
    144162        struct { 
    145             /** The problem description. */ 
    146             const char *problem; 
    147             /** The problem mark. */ 
    148             yaml_mark_t problem_mark; 
    149163            /** The context in which the problem occured 
    150164             * (@c NULL if not applicable). 
     
    153167            /** The context mark (if @c problem_mark is not @c NULL). **/ 
    154168            yaml_mark_t context_mark; 
     169            /** The problem description. */ 
     170            const char *problem; 
     171            /** The problem mark. */ 
     172            yaml_mark_t problem_mark; 
    155173        } loading; 
    156174 
     
    171189        } dumping; 
    172190 
     191        /** A problem while resolving an implicit tag (@c YAML_RESOLVER_ERROR). */ 
     192        struct { 
     193            /** The problem description. */ 
     194            const char *problem; 
     195        } resolving; 
     196 
    173197    } data; 
    174198 
    175199} yaml_error_t; 
    176200 
     201/** 
     202 * Create an error message. 
     203 * 
     204 * @param[in]   error   An error object. 
     205 * @param[out]  buffer         model   A token to copy. 
     206 * 
     207 * @returns @c 1 if the function succeeded, @c 0 on error.  The function may 
     208 * fail if the buffer is not large enough to contain the whole message. 
     209 */ 
     210 
     211YAML_DECLARE(int) 
     212yaml_error_message(yaml_error_t *error, char *buffer, size_t capacity); 
    177213 
    178214/** @} */ 
     
    434470 
    435471YAML_DECLARE(int) 
    436 yaml_token_duplicate(yaml_token_t *token, yaml_token_t *model); 
     472yaml_token_duplicate(yaml_token_t *token, const yaml_token_t *model); 
    437473 
    438474/** 
     
    608644 
    609645YAML_DECLARE(int) 
    610 yaml_event_duplicate(yaml_event_t *event, yaml_event_t *model); 
     646yaml_event_duplicate(yaml_event_t *event, const yaml_event_t *model); 
    611647 
    612648/** 
     
    792828 
    793829/** The tag @c !!null with the only possible value: @c null. */ 
    794 #define YAML_NULL_TAG       "tag:yaml.org,2002:null" 
     830#define YAML_NULL_TAG       ((const yaml_char_t *) "tag:yaml.org,2002:null") 
    795831/** The tag @c !!bool with the values: @c true and @c falce. */ 
    796 #define YAML_BOOL_TAG       "tag:yaml.org,2002:bool" 
     832#define YAML_BOOL_TAG       ((const yaml_char_t *) "tag:yaml.org,2002:bool") 
    797833/** The tag @c !!str for string values. */ 
    798 #define YAML_STR_TAG        "tag:yaml.org,2002:str" 
     834#define YAML_STR_TAG        ((const yaml_char_t *) "tag:yaml.org,2002:str") 
    799835/** The tag @c !!int for integer values. */ 
    800 #define YAML_INT_TAG        "tag:yaml.org,2002:int" 
     836#define YAML_INT_TAG        ((const yaml_char_t *) "tag:yaml.org,2002:int") 
    801837/** The tag @c !!float for float values. */ 
    802 #define YAML_FLOAT_TAG      "tag:yaml.org,2002:float" 
     838#define YAML_FLOAT_TAG      ((const yaml_char_t *) "tag:yaml.org,2002:float") 
    803839 
    804840/** The tag @c !!seq is used to denote sequences. */ 
    805 #define YAML_SEQ_TAG        "tag:yaml.org,2002:seq" 
     841#define YAML_SEQ_TAG        ((const yaml_char_t *) "tag:yaml.org,2002:seq") 
    806842/** The tag @c !!map is used to denote mapping. */ 
    807 #define YAML_MAP_TAG        "tag:yaml.org,2002:map" 
     843#define YAML_MAP_TAG        ((const yaml_char_t *) "tag:yaml.org,2002:map") 
    808844 
    809845/** The default scalar tag is @c !!str. */ 
     
    12281264 */ 
    12291265 
    1230 typedef int yaml_writer_t(void *data, unsigned char *buffer, size_t length); 
     1266typedef int yaml_writer_t(void *data, const unsigned char *buffer, 
     1267        size_t length); 
    12311268 
    12321269/** 
     
    13991436 
    14001437YAML_DECLARE(int) 
    1401 yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token); 
     1438yaml_parser_parse_token(yaml_parser_t *parser, yaml_token_t *token); 
    14021439 
    14031440/** 
     
    14231460 
    14241461YAML_DECLARE(int) 
    1425 yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event); 
     1462yaml_parser_parse_event(yaml_parser_t *parser, yaml_event_t *event); 
    14261463 
    14271464#if 0 
     
    14501487 
    14511488YAML_DECLARE(int) 
    1452 yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document); 
     1489yaml_parser_parse_document(yaml_parser_t *parser, yaml_document_t *document); 
    14531490 
    14541491#endif 
     
    16481685 
    16491686YAML_DECLARE(int) 
    1650 yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event); 
     1687yaml_emitter_emit_event(yaml_emitter_t *emitter, yaml_event_t *event); 
    16511688 
    16521689#if 0 
     
    16951732 
    16961733YAML_DECLARE(int) 
    1697 yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document); 
     1734yaml_emitter_emit_document(yaml_emitter_t *emitter, yaml_document_t *document); 
    16981735 
    16991736#endif 
  • libyaml/trunk/src/api.c

    r263 r264  
    6868 
    6969/* 
     70 * Format an error message. 
     71 */ 
     72 
     73YAML_DECLARE(int) 
     74yaml_error_message(yaml_error_t *error, char *buffer, size_t capacity) 
     75{ 
     76    char *prefixes[] = { 
     77        "No error", 
     78        "Memory error", 
     79        "Reader error", 
     80        "Decoder error", 
     81        "Scanner error", 
     82        "Parser error", 
     83        "Composer error", 
     84        "Writer error", 
     85        "Emitter error", 
     86        "Serializer error", 
     87        "Resolver error", 
     88    }; 
     89    int length; 
     90 
     91    assert(error);  /* Non-NULL error is expected. */ 
     92    assert(buffer); /* Non-NULL buffer is expected. */ 
     93 
     94    switch (error->type) 
     95    { 
     96        case YAML_NO_ERROR: 
     97        case YAML_MEMORY_ERROR: 
     98            length = snprintf(buffer, capacity, "%s", 
     99                    prefixes[error->type]); 
     100            break; 
     101 
     102        case YAML_READER_ERROR: 
     103        case YAML_DECODER_ERROR: 
     104            if (error->data.reading.value == -1) { 
     105                length = snprintf(buffer, capacity, 
     106                        "%s: %s at position %d", 
     107                        prefixes[error->type], 
     108                        error->data.reading.problem, 
     109                        error->data.reading.offset); 
     110            } 
     111            else { 
     112                length = snprintf(buffer, capacity, 
     113                        "%s: %s (#%X) at position %d", 
     114                        prefixes[error->type], 
     115                        error->data.reading.problem, 
     116                        error->data.reading.value, 
     117                        error->data.reading.offset); 
     118            } 
     119            break; 
     120 
     121        case YAML_SCANNER_ERROR: 
     122        case YAML_PARSER_ERROR: 
     123        case YAML_COMPOSER_ERROR: 
     124            if (!error->data.loading.context) { 
     125                length = snprintf(buffer, capacity, 
     126                        "%s: %s at line %d, column %d", 
     127                        prefixes[error->type], 
     128                        error->data.loading.problem, 
     129                        error->data.loading.problem_mark.line+1, 
     130                        error->data.loading.problem_mark.column+1); 
     131            } 
     132            else { 
     133                length = snprintf(buffer, capacity, 
     134                        "%s: %s at line %d, column %d, %s at line %d, column %d", 
     135                        prefixes[error->type], 
     136                        error->data.loading.context, 
     137                        error->data.loading.context_mark.line+1, 
     138                        error->data.loading.context_mark.column+1, 
     139                        error->data.loading.problem, 
     140                        error->data.loading.problem_mark.line+1, 
     141                        error->data.loading.problem_mark.column+1); 
     142            } 
     143            break; 
     144 
     145        case YAML_WRITER_ERROR: 
     146            length = snprintf(buffer, capacity, 
     147                    "%s: %s at position %d", 
     148                    prefixes[error->type], 
     149                    error->data.writing.problem, 
     150                    error->data.writing.offset); 
     151            break; 
     152 
     153        case YAML_EMITTER_ERROR: 
     154        case YAML_SERIALIZER_ERROR: 
     155            length = snprintf(buffer, capacity, "%s: %s", 
     156                    prefixes[error->type], 
     157                    error->data.dumping.problem); 
     158            break; 
     159 
     160        case YAML_RESOLVER_ERROR: 
     161            length = snprintf(buffer, capacity, "%s: %s", 
     162                    prefixes[error->type], 
     163                    error->data.resolving.problem); 
     164            break; 
     165 
     166        default: 
     167            assert(0);  /* Should never happen. */ 
     168    } 
     169 
     170    return (length >= 0 && length < capacity); 
     171} 
     172 
     173 
     174/* 
    70175 * Extend a string. 
    71176 */ 
    72177 
    73178YAML_DECLARE(int) 
    74 yaml_string_extend(yaml_char_t **buffer, size_t *capacity) 
     179yaml_ostring_extend(yaml_char_t **buffer, size_t *capacity) 
    75180{ 
    76181    yaml_char_t *new_buffer = yaml_realloc(*buffer, (*capacity)*2); 
     
    91196 
    92197YAML_DECLARE(int) 
    93 yaml_string_join( 
     198yaml_ostring_join( 
    94199        yaml_char_t **base_buffer, size_t *base_pointer, size_t *base_capacity, 
    95         yaml_char_t *adj_buffer, size_t adj_pointer, size_t adj_capacity) 
     200        yaml_char_t *adj_buffer, size_t adj_pointer) 
    96201{ 
    97202    if (!adj_pointer) 
     
    99204 
    100205    while (*base_capacity - *base_pointer <= adj_pointer) { 
    101         if (!yaml_string_extend(base_buffer, base_capacity)) 
     206        if (!yaml_ostring_extend(base_buffer, base_capacity)) 
    102207            return 0; 
    103208    } 
     
    173278 
    174279    memset(parser, 0, sizeof(yaml_parser_t)); 
    175     if (!STRING_INIT(parser, parser->raw_input, RAW_INPUT_BUFFER_CAPACITY)) 
     280    if (!IOSTRING_INIT(parser, parser->raw_input, RAW_INPUT_BUFFER_CAPACITY)) 
    176281        goto error; 
    177     if (!STRING_INIT(parser, parser->input, INPUT_BUFFER_CAPACITY)) 
     282    if (!IOSTRING_INIT(parser, parser->input, INPUT_BUFFER_CAPACITY)) 
    178283        goto error; 
    179284    if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_CAPACITY)) 
     
    207312    assert(parser); /* Non-NULL parser object expected. */ 
    208313 
    209     STRING_DEL(parser, parser->raw_input); 
    210     STRING_DEL(parser, parser->input); 
     314    IOSTRING_DEL(parser, parser->raw_input); 
     315    IOSTRING_DEL(parser, parser->input); 
    211316    while (!QUEUE_EMPTY(parser, parser->tokens)) { 
    212317        yaml_token_destroy(&DEQUEUE(parser, parser->tokens)); 
     
    250355    yaml_standard_reader_data_t *data = untyped_data; 
    251356 
    252     if (data->string.pointer == data->string.capacity) { 
     357    if (data->string.pointer == data->string.length) { 
    253358        *length = 0; 
    254359        return 1; 
    255360    } 
    256361 
    257     if (capacity > (size_t)(data->string.capacity - data->string.pointer)) { 
    258         capacity = data->string.capacity - data->string.pointer; 
     362    if (capacity > (size_t)(data->string.length - data->string.pointer)) { 
     363        capacity = data->string.length - data->string.pointer; 
    259364    } 
    260365 
     
    294399    parser->reader_data = &(parser->standard_reader_data); 
    295400 
    296     parser->standard_reader_data.string.buffer = (unsigned char *)buffer; 
     401    parser->standard_reader_data.string.buffer = buffer; 
    297402    parser->standard_reader_data.string.pointer = 0; 
    298     parser->standard_reader_data.string.capacity = length; 
     403    parser->standard_reader_data.string.length = length; 
    299404} 
    300405 
     
    358463 
    359464    memset(emitter, 0, sizeof(yaml_emitter_t)); 
    360     if (!STRING_INIT(emitter, emitter->output, OUTPUT_BUFFER_CAPACITY)) 
     465    if (!IOSTRING_INIT(emitter, emitter->output, OUTPUT_BUFFER_CAPACITY)) 
    361466        goto error; 
    362     if (!STRING_INIT(emitter, emitter->raw_output, RAW_OUTPUT_BUFFER_CAPACITY)) 
     467    if (!IOSTRING_INIT(emitter, emitter->raw_output, RAW_OUTPUT_BUFFER_CAPACITY)) 
    363468        goto error; 
    364469    if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_CAPACITY)) 
     
    388493    assert(emitter);    /* Non-NULL emitter object expected. */ 
    389494 
    390     STRING_DEL(emitter, emitter->output); 
    391     STRING_DEL(emitter, emitter->raw_output); 
     495    IOSTRING_DEL(emitter, emitter->output); 
     496    IOSTRING_DEL(emitter, emitter->raw_output); 
    392497    STACK_DEL(emitter, emitter->states); 
    393498    while (!QUEUE_EMPTY(emitter, emitter->events)) { 
     
    425530 
    426531static int 
    427 yaml_string_writer(void *untyped_data, unsigned char *buffer, size_t length) 
     532yaml_string_writer(void *untyped_data, const unsigned char *buffer, size_t length) 
    428533{ 
    429534    yaml_standard_writer_data_t *data = untyped_data; 
     
    447552 
    448553static int 
    449 yaml_file_writer(void *untyped_data, unsigned char *buffer, size_t length) 
     554yaml_file_writer(void *untyped_data, const unsigned char *buffer, size_t length) 
    450555{ 
    451556    yaml_standard_writer_data_t *data = untyped_data; 
     
    617722 
    618723YAML_DECLARE(int) 
    619 yaml_token_duplicate(yaml_token_t *token, yaml_token_t *model) 
     724yaml_token_duplicate(yaml_token_t *token, const yaml_token_t *model) 
    620725{ 
    621726    assert(token);  /* Non-NULL token object is expected. */ 
     
    810915 
    811916YAML_DECLARE(int) 
    812 yaml_event_duplicate(yaml_event_t *event, yaml_event_t *model) 
     917yaml_event_duplicate(yaml_event_t *event, const yaml_event_t *model) 
    813918{ 
    814919    struct { 
  • libyaml/trunk/src/emitter.c

    r263 r264  
    1414 */ 
    1515 
    16 #define PUT(emitter,value)                                                      \ 
     16#define PUT(emitter, value)                                                     \ 
    1717    (FLUSH(emitter)                                                             \ 
    18      && (JOIN_OCTET(emitter->output,(yaml_char_t)(value)),                      \ 
     18     && (JOIN_OCTET(emitter->output, (yaml_char_t)(value)),                     \ 
    1919         emitter->column ++,                                                    \ 
    2020         1)) 
     
    4141 */ 
    4242 
    43 #define WRITE(emitter,string)                                                   \ 
     43#define WRITE(emitter, string)                                                  \ 
    4444    (FLUSH(emitter)                                                             \ 
    45      && (COPY(emitter->output,string),                                          \ 
     45     && (COPY(emitter->output, string),                                         \ 
    4646         emitter->column ++,                                                    \ 
    4747         1)) 
     
    5151 */ 
    5252 
    53 #define WRITE_BREAK(emitter,string)                                             \ 
     53#define WRITE_BREAK(emitter, string)                                            \ 
    5454    (FLUSH(emitter)                                                             \ 
    55      && (CHECK(string,'\n') ?                                                   \ 
     55     && (CHECK(string, '\n') ?                                                  \ 
    5656         (PUT_BREAK(emitter),                                                   \ 
    5757          string.pointer ++,                                                    \ 
    5858          1) :                                                                  \ 
    59          (COPY(emitter->output,string),                                         \ 
     59         (COPY(emitter->output, string),                                        \ 
    6060          emitter->column = 0,                                                  \ 
    6161          emitter->line ++,                                                     \ 
     
    6767 
    6868YAML_DECLARE(int) 
    69 yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event); 
     69yaml_emitter_emit_event(yaml_emitter_t *emitter, yaml_event_t *event); 
    7070 
    7171/* 
     
    219219static int 
    220220yaml_emitter_write_indicator(yaml_emitter_t *emitter, 
    221         char *indicator, int need_whitespace, 
     221        const char *indicator, int need_whitespace, 
    222222        int is_whitespace, int is_indention); 
    223223 
    224224static int 
    225225yaml_emitter_write_anchor(yaml_emitter_t *emitter, 
    226         yaml_char_t *value, size_t length); 
     226        const yaml_char_t *value, size_t length); 
    227227 
    228228static int 
    229229yaml_emitter_write_tag_handle(yaml_emitter_t *emitter, 
    230         yaml_char_t *value, size_t length); 
     230        const yaml_char_t *value, size_t length); 
    231231 
    232232static int 
    233233yaml_emitter_write_tag_content(yaml_emitter_t *emitter, 
    234         yaml_char_t *value, size_t length, int need_whitespace); 
     234        const yaml_char_t *value, size_t length, int need_whitespace); 
    235235 
    236236static int 
    237237yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter, 
    238         yaml_char_t *value, size_t length, int allow_breaks); 
     238        const yaml_char_t *value, size_t length, int allow_breaks); 
    239239 
    240240static int 
    241241yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter, 
    242         yaml_char_t *value, size_t length, int allow_breaks); 
     242        const yaml_char_t *value, size_t length, int allow_breaks); 
    243243 
    244244static int 
    245245yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter, 
    246         yaml_char_t *value, size_t length, int allow_breaks); 
     246        const yaml_char_t *value, size_t length, int allow_breaks); 
    247247 
    248248static int 
    249249yaml_emitter_determine_chomping(yaml_emitter_t *emitter, 
    250         yaml_string_t string); 
     250        yaml_istring_t string); 
    251251 
    252252static int 
    253253yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter, 
    254         yaml_char_t *value, size_t length); 
     254        const yaml_char_t *value, size_t length); 
    255255 
    256256static int 
    257257yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter, 
    258         yaml_char_t *value, size_t length); 
     258        const yaml_char_t *value, size_t length); 
    259259 
    260260/* 
     
    263263 
    264264YAML_DECLARE(int) 
    265 yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event) 
     265yaml_emitter_emit_event(yaml_emitter_t *emitter, yaml_event_t *event) 
    266266{ 
    267267    if (!ENQUEUE(emitter, emitter->events, *event)) { 
     
    468468 
    469469        default: 
    470             assert(1);      /* Invalid state. */ 
     470            assert(0);      /* Invalid state. */ 
    471471    } 
    472472 
     
    12871287 
    12881288        default: 
    1289             assert(1);      /* Impossible. */ 
     1289            assert(0);      /* Impossible. */ 
    12901290    } 
    12911291 
     
    13161316        yaml_tag_directive_t tag_directive) 
    13171317{ 
    1318     yaml_string_t handle = STRING(tag_directive.handle, 
     1318    yaml_istring_t handle = ISTRING(tag_directive.handle, 
    13191319            strlen((char *)tag_directive.handle)); 
    1320     yaml_string_t prefix = STRING(tag_directive.prefix, 
     1320    yaml_istring_t prefix = ISTRING(tag_directive.prefix, 
    13211321            strlen((char *)tag_directive.prefix)); 
    13221322 
    1323     if (!handle.capacity) { 
     1323    if (!handle.length) { 
    13241324        return EMITTER_ERROR_INIT(emitter, "tag handle must not be empty"); 
    13251325    } 
     
    13291329    } 
    13301330 
    1331     if (handle.buffer[handle.capacity-1] != '!') { 
     1331    if (handle.buffer[handle.length-1] != '!') { 
    13321332        return EMITTER_ERROR_INIT(emitter, "tag handle must end with '!'"); 
    13331333    } 
     
    13351335    handle.pointer ++; 
    13361336 
    1337     while (handle.pointer < handle.capacity-1) { 
     1337    while (handle.pointer < handle.length-1) { 
    13381338        if (!IS_ALPHA(handle)) { 
    13391339            return EMITTER_ERROR_INIT(emitter, 
     
    13431343    } 
    13441344 
    1345     if (!prefix.capacity) { 
     1345    if (!prefix.length) { 
    13461346        return EMITTER_ERROR_INIT(emitter, "tag prefix must not be empty"); 
    13471347    } 
     
    13581358        yaml_char_t *anchor, int is_alias) 
    13591359{ 
    1360     yaml_string_t string = STRING(anchor, strlen((char *)anchor)); 
    1361  
    1362     if (!string.capacity) { 
     1360    yaml_istring_t string = ISTRING(anchor, strlen((char *)anchor)); 
     1361 
     1362    if (!string.length) { 
    13631363        return EMITTER_ERROR_INIT(emitter, is_alias ? 
    13641364                "alias value must not be empty" : 
     
    13661366    } 
    13671367 
    1368     while (string.pointer < string.capacity) { 
     1368    while (string.pointer < string.length) { 
    13691369        if (!IS_ALPHA(string)) { 
    13701370            return EMITTER_ERROR_INIT(emitter, is_alias ? 
     
    13761376 
    13771377    emitter->anchor_data.anchor = string.buffer; 
    1378     emitter->anchor_data.anchor_length = string.capacity; 
     1378    emitter->anchor_data.anchor_length = string.length; 
    13791379    emitter->anchor_data.is_alias = is_alias; 
    13801380 
     
    13901390        yaml_char_t *tag) 
    13911391{ 
    1392     yaml_string_t string = STRING(tag, strlen((char *)tag)); 
     1392    yaml_istring_t string = ISTRING(tag, strlen((char *)tag)); 
    13931393    size_t idx; 
    13941394 
    1395     if (!string.capacity) { 
     1395    if (!string.length) { 
    13961396        return EMITTER_ERROR_INIT(emitter, "tag value must not be empty"); 
    13971397    } 
    13981398 
    13991399    for (idx = 0; idx < emitter->tag_directives.length; idx ++) { 
    1400         yaml_tag_directive_t *tag_directive = emitter->tag_directives.list+idx; 
     1400        yaml_tag_directive_t *tag_directive = 
     1401            STACK_ITER(emitter, emitter->tag_directives, idx); 
    14011402        size_t prefix_length = strlen((char *)tag_directive->prefix); 
    1402         if (prefix_length < string.capacity 
     1403        if (prefix_length < string.length 
    14031404                && strncmp((char *)tag_directive->prefix, (char *)string.buffer, 
    14041405                    prefix_length) == 0) 
     
    14081409                strlen((char *)tag_directive->handle); 
    14091410            emitter->tag_data.suffix = string.buffer + prefix_length; 
    1410             emitter->tag_data.suffix_length = string.capacity - prefix_length; 
     1411            emitter->tag_data.suffix_length = string.length - prefix_length; 
    14111412            return 1; 
    14121413        } 
     
    14141415 
    14151416    emitter->tag_data.suffix = string.buffer; 
    1416     emitter->tag_data.suffix_length = string.capacity; 
     1417    emitter->tag_data.suffix_length = string.length; 
    14171418 
    14181419    return 1; 
     
    14271428        yaml_char_t *value, size_t length) 
    14281429{ 
    1429     yaml_string_t string = STRING(value, length); 
     1430    yaml_istring_t string = ISTRING(value, length); 
    14301431 
    14311432    int block_indicators = 0; 
     
    14531454    emitter->scalar_data.length = length; 
    14541455 
    1455     if (!string.capacity) 
     1456    if (!string.length) 
    14561457    { 
    14571458        emitter->scalar_data.is_multiline = 0; 
     
    14771478    followed_by_space = IS_BLANKZ_AT(string, WIDTH(string)); 
    14781479 
    1479     while (string.pointer < string.capacity) 
     1480    while (string.pointer < string.length) 
    14801481    { 
    14811482        if (!string.pointer) 
     
    15841585        } 
    15851586 
    1586         if ((spaces || breaks) && string.pointer == string.capacity-1) 
     1587        if ((spaces || breaks) && string.pointer == string.length-1) 
    15871588        { 
    15881589            if (spaces && breaks) { 
     
    16051606        preceeded_by_space = IS_BLANKZ(string); 
    16061607        MOVE(string); 
    1607         if (string.pointer < string.capacity) { 
     1608        if (string.pointer < string.length) { 
    16081609            followed_by_space = IS_BLANKZ_AT(string, WIDTH(string)); 
    16091610        } 
     
    17701771static int 
    17711772yaml_emitter_write_indicator(yaml_emitter_t *emitter, 
    1772         char *indicator, int need_whitespace, 
     1773        const char *indicator, int need_whitespace, 
    17731774        int is_whitespace, int is_indention) 
    17741775{ 
    1775     yaml_string_t string = STRING((yaml_char_t *)indicator, strlen(indicator)); 
     1776    yaml_istring_t string = ISTRING((yaml_char_t *)indicator, strlen(indicator)); 
    17761777 
    17771778    if (need_whitespace && !emitter->is_whitespace) { 
     
    17791780    } 
    17801781 
    1781     while (string.pointer < string.capacity) { 
     1782    while (string.pointer < string.length) { 
    17821783        if (!WRITE(emitter, string)) return 0; 
    17831784    } 
     
    17911792static int 
    17921793yaml_emitter_write_anchor(yaml_emitter_t *emitter, 
    1793         yaml_char_t *value, size_t length) 
    1794 { 
    1795     yaml_string_t string = STRING(value, length); 
    1796  
    1797     while (string.pointer < string.capacity) { 
     1794        const yaml_char_t *value, size_t length) 
     1795{ 
     1796    yaml_istring_t string = ISTRING(value, length); 
     1797 
     1798    while (string.pointer < string.length) { 
    17981799        if (!WRITE(emitter, string)) return 0; 
    17991800    } 
     
    18071808static int 
    18081809yaml_emitter_write_tag_handle(yaml_emitter_t *emitter, 
    1809         yaml_char_t *value, size_t length) 
    1810 { 
    1811     yaml_string_t string = STRING(value, length); 
     1810        const yaml_char_t *value, size_t length) 
     1811{ 
     1812    yaml_istring_t string = ISTRING(value, length); 
    18121813 
    18131814    if (!emitter->is_whitespace) { 
     
    18151816    } 
    18161817 
    1817     while (string.pointer < string.capacity) { 
     1818    while (string.pointer < string.length) { 
    18181819        if (!WRITE(emitter, string)) return 0; 
    18191820    } 
     
    18271828static int 
    18281829yaml_emitter_write_tag_content(yaml_emitter_t *emitter, 
    1829         yaml_char_t *value, size_t length, 
     1830        const yaml_char_t *value, size_t length, 
    18301831        int need_whitespace) 
    18311832{ 
    1832     yaml_string_t string = STRING(value, length); 
     1833    yaml_istring_t string = ISTRING(value, length); 
    18331834 
    18341835    if (need_whitespace && !emitter->is_whitespace) { 
     
    18361837    } 
    18371838 
    1838     while (string.pointer < string.capacity) { 
     1839    while (string.pointer < string.length) { 
    18391840        if (IS_ALPHA(string) 
    18401841                || CHECK(string, ';') || CHECK(string, '/') 
     
    18751876static int 
    18761877yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter, 
    1877         yaml_char_t *value, size_t length, int allow_breaks) 
    1878 { 
    1879     yaml_string_t string = STRING(value, length); 
     1878        const yaml_char_t *value, size_t length, int allow_breaks) 
     1879{ 
     1880    yaml_istring_t string = ISTRING(value, length); 
    18801881    int spaces = 0; 
    18811882    int breaks = 0; 
     
    18851886    } 
    18861887 
    1887     while (string.pointer < string.capacity) 
     1888    while (string.pointer < string.length) 
    18881889    { 
    18891890        if (IS_SPACE(string)) 
     
    19291930static int 
    19301931yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter, 
    1931         yaml_char_t *value, size_t length, int allow_breaks) 
    1932 { 
    1933     yaml_string_t string = STRING(value, length); 
     1932        const yaml_char_t *value, size_t length, int allow_breaks) 
     1933{ 
     1934    yaml_istring_t string = ISTRING(value, length); 
    19341935    int spaces = 0; 
    19351936    int breaks = 0; 
     
    19381939        return 0; 
    19391940 
    1940     while (string.pointer < string.capacity) 
     1941    while (string.pointer < string.length) 
    19411942    { 
    19421943        if (IS_SPACE(string)) 
     
    19441945            if (allow_breaks && !spaces 
    19451946                    && emitter->column > emitter->best_width 
    1946                     && string.pointer != 0 
    1947                     && string.pointer != string.capacity - 1 
     1947                    && string.pointer > 0 && string.pointer < string.length 
    19481948                    && !IS_SPACE_AT(string, 1)) { 
    19491949                if (!yaml_emitter_write_indent(emitter)) return 0; 
     
    19901990static int 
    19911991yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter, 
    1992         yaml_char_t *value, size_t length, int allow_breaks) 
    1993 { 
    1994     yaml_string_t string = STRING(value, length); 
     1992        const yaml_char_t *value, size_t length, int allow_breaks) 
     1993{ 
     1994    yaml_istring_t string = ISTRING(value, length); 
    19951995    int spaces = 0; 
    19961996 
     
    19981998        return 0; 
    19991999 
    2000     while (string.pointer < string.capacity) 
     2000    while (string.pointer < string.length) 
    20012001    { 
    20022002        if (!IS_PRINTABLE(string) || (!emitter->is_unicode && !IS_ASCII(string)) 
     
    21132113            if (allow_breaks && !spaces 
    21142114                    && emitter->column > emitter->best_width 
    2115                     && string.pointer != 0 
    2116                     && string.pointer != string.capacity - 1) { 
     2115                    && string.pointer > 0 
     2116                    && string.pointer < string.length) { 
    21172117                if (!yaml_emitter_write_indent(emitter)) return 0; 
    21182118                if (IS_SPACE_AT(string, 1)) { 
     
    21442144static int 
    21452145yaml_emitter_determine_chomping(yaml_emitter_t *emitter, 
    2146         yaml_string_t string) 
    2147 { 
    2148     string.pointer = string.capacity; 
     2146        yaml_istring_t string) 
     2147{ 
     2148    string.pointer = string.length; 
    21492149    if (!string.pointer) 
    21502150        return -1; 
     
    21672167static int 
    21682168yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter, 
    2169         yaml_char_t *value, size_t length) 
    2170 { 
    2171     yaml_string_t string = STRING(value, length); 
     2169        const yaml_char_t *value, size_t length) 
     2170{ 
     2171    yaml_istring_t string = ISTRING(value, length); 
    21722172    int chomp = yaml_emitter_determine_chomping(emitter, string); 
    21732173    int breaks = 0; 
     
    21792179        return 0; 
    21802180 
    2181     while (string.pointer < string.capacity) 
     2181    while (string.pointer < string.length) 
    21822182    { 
    21832183        if (IS_BREAK(string)) 
     
    22032203static int 
    22042204yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter, 
    2205         yaml_char_t *value, size_t length) 
    2206 { 
    2207     yaml_string_t string = STRING(value, length); 
     2205        const yaml_char_t *value, size_t length) 
     2206{ 
     2207    yaml_istring_t string = ISTRING(value, length); 
    22082208    int chomp = yaml_emitter_determine_chomping(emitter, string); 
    22092209    int breaks = 1; 
     
    22162216        return 0; 
    22172217 
    2218     while (string.pointer < string.capacity) 
     2218    while (string.pointer < string.length) 
    22192219    { 
    22202220        if (IS_BREAK(string)) 
  • libyaml/trunk/src/parser.c

    r263 r264  
    4848#define PEEK_TOKEN(parser)                                                      \ 
    4949    ((parser->is_token_available || yaml_parser_fetch_more_tokens(parser)) ?    \ 
    50         parser->tokens.list + parser->tokens.head : NULL) 
     50        QUEUE_ITER(parser, parser->tokens, 0) : NULL) 
    5151 
    5252/* 
     
    5858     parser->tokens_parsed ++,                                                  \ 
    5959     parser->is_stream_end_produced =                                           \ 
    60         (parser->tokens.list[parser->tokens.head].type == YAML_STREAM_END_TOKEN),  \ 
     60        (QUEUE_ITER(parser, parser->tokens, 0)->type == YAML_STREAM_END_TOKEN), \ 
    6161     parser->tokens.head ++) 
    6262 
     
    6666 
    6767YAML_DECLARE(int) 
    68 yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event); 
     68yaml_parser_parse_event(yaml_parser_t *parser, yaml_event_t *event); 
    6969 
    7070/* 
     
    156156 
    157157YAML_DECLARE(int) 
    158 yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event) 
     158yaml_parser_parse_event(yaml_parser_t *parser, yaml_event_t *event) 
    159159{ 
    160160    assert(parser);     /* Non-NULL parser object is expected. */ 
     
    256256 
    257257        default: 
    258             assert(1);      /* Invalid state. */ 
     258            assert(0);      /* Invalid state. */ 
    259259    } 
    260260 
     
    563563                int idx; 
    564564                for (idx = 0; idx < parser->tag_directives.length; idx++) { 
    565                     yaml_tag_directive_t *tag_directive = parser->tag_directives.list + idx; 
     565                    yaml_tag_directive_t *tag_directive = 
     566                        STACK_ITER(parser, parser->tag_directives, idx); 
    566567                    if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) { 
    567568                        size_t prefix_len = strlen((char *)tag_directive->prefix); 
     
    13111312 
    13121313    for (idx = 0; idx < parser->tag_directives.length; idx++) { 
    1313         yaml_tag_directive_t *tag_directive = parser->tag_directives.list + idx; 
     1314        yaml_tag_directive_t *tag_directive = 
     1315            STACK_ITER(parser, parser->tag_directives, idx); 
    13141316        if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) { 
    13151317            if (allow_duplicates) 
  • libyaml/trunk/src/reader.c

    r263 r264  
    3636    /* Ensure that we had enough bytes in the raw buffer. */ 
    3737 
    38     while (!parser->is_eof && parser->raw_input.capacity < 3) { 
     38    while (!parser->is_eof && parser->raw_input.length < 3) { 
    3939        if (!yaml_parser_update_raw_buffer(parser)) { 
    4040            return 0; 
     
    4444    /* Determine the encoding. */ 
    4545 
    46     if (parser->raw_input.capacity >= 2 
     46    if (parser->raw_input.length >= 2 
    4747            && !memcmp(parser->raw_input.buffer, BOM_UTF16LE, 2)) { 
    4848        parser->encoding = YAML_UTF16LE_ENCODING; 
     
    5050        parser->offset = 2; 
    5151    } 
    52     else if (parser->raw_input.capacity >= 2 
     52    else if (parser->raw_input.length >= 2 
    5353            && !memcmp(parser->raw_input.buffer, BOM_UTF16BE, 2)) { 
    5454        parser->encoding = YAML_UTF16BE_ENCODING; 
     
    5656        parser->offset = 2; 
    5757    } 
    58     else if (parser->raw_input.capacity >= 3 
     58    else if (parser->raw_input.length >= 3 
    5959            && !memcmp(parser->raw_input.buffer, BOM_UTF8, 3)) { 
    6060        parser->encoding = YAML_UTF8_ENCODING; 
     
    8181 
    8282    if (parser->raw_input.pointer == 0 && 
    83             parser->raw_input.capacity == RAW_INPUT_BUFFER_CAPACITY) 
     83            parser->raw_input.length == parser->raw_input.capacity) 
    8484        return 1; 
    8585 
     
    9292 
    9393    if (parser->raw_input.pointer > 0 && 
    94             parser->raw_input.pointer < parser->raw_input.capacity) { 
     94            parser->raw_input.pointer < parser->raw_input.length) { 
    9595        memmove(parser->raw_input.buffer, 
    9696                parser->raw_input.buffer + parser->raw_input.pointer, 
    97                 parser->raw_input.capacity - parser->raw_input.pointer); 
    98     } 
    99     parser->raw_input.capacity -= parser->raw_input.pointer; 
     97                parser->raw_input.length - parser->raw_input.pointer); 
     98    } 
     99    parser->raw_input.length -= parser->raw_input.pointer; 
    100100    parser->raw_input.pointer = 0; 
    101101 
     
    103103 
    104104    if (!parser->reader(parser->reader_data, 
    105                 parser->raw_input.buffer + parser->raw_input.capacity, 
    106                 RAW_INPUT_BUFFER_CAPACITY - parser->raw_input.capacity, 
     105                parser->raw_input.buffer + parser->raw_input.length, 
     106                parser->raw_input.capacity - parser->raw_input.length, 
    107107                &length)) { 
    108         return READER_ERROR_INIT(parser, "Input error", parser->offset); 
    109     } 
    110     parser->raw_input.capacity += length; 
     108        return READER_ERROR_INIT(parser, "read handler error", parser->offset); 
     109    } 
     110    parser->raw_input.length += length; 
    111111    if (!length) { 
    112112        parser->is_eof = 1; 
     
    126126yaml_parser_update_buffer(yaml_parser_t *parser, size_t length) 
    127127{ 
    128     size_t old_capacity; 
    129  
    130128    assert(parser->reader); /* Read handler must be set. */ 
    131129 
    132130    /* If the EOF flag is set and the raw buffer is empty, do nothing. */ 
    133131 
    134     if (parser->is_eof && parser->raw_input.pointer == parser->raw_input.capacity) 
     132    if (parser->is_eof && parser->raw_input.pointer == parser->raw_input.length) 
    135133        return 1; 
    136134 
     
    150148 
    151149    if (parser->input.pointer > 0 && 
    152             parser->input.pointer < parser->input.capacity) { 
     150            parser->input.pointer < parser->input.length) { 
    153151        memmove(parser->input.buffer, 
    154152                parser->input.buffer + parser->input.pointer, 
    155                 parser->input.capacity - parser->input.pointer); 
    156         parser->input.capacity -= parser->input.pointer; 
    157     } 
    158     else if (parser->input.pointer == parser->input.capacity) { 
    159         parser->input.capacity = 0; 
    160     } 
    161  
    162     /* Set the pointer to the end of the buffer. */ 
    163  
    164     parser->input.pointer = parser->input.capacity; 
     153                parser->input.length - parser->input.pointer); 
     154        parser->input.length -= parser->input.pointer; 
     155    } 
     156    else if (parser->input.pointer == parser->input.length) { 
     157        parser->input.length = 0; 
     158    } 
     159 
     160    /* Switch the buffer to the output mode. */ 
     161 
     162    parser->input.pointer = parser->input.length; 
    165163 
    166164    /* Fill the buffer until it has enough characters. */ 
     
    174172        /* Decode the raw buffer. */ 
    175173 
    176         while (parser->raw_input.pointer != parser->raw_input.capacity) 
     174        while (parser->raw_input.pointer < parser->raw_input.length) 
    177175        { 
    178176            size_t raw_unread = 
    179                 parser->raw_input.capacity - parser->raw_input.pointer; 
     177                parser->raw_input.length - parser->raw_input.pointer; 
    180178            unsigned int value = 0, value2 = 0; 
    181179            int is_incomplete = 0; 
     
    223221                    if (!width) 
    224222                        return DECODER_ERROR_INIT(parser, 
    225                                 "Invalid leading UTF-8 octet", 
     223                                "invalid leading UTF-8 octet", 
    226224                                parser->offset, octet); 
    227225 
     
    231229                        if (parser->is_eof) { 
    232230                            return DECODER_ERROR_INIT(parser, 
    233                                     "Incomplete UTF-8 octet sequence", 
     231                                    "incomplete UTF-8 octet sequence", 
    234232                                    parser->offset, -1); 
    235233                        } 
     
    255253                        if ((octet & 0xC0) != 0x80) 
    256254                            return DECODER_ERROR_INIT(parser, 
    257                                     "Invalid trailing UTF-8 octet", 
     255                                    "invalid trailing UTF-8 octet", 
    258256                                    parser->offset+idx, octet); 
    259257 
     
    270268                            (width == 4 && value >= 0x10000))) 
    271269                        return DECODER_ERROR_INIT(parser, 
    272                                 "Invalid length of a UTF-8 sequence", 
     270                                "invalid length of a UTF-8 sequence", 
    273271                                parser->offset, -1); 
    274272 
     
    277275                    if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) 
    278276                        return DECODER_ERROR_INIT(parser, 
    279                                 "Invalid Unicode character", 
     277                                "invalid Unicode character", 
    280278                                parser->offset, value); 
    281279 
     
    319317                        if (parser->is_eof) { 
    320318                            return DECODER_ERROR_INIT(parser, 
    321                                     "Incomplete UTF-16 character", 
     319                                    "incomplete UTF-16 character", 
    322320                                    parser->offset, -1); 
    323321                        } 
     
    335333                    if ((value & 0xFC00) == 0xDC00) 
    336334                        return DECODER_ERROR_INIT(parser, 
    337                                 "Unexpected low surrogate area", 
     335                                "unexpected low surrogate area", 
    338336                                parser->offset, value); 
    339337 
     
    349347                            if (parser->is_eof) { 
    350348                                return DECODER_ERROR_INIT(parser, 
    351                                         "Incomplete UTF-16 surrogate pair", 
     349                                        "incomplete UTF-16 surrogate pair", 
    352350                                        parser->offset, -1); 
    353351                            } 
     
    365363                        if ((value2 & 0xFC00) != 0xDC00) 
    366364                            return DECODER_ERROR_INIT(parser, 
    367                                     "Expected low surrogate area", 
     365                                    "expected low surrogate area", 
    368366                                    parser->offset+2, value2); 
    369367 
     
    380378 
    381379                default: 
    382                     assert(1);      /* Impossible. */ 
     380                    assert(0);      /* Impossible. */ 
    383381            } 
    384382 
     
    401399                        || (value >= 0x10000 && value <= 0x10FFFF))) 
    402400                return DECODER_ERROR_INIT(parser, 
    403                         "Control characters are not allowed", 
     401                        "control characters are not allowed", 
    404402                        parser->offset, value); 
    405403 
     
    446444 
    447445    } 
    448     /* Swap the pointer with the end of the buffer. */ 
    449  
    450     old_capacity = parser->input.capacity; 
    451     parser->input.capacity = parser->input.pointer; 
    452     parser->input.pointer = old_capacity; 
     446 
     447    /* Switch the the buffer back to the input mode. */ 
     448 
     449    parser->input.length = parser->input.pointer; 
     450    parser->input.pointer = 0; 
    453451 
    454452    return 1; 
  • libyaml/trunk/src/scanner.c

    r263 r264  
    516516 */ 
    517517 
    518 #define READ(parser,string)                                                     \ 
    519      (STRING_EXTEND(parser,string) ?                                            \ 
    520          (COPY(string,parser->input),                                           \ 
     518#define READ(parser, string)                                                    \ 
     519     (OSTRING_EXTEND(parser, string) ?                                          \ 
     520         (COPY(string, parser->input),                                          \ 
    521521          parser->mark.index ++,                                                \ 
    522522          parser->mark.column ++,                                               \ 
     
    528528 */ 
    529529 
    530 #define READ_LINE(parser,string)                                                \ 
    531     (STRING_EXTEND(parser,string) ?                                             \ 
    532     (((CHECK_AT(parser->input,'\r',0)                                           \ 
    533        && CHECK_AT(parser->input,'\n',1)) ?         /* CR LF -> LF */           \ 
     530#define READ_LINE(parser, string)                                               \ 
     531    (OSTRING_EXTEND(parser, string) ?                                           \ 
     532    (((CHECK_AT(parser->input, '\r', 0)                                         \ 
     533       && CHECK_AT(parser->input, '\n', 1)) ?       /* CR LF -> LF */           \ 
    534534     (JOIN_OCTET(string, (yaml_char_t) '\n'),                                   \ 
    535535      parser->input.pointer += 2,                                               \ 
     
    538538      parser->mark.line ++,                                                     \ 
    539539      parser->unread -= 2) :                                                    \ 
    540      (CHECK_AT(parser->input,'\r',0)                                            \ 
    541       || CHECK_AT(parser->input,'\n',0)) ?          /* CR|LF -> LF */           \ 
    542      (JOIN_OCTET(string,(yaml_char_t) '\n'),                                    \ 
     540     (CHECK_AT(parser->input, '\r', 0)                                          \ 
     541      || CHECK_AT(parser->input, '\n', 0)) ?        /* CR|LF -> LF */           \ 
     542     (JOIN_OCTET(string, (yaml_char_t) '\n'),                                   \ 
    543543      parser->input.pointer ++,                                                 \ 
    544544      parser->mark.index ++,                                                    \ 
     
    546546      parser->mark.line ++,                                                     \ 
    547547      parser->unread --) :                                                      \ 
    548      (CHECK_AT(parser->input,'\xC2',0)                                          \ 
    549       && CHECK_AT(parser->input,'\x85',1)) ?        /* NEL -> LF */             \ 
    550      (JOIN_OCTET(string,(yaml_char_t) '\n'),                                    \ 
     548     (CHECK_AT(parser->input, '\xC2', 0)                                        \ 
     549      && CHECK_AT(parser->input, '\x85', 1)) ?      /* NEL -> LF */             \ 
     550     (JOIN_OCTET(string, (yaml_char_t) '\n'),                                   \ 
    551551      parser->input.pointer += 2,                                               \ 
    552552      parser->mark.index ++,                                                    \ 
     
    554554      parser->mark.line ++,                                                     \ 
    555555      parser->unread --) :                                                      \ 
    556      (CHECK_AT(parser->input,'\xE2',0) &&                                       \ 
    557       CHECK_AT(parser->input,'\x80',1) &&                                       \ 
    558       (CHECK_AT(parser->input,'\xA8',2) ||                                      \ 
    559        CHECK_AT(parser->input,'\xA9',2))) ?         /* LS|PS -> LS|PS */        \ 
    560      (COPY_OCTET(string,parser->input),                                         \ 
    561       COPY_OCTET(string,parser->input),                                         \ 
    562       COPY_OCTET(string,parser->input),                                         \ 
     556     (CHECK_AT(parser->input, '\xE2', 0) &&                                     \ 
     557      CHECK_AT(parser->input, '\x80', 1) &&                                     \ 
     558      (CHECK_AT(parser->input, '\xA8', 2) ||                                    \ 
     559       CHECK_AT(parser->input, '\xA9', 2))) ?       /* LS|PS -> LS|PS */        \ 
     560     (COPY_OCTET(string, parser->input),                                        \ 
     561      COPY_OCTET(string, parser->input),                                        \ 
     562      COPY_OCTET(string, parser->input),                                        \ 
    563563      parser->mark.index ++,                                                    \ 
    564564      parser->mark.column = 0,                                                  \ 
     
    572572 
    573573YAML_DECLARE(int) 
    574 yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token); 
     574yaml_parser_parse_token(yaml_parser_t *parser, yaml_token_t *token); 
    575575 
    576576/* 
     
    709709static int 
    710710yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive, 
    711         yaml_mark_t start_mark, yaml_string_t *string); 
     711        yaml_mark_t start_mark, yaml_ostring_t *string); 
    712712 
    713713static int 
     
    717717static int 
    718718yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser, 
    719         int *indent, yaml_string_t *breaks, 
     719        int *indent, yaml_ostring_t *breaks, 
    720720        yaml_mark_t start_mark, yaml_mark_t *end_mark); 
    721721 
     
    732732 
    733733YAML_DECLARE(int) 
    734 yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token) 
     734yaml_parser_parse_token(yaml_parser_t *parser, yaml_token_t *token) 
    735735{ 
    736736    assert(parser); /* Non-NULL parser object is expected. */ 
     
    20932093        yaml_mark_t start_mark, yaml_char_t **name) 
    20942094{ 
    2095     yaml_string_t string = NULL_STRING; 
    2096  
    2097     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2095    yaml_ostring_t string = NULL_OSTRING; 
     2096 
     2097    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    20982098        goto error; 
    20992099 
     
    21312131 
    21322132error: 
    2133     STRING_DEL(parser, string); 
     2133    OSTRING_DEL(parser, string); 
    21342134    return 0; 
    21352135} 
     
    23122312    int length = 0; 
    23132313    yaml_mark_t start_mark, end_mark; 
    2314     yaml_string_t string = NULL_STRING; 
    2315  
    2316     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2314    yaml_ostring_t string = NULL_OSTRING; 
     2315 
     2316    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    23172317        goto error; 
    23182318 
     
    23672367 
    23682368error: 
    2369     STRING_DEL(parser, string); 
     2369    OSTRING_DEL(parser, string); 
    23702370    return 0; 
    23712371} 
     
    24962496        yaml_mark_t start_mark, yaml_char_t **handle) 
    24972497{ 
    2498     yaml_string_t string = NULL_STRING; 
    2499  
    2500     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2498    yaml_ostring_t string = NULL_OSTRING; 
     2499 
     2500    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    25012501        goto error; 
    25022502 
     
    25542554 
    25552555error: 
    2556     STRING_DEL(parser, string); 
     2556    OSTRING_DEL(parser, string); 
    25572557    return 0; 
    25582558} 
     
    25672567{ 
    25682568    size_t length = head ? strlen((char *)head) : 0; 
    2569     yaml_string_t string = NULL_STRING; 
    2570  
    2571     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2569    yaml_ostring_t string = NULL_OSTRING; 
     2570 
     2571    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    25722572        goto error; 
    25732573 
     
    25752575 
    25762576    while (string.capacity <= length) { 
    2577         if (!yaml_string_extend(&string.buffer, &string.capacity)) { 
     2577        if (!yaml_ostring_extend(&string.buffer, &string.capacity)) { 
    25782578            MEMORY_ERROR_INIT(parser); 
    25792579            goto error; 
     
    26332633 
    26342634    if (!length) { 
    2635         if (!STRING_EXTEND(parser, string)) 
     2635        if (!OSTRING_EXTEND(parser, string)) 
    26362636            goto error; 
    26372637 
     
    26472647 
    26482648error: 
    2649     STRING_DEL(parser, string); 
     2649    OSTRING_DEL(parser, string); 
    26502650    return 0; 
    26512651} 
     
    26572657static int 
    26582658yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive, 
    2659         yaml_mark_t start_mark, yaml_string_t *string) 
     2659        yaml_mark_t start_mark, yaml_ostring_t *string) 
    26602660{ 
    26612661    int width = 0; 
     
    27312731    yaml_mark_t start_mark; 
    27322732    yaml_mark_t end_mark; 
    2733     yaml_string_t string = NULL_STRING; 
    2734     yaml_string_t leading_break = NULL_STRING; 
    2735     yaml_string_t trailing_breaks = NULL_STRING; 
     2733    yaml_ostring_t string = NULL_OSTRING; 
     2734    yaml_ostring_t leading_break = NULL_OSTRING; 
     2735    yaml_ostring_t trailing_breaks = NULL_OSTRING; 
    27362736    int chomping = 0; 
    27372737    int increment = 0; 
     
    27402740    int trailing_blank = 0; 
    27412741 
    2742     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2742    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    27432743        goto error; 
    2744     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
     2744    if (!OSTRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
    27452745        goto error; 
    2746     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
     2746    if (!OSTRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
    27472747        goto error; 
    27482748 
     
    28812881 
    28822882            if (*trailing_breaks.buffer == '\0') { 
    2883                 if (!STRING_EXTEND(parser, string)) goto error; 
     2883                if (!OSTRING_EXTEND(parser, string)) goto error; 
    28842884                JOIN_OCTET(string, ' '); 
    28852885            } 
     
    29352935            start_mark, end_mark); 
    29362936 
    2937     STRING_DEL(parser, leading_break); 
    2938     STRING_DEL(parser, trailing_breaks); 
     2937    OSTRING_DEL(parser, leading_break); 
     2938    OSTRING_DEL(parser, trailing_breaks); 
    29392939 
    29402940    return 1; 
    29412941 
    29422942error: 
    2943     STRING_DEL(parser, string); 
    2944     STRING_DEL(parser, leading_break); 
    2945     STRING_DEL(parser, trailing_breaks); 
     2943    OSTRING_DEL(parser, string); 
     2944    OSTRING_DEL(parser, leading_break); 
     2945    OSTRING_DEL(parser, trailing_breaks); 
    29462946 
    29472947    return 0; 
     
    29552955static int 
    29562956yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser, 
    2957         int *indent, yaml_string_t *breaks, 
     2957        int *indent, yaml_ostring_t *breaks, 
    29582958        yaml_mark_t start_mark, yaml_mark_t *end_mark) 
    29592959{ 
     
    30233023    yaml_mark_t start_mark; 
    30243024    yaml_mark_t end_mark; 
    3025     yaml_string_t string = NULL_STRING; 
    3026     yaml_string_t leading_break = NULL_STRING; 
    3027     yaml_string_t trailing_breaks = NULL_STRING; 
    3028     yaml_string_t whitespaces = NULL_STRING; 
     3025    yaml_ostring_t string = NULL_OSTRING; 
     3026    yaml_ostring_t leading_break = NULL_OSTRING; 
     3027    yaml_ostring_t trailing_breaks = NULL_OSTRING; 
     3028    yaml_ostring_t whitespaces = NULL_OSTRING; 
    30293029    int leading_blanks; 
    30303030 
    3031     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     3031    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    30323032        goto error; 
    3033     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
     3033    if (!OSTRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
    30343034        goto error; 
    3035     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
     3035    if (!OSTRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
    30363036        goto error; 
    3037     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) 
     3037    if (!OSTRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) 
    30383038        goto error; 
    30393039 
     
    30893089                    && CHECK_AT(parser->input, '\'', 1)) 
    30903090            { 
    3091                 if (!STRING_EXTEND(parser, string)) goto error; 
     3091                if (!OSTRING_EXTEND(parser, string)) goto error; 
    30923092                JOIN_OCTET(string, '\''); 
    30933093                SKIP(parser); 
     
    31203120                size_t code_length = 0; 
    31213121 
    3122                 if (!STRING_EXTEND(parser, string)) goto error; 
     3122                if (!OSTRING_EXTEND(parser, string)) goto error; 
    31233123 
    31243124                /* Check the escape character. */ 
     
    33423342            if (leading_break.buffer[0] == '\n') { 
    33433343                if (trailing_breaks.buffer[0] == '\0') { 
    3344                     if (!STRING_EXTEND(parser, string)) goto error; 
     3344                    if (!OSTRING_EXTEND(parser, string)) goto error; 
    33453345                    JOIN_OCTET(string, ' '); 
    33463346                } 
     
    33773377            start_mark, end_mark); 
    33783378 
    3379     STRING_DEL(parser, leading_break); 
    3380     STRING_DEL(parser, trailing_breaks); 
    3381     STRING_DEL(parser, whitespaces); 
     3379    OSTRING_DEL(parser, leading_break); 
     3380    OSTRING_DEL(parser, trailing_breaks); 
     3381    OSTRING_DEL(parser, whitespaces); 
    33823382 
    33833383    return 1; 
    33843384 
    33853385error: 
    3386     STRING_DEL(parser, string); 
    3387     STRING_DEL(parser, leading_break); 
    3388     STRING_DEL(parser, trailing_breaks); 
    3389     STRING_DEL(parser, whitespaces); 
     3386    OSTRING_DEL(parser, string); 
     3387    OSTRING_DEL(parser, leading_break); 
     3388    OSTRING_DEL(parser, trailing_breaks); 
     3389    OSTRING_DEL(parser, whitespaces); 
    33903390 
    33913391    return 0; 
     
    34013401    yaml_mark_t start_mark; 
    34023402    yaml_mark_t end_mark; 
    3403     yaml_string_t string = NULL_STRING; 
    3404     yaml_string_t leading_break = NULL_STRING; 
    3405     yaml_string_t trailing_breaks = NULL_STRING; 
    3406     yaml_string_t whitespaces = NULL_STRING; 
     3403    yaml_ostring_t string = NULL_OSTRING; 
     3404    yaml_ostring_t leading_break = NULL_OSTRING; 
     3405    yaml_ostring_t trailing_breaks = NULL_OSTRING; 
     3406    yaml_ostring_t whitespaces = NULL_OSTRING; 
    34073407    int leading_blanks = 0; 
    34083408    int indent = parser->indent+1; 
    34093409 
    3410     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     3410    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    34113411        goto error; 
    3412     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
     3412    if (!OSTRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
    34133413        goto error; 
    3414     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
     3414    if (!OSTRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
    34153415        goto error; 
    3416     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) 
     3416    if (!OSTRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) 
    34173417        goto error; 
    34183418 
     
    34763476                    if (leading_break.buffer[0] == '\n') { 
    34773477                        if (trailing_breaks.buffer[0] == '\0') { 
    3478                             if (!STRING_EXTEND(parser, string)) goto error; 
     3478                            if (!OSTRING_EXTEND(parser, string)) goto error; 
    34793479                            JOIN_OCTET(string, ' '); 
    34803480                        } 
     
    35803580    } 
    35813581 
    3582     STRING_DEL(parser, leading_break); 
    3583     STRING_DEL(parser, trailing_breaks); 
    3584     STRING_DEL(parser, whitespaces); 
     3582    OSTRING_DEL(parser, leading_break); 
     3583    OSTRING_DEL(parser, trailing_breaks); 
     3584    OSTRING_DEL(parser, whitespaces); 
    35853585 
    35863586    return 1; 
    35873587 
    35883588error: 
    3589     STRING_DEL(parser, string); 
    3590     STRING_DEL(parser, leading_break); 
    3591     STRING_DEL(parser, trailing_breaks); 
    3592     STRING_DEL(parser, whitespaces); 
     3589    OSTRING_DEL(parser, string); 
     3590    OSTRING_DEL(parser, leading_break); 
     3591    OSTRING_DEL(parser, trailing_breaks); 
     3592    OSTRING_DEL(parser, whitespaces); 
    35933593 
    35943594    return 0; 
  • libyaml/trunk/src/writer.c

    r263 r264  
    2828    } 
    2929 
    30     /* Switch the pointer to the beginning of the buffer. */ 
     30    /* Switch the buffer into the input mode. */ 
    3131 
    32     emitter->output.capacity = emitter->output.pointer; 
     32    emitter->output.length = emitter->output.pointer; 
    3333    emitter->output.pointer = 0; 
    3434 
     
    3838    { 
    3939        if (emitter->writer(emitter->writer_data, 
    40                     emitter->output.buffer, emitter->output.capacity)) { 
    41             emitter->offset += emitter->output.capacity; 
    42             emitter->output.capacity = OUTPUT_BUFFER_CAPACITY; 
     40                    emitter->output.buffer, emitter->output.length)) { 
     41            emitter->offset += emitter->output.length; 
     42            emitter->output.length = 0; 
    4343            return 1; 
    4444        } 
    4545        else { 
    46             return WRITER_ERROR_INIT(emitter, "Write error", emitter->offset); 
     46            return WRITER_ERROR_INIT(emitter, 
     47                    "write handler error", emitter->offset); 
    4748        } 
    4849    } 
     
    5354    high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0); 
    5455 
    55     while (emitter->output.pointer != emitter->output.capacity) 
     56    while (emitter->output.pointer < emitter->output.length) 
    5657    { 
    5758        unsigned char octet; 
     
    114115                emitter->raw_output.buffer, emitter->raw_output.pointer)) { 
    115116        emitter->output.pointer = 0; 
    116         emitter->output.capacity = OUTPUT_BUFFER_CAPACITY; 
     117        emitter->output.length = 0; 
    117118        emitter->offset += emitter->raw_output.pointer; 
    118119        emitter->raw_output.pointer = 0; 
     
    120121    } 
    121122    else { 
    122         return WRITER_ERROR_INIT(emitter, "Write error", emitter->offset); 
     123        return WRITER_ERROR_INIT(emitter, 
     124                "write handler error", emitter->offset); 
    123125    } 
    124126} 
  • 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; 
  • libyaml/trunk/tests/run-scanner.c

    r263 r264  
    2424        yaml_parser_t *parser; 
    2525        yaml_token_t token; 
     26        yaml_error_t error; 
     27        char error_buffer[256]; 
    2628        int done = 0; 
    2729        int count = 0; 
    28         int error = 0; 
     30        int failed = 0; 
    2931 
    3032        printf("[%d] Scanning '%s': ", number, argv[number]); 
     
    4042        while (!done) 
    4143        { 
    42             if (!yaml_parser_scan(parser, &token)) { 
    43                 error = 1; 
     44            if (!yaml_parser_parse_token(parser, &token)) { 
     45                failed = 1; 
    4446                break; 
    4547            } 
     
    5254        } 
    5355 
     56        yaml_parser_get_error(parser, &error); 
     57 
    5458        yaml_parser_delete(parser); 
    5559 
    5660        assert(!fclose(file)); 
    5761 
    58         printf("%s (%d tokens)\n", (error ? "FAILURE" : "SUCCESS"), count); 
     62        yaml_error_message(&error, error_buffer, 256); 
     63 
     64        printf("%s (%d tokens) -> %s\n", 
     65                (failed ? "FAILURE" : "SUCCESS"), 
     66                count, error_buffer); 
    5967    } 
    6068 
Note: See TracChangeset for help on using the changeset viewer.