Index: /libyaml/trunk/configure.ac =================================================================== --- /libyaml/trunk/configure.ac (revision 238) +++ /libyaml/trunk/configure.ac (revision 264) @@ -3,6 +3,6 @@ # Define the package version numbers and the bug reporting link. m4_define([YAML_MAJOR], 0) -m4_define([YAML_MINOR], 0) -m4_define([YAML_PATCH], 1) +m4_define([YAML_MINOR], 2) +m4_define([YAML_PATCH], 0) m4_define([YAML_BUGS], [http://pyyaml.org/newticket?component=libyaml]) @@ -19,5 +19,5 @@ # YAML_AGE = 0 m4_define([YAML_RELEASE], 0) -m4_define([YAML_CURRENT], 1) +m4_define([YAML_CURRENT], 2) m4_define([YAML_REVISION], 0) m4_define([YAML_AGE], 0) @@ -29,10 +29,4 @@ AC_CONFIG_HEADERS([config.h]) AM_INIT_AUTOMAKE([1.9 foreign]) - -# Define macro variables for the package version numbers. -AC_DEFINE(YAML_VERSION_MAJOR, YAML_MAJOR, [Define the major version number.]) -AC_DEFINE(YAML_VERSION_MINOR, YAML_MINOR, [Define the minor version number.]) -AC_DEFINE(YAML_VERSION_PATCH, YAML_PATCH, [Define the patch version number.]) -AC_DEFINE(YAML_VERSION_STRING, "YAML_MAJOR.YAML_MINOR.YAML_PATCH", [Define the version string.]) # Define substitutions for the libtool version numbers. Index: /libyaml/trunk/include/yaml.h =================================================================== --- /libyaml/trunk/include/yaml.h (revision 261) +++ /libyaml/trunk/include/yaml.h (revision 264) @@ -46,17 +46,23 @@ */ -/** - * Get the library version as a string. - * - * @returns The function returns the pointer to a static string of the form - * @c "X.Y.Z", where @c X is the major version number, @c Y is a minor version - * number, and @c Z is the patch version number. - */ - -YAML_DECLARE(const char *) -yaml_get_version_string(void); - -/** - * Get the library version numbers. +/** The major version number. */ +#define YAML_VERSION_MAJOR 0 + +/** The minor version number. */ +#define YAML_VERSION_MINOR 2 + +/** The patch version number. */ +#define YAML_VERSION_PATCH 0 + +/** The version string generator macro. */ +#define YAML_VERSION_STRING_GENERATOR(major,minor,patch) \ + (#major "." #minor "." #patch) + +/** The version string. */ +#define YAML_VERSION_STRING \ + YAML_VERSION_STRING_GENERATOR(YAML_VERSION_MAJOR,YAML_VERSION_MINOR,YAML_VERSION_PATCH) + +/** + * Get the library version numbers at runtime. * * @param[out] major Major version number. @@ -67,4 +73,15 @@ YAML_DECLARE(void) yaml_get_version(int *major, int *minor, int *patch); + +/** + * Get the library version as a string at runtime. + * + * @returns The function returns the pointer to a static string of the form + * @c "X.Y.Z", where @c X is the major version number, @c Y is the minor version + * number, and @c Z is the patch version number. + */ + +YAML_DECLARE(const char *) +yaml_get_version_string(void); /** @} */ @@ -87,5 +104,4 @@ /** Cannot decode the input stream. */ YAML_DECODER_ERROR, - /** Cannot scan a YAML token. */ YAML_SCANNER_ERROR, @@ -97,9 +113,11 @@ /** Cannot write into the output stream. */ YAML_WRITER_ERROR, - /** Cannot emit a YAML event. */ YAML_EMITTER_ERROR, /** Cannot serialize a YAML document. */ - YAML_SERIALIZER_ERROR + YAML_SERIALIZER_ERROR, + + /** Cannot resolve an implicit tag. */ + YAML_RESOLVER_ERROR } yaml_error_type_t; @@ -143,8 +161,4 @@ */ struct { - /** The problem description. */ - const char *problem; - /** The problem mark. */ - yaml_mark_t problem_mark; /** The context in which the problem occured * (@c NULL if not applicable). @@ -153,4 +167,8 @@ /** The context mark (if @c problem_mark is not @c NULL). **/ yaml_mark_t context_mark; + /** The problem description. */ + const char *problem; + /** The problem mark. */ + yaml_mark_t problem_mark; } loading; @@ -171,8 +189,26 @@ } dumping; + /** A problem while resolving an implicit tag (@c YAML_RESOLVER_ERROR). */ + struct { + /** The problem description. */ + const char *problem; + } resolving; + } data; } yaml_error_t; +/** + * Create an error message. + * + * @param[in] error An error object. + * @param[out] buffer model A token to copy. + * + * @returns @c 1 if the function succeeded, @c 0 on error. The function may + * fail if the buffer is not large enough to contain the whole message. + */ + +YAML_DECLARE(int) +yaml_error_message(yaml_error_t *error, char *buffer, size_t capacity); /** @} */ @@ -434,5 +470,5 @@ YAML_DECLARE(int) -yaml_token_duplicate(yaml_token_t *token, yaml_token_t *model); +yaml_token_duplicate(yaml_token_t *token, const yaml_token_t *model); /** @@ -608,5 +644,5 @@ YAML_DECLARE(int) -yaml_event_duplicate(yaml_event_t *event, yaml_event_t *model); +yaml_event_duplicate(yaml_event_t *event, const yaml_event_t *model); /** @@ -792,18 +828,18 @@ /** The tag @c !!null with the only possible value: @c null. */ -#define YAML_NULL_TAG "tag:yaml.org,2002:null" +#define YAML_NULL_TAG ((const yaml_char_t *) "tag:yaml.org,2002:null") /** The tag @c !!bool with the values: @c true and @c falce. */ -#define YAML_BOOL_TAG "tag:yaml.org,2002:bool" +#define YAML_BOOL_TAG ((const yaml_char_t *) "tag:yaml.org,2002:bool") /** The tag @c !!str for string values. */ -#define YAML_STR_TAG "tag:yaml.org,2002:str" +#define YAML_STR_TAG ((const yaml_char_t *) "tag:yaml.org,2002:str") /** The tag @c !!int for integer values. */ -#define YAML_INT_TAG "tag:yaml.org,2002:int" +#define YAML_INT_TAG ((const yaml_char_t *) "tag:yaml.org,2002:int") /** The tag @c !!float for float values. */ -#define YAML_FLOAT_TAG "tag:yaml.org,2002:float" +#define YAML_FLOAT_TAG ((const yaml_char_t *) "tag:yaml.org,2002:float") /** The tag @c !!seq is used to denote sequences. */ -#define YAML_SEQ_TAG "tag:yaml.org,2002:seq" +#define YAML_SEQ_TAG ((const yaml_char_t *) "tag:yaml.org,2002:seq") /** The tag @c !!map is used to denote mapping. */ -#define YAML_MAP_TAG "tag:yaml.org,2002:map" +#define YAML_MAP_TAG ((const yaml_char_t *) "tag:yaml.org,2002:map") /** The default scalar tag is @c !!str. */ @@ -1228,5 +1264,6 @@ */ -typedef int yaml_writer_t(void *data, unsigned char *buffer, size_t length); +typedef int yaml_writer_t(void *data, const unsigned char *buffer, + size_t length); /** @@ -1399,5 +1436,5 @@ YAML_DECLARE(int) -yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token); +yaml_parser_parse_token(yaml_parser_t *parser, yaml_token_t *token); /** @@ -1423,5 +1460,5 @@ YAML_DECLARE(int) -yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event); +yaml_parser_parse_event(yaml_parser_t *parser, yaml_event_t *event); #if 0 @@ -1450,5 +1487,5 @@ YAML_DECLARE(int) -yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document); +yaml_parser_parse_document(yaml_parser_t *parser, yaml_document_t *document); #endif @@ -1648,5 +1685,5 @@ YAML_DECLARE(int) -yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event); +yaml_emitter_emit_event(yaml_emitter_t *emitter, yaml_event_t *event); #if 0 @@ -1695,5 +1732,5 @@ YAML_DECLARE(int) -yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document); +yaml_emitter_emit_document(yaml_emitter_t *emitter, yaml_document_t *document); #endif Index: /libyaml/trunk/src/api.c =================================================================== --- /libyaml/trunk/src/api.c (revision 263) +++ /libyaml/trunk/src/api.c (revision 264) @@ -68,9 +68,114 @@ /* + * Format an error message. + */ + +YAML_DECLARE(int) +yaml_error_message(yaml_error_t *error, char *buffer, size_t capacity) +{ + char *prefixes[] = { + "No error", + "Memory error", + "Reader error", + "Decoder error", + "Scanner error", + "Parser error", + "Composer error", + "Writer error", + "Emitter error", + "Serializer error", + "Resolver error", + }; + int length; + + assert(error); /* Non-NULL error is expected. */ + assert(buffer); /* Non-NULL buffer is expected. */ + + switch (error->type) + { + case YAML_NO_ERROR: + case YAML_MEMORY_ERROR: + length = snprintf(buffer, capacity, "%s", + prefixes[error->type]); + break; + + case YAML_READER_ERROR: + case YAML_DECODER_ERROR: + if (error->data.reading.value == -1) { + length = snprintf(buffer, capacity, + "%s: %s at position %d", + prefixes[error->type], + error->data.reading.problem, + error->data.reading.offset); + } + else { + length = snprintf(buffer, capacity, + "%s: %s (#%X) at position %d", + prefixes[error->type], + error->data.reading.problem, + error->data.reading.value, + error->data.reading.offset); + } + break; + + case YAML_SCANNER_ERROR: + case YAML_PARSER_ERROR: + case YAML_COMPOSER_ERROR: + if (!error->data.loading.context) { + length = snprintf(buffer, capacity, + "%s: %s at line %d, column %d", + prefixes[error->type], + error->data.loading.problem, + error->data.loading.problem_mark.line+1, + error->data.loading.problem_mark.column+1); + } + else { + length = snprintf(buffer, capacity, + "%s: %s at line %d, column %d, %s at line %d, column %d", + prefixes[error->type], + error->data.loading.context, + error->data.loading.context_mark.line+1, + error->data.loading.context_mark.column+1, + error->data.loading.problem, + error->data.loading.problem_mark.line+1, + error->data.loading.problem_mark.column+1); + } + break; + + case YAML_WRITER_ERROR: + length = snprintf(buffer, capacity, + "%s: %s at position %d", + prefixes[error->type], + error->data.writing.problem, + error->data.writing.offset); + break; + + case YAML_EMITTER_ERROR: + case YAML_SERIALIZER_ERROR: + length = snprintf(buffer, capacity, "%s: %s", + prefixes[error->type], + error->data.dumping.problem); + break; + + case YAML_RESOLVER_ERROR: + length = snprintf(buffer, capacity, "%s: %s", + prefixes[error->type], + error->data.resolving.problem); + break; + + default: + assert(0); /* Should never happen. */ + } + + return (length >= 0 && length < capacity); +} + + +/* * Extend a string. */ YAML_DECLARE(int) -yaml_string_extend(yaml_char_t **buffer, size_t *capacity) +yaml_ostring_extend(yaml_char_t **buffer, size_t *capacity) { yaml_char_t *new_buffer = yaml_realloc(*buffer, (*capacity)*2); @@ -91,7 +196,7 @@ YAML_DECLARE(int) -yaml_string_join( +yaml_ostring_join( yaml_char_t **base_buffer, size_t *base_pointer, size_t *base_capacity, - yaml_char_t *adj_buffer, size_t adj_pointer, size_t adj_capacity) + yaml_char_t *adj_buffer, size_t adj_pointer) { if (!adj_pointer) @@ -99,5 +204,5 @@ while (*base_capacity - *base_pointer <= adj_pointer) { - if (!yaml_string_extend(base_buffer, base_capacity)) + if (!yaml_ostring_extend(base_buffer, base_capacity)) return 0; } @@ -173,7 +278,7 @@ memset(parser, 0, sizeof(yaml_parser_t)); - if (!STRING_INIT(parser, parser->raw_input, RAW_INPUT_BUFFER_CAPACITY)) + if (!IOSTRING_INIT(parser, parser->raw_input, RAW_INPUT_BUFFER_CAPACITY)) goto error; - if (!STRING_INIT(parser, parser->input, INPUT_BUFFER_CAPACITY)) + if (!IOSTRING_INIT(parser, parser->input, INPUT_BUFFER_CAPACITY)) goto error; if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_CAPACITY)) @@ -207,6 +312,6 @@ assert(parser); /* Non-NULL parser object expected. */ - STRING_DEL(parser, parser->raw_input); - STRING_DEL(parser, parser->input); + IOSTRING_DEL(parser, parser->raw_input); + IOSTRING_DEL(parser, parser->input); while (!QUEUE_EMPTY(parser, parser->tokens)) { yaml_token_destroy(&DEQUEUE(parser, parser->tokens)); @@ -250,11 +355,11 @@ yaml_standard_reader_data_t *data = untyped_data; - if (data->string.pointer == data->string.capacity) { + if (data->string.pointer == data->string.length) { *length = 0; return 1; } - if (capacity > (size_t)(data->string.capacity - data->string.pointer)) { - capacity = data->string.capacity - data->string.pointer; + if (capacity > (size_t)(data->string.length - data->string.pointer)) { + capacity = data->string.length - data->string.pointer; } @@ -294,7 +399,7 @@ parser->reader_data = &(parser->standard_reader_data); - parser->standard_reader_data.string.buffer = (unsigned char *)buffer; + parser->standard_reader_data.string.buffer = buffer; parser->standard_reader_data.string.pointer = 0; - parser->standard_reader_data.string.capacity = length; + parser->standard_reader_data.string.length = length; } @@ -358,7 +463,7 @@ memset(emitter, 0, sizeof(yaml_emitter_t)); - if (!STRING_INIT(emitter, emitter->output, OUTPUT_BUFFER_CAPACITY)) + if (!IOSTRING_INIT(emitter, emitter->output, OUTPUT_BUFFER_CAPACITY)) goto error; - if (!STRING_INIT(emitter, emitter->raw_output, RAW_OUTPUT_BUFFER_CAPACITY)) + if (!IOSTRING_INIT(emitter, emitter->raw_output, RAW_OUTPUT_BUFFER_CAPACITY)) goto error; if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_CAPACITY)) @@ -388,6 +493,6 @@ assert(emitter); /* Non-NULL emitter object expected. */ - STRING_DEL(emitter, emitter->output); - STRING_DEL(emitter, emitter->raw_output); + IOSTRING_DEL(emitter, emitter->output); + IOSTRING_DEL(emitter, emitter->raw_output); STACK_DEL(emitter, emitter->states); while (!QUEUE_EMPTY(emitter, emitter->events)) { @@ -425,5 +530,5 @@ static int -yaml_string_writer(void *untyped_data, unsigned char *buffer, size_t length) +yaml_string_writer(void *untyped_data, const unsigned char *buffer, size_t length) { yaml_standard_writer_data_t *data = untyped_data; @@ -447,5 +552,5 @@ static int -yaml_file_writer(void *untyped_data, unsigned char *buffer, size_t length) +yaml_file_writer(void *untyped_data, const unsigned char *buffer, size_t length) { yaml_standard_writer_data_t *data = untyped_data; @@ -617,5 +722,5 @@ YAML_DECLARE(int) -yaml_token_duplicate(yaml_token_t *token, yaml_token_t *model) +yaml_token_duplicate(yaml_token_t *token, const yaml_token_t *model) { assert(token); /* Non-NULL token object is expected. */ @@ -810,5 +915,5 @@ YAML_DECLARE(int) -yaml_event_duplicate(yaml_event_t *event, yaml_event_t *model) +yaml_event_duplicate(yaml_event_t *event, const yaml_event_t *model) { struct { Index: /libyaml/trunk/src/emitter.c =================================================================== --- /libyaml/trunk/src/emitter.c (revision 263) +++ /libyaml/trunk/src/emitter.c (revision 264) @@ -14,7 +14,7 @@ */ -#define PUT(emitter,value) \ +#define PUT(emitter, value) \ (FLUSH(emitter) \ - && (JOIN_OCTET(emitter->output,(yaml_char_t)(value)), \ + && (JOIN_OCTET(emitter->output, (yaml_char_t)(value)), \ emitter->column ++, \ 1)) @@ -41,7 +41,7 @@ */ -#define WRITE(emitter,string) \ +#define WRITE(emitter, string) \ (FLUSH(emitter) \ - && (COPY(emitter->output,string), \ + && (COPY(emitter->output, string), \ emitter->column ++, \ 1)) @@ -51,11 +51,11 @@ */ -#define WRITE_BREAK(emitter,string) \ +#define WRITE_BREAK(emitter, string) \ (FLUSH(emitter) \ - && (CHECK(string,'\n') ? \ + && (CHECK(string, '\n') ? \ (PUT_BREAK(emitter), \ string.pointer ++, \ 1) : \ - (COPY(emitter->output,string), \ + (COPY(emitter->output, string), \ emitter->column = 0, \ emitter->line ++, \ @@ -67,5 +67,5 @@ YAML_DECLARE(int) -yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event); +yaml_emitter_emit_event(yaml_emitter_t *emitter, yaml_event_t *event); /* @@ -219,42 +219,42 @@ static int yaml_emitter_write_indicator(yaml_emitter_t *emitter, - char *indicator, int need_whitespace, + const char *indicator, int need_whitespace, int is_whitespace, int is_indention); static int yaml_emitter_write_anchor(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length); + const yaml_char_t *value, size_t length); static int yaml_emitter_write_tag_handle(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length); + const yaml_char_t *value, size_t length); static int yaml_emitter_write_tag_content(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length, int need_whitespace); + const yaml_char_t *value, size_t length, int need_whitespace); static int yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length, int allow_breaks); + const yaml_char_t *value, size_t length, int allow_breaks); static int yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length, int allow_breaks); + const yaml_char_t *value, size_t length, int allow_breaks); static int yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length, int allow_breaks); + const yaml_char_t *value, size_t length, int allow_breaks); static int yaml_emitter_determine_chomping(yaml_emitter_t *emitter, - yaml_string_t string); + yaml_istring_t string); static int yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length); + const yaml_char_t *value, size_t length); static int yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length); + const yaml_char_t *value, size_t length); /* @@ -263,5 +263,5 @@ YAML_DECLARE(int) -yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event) +yaml_emitter_emit_event(yaml_emitter_t *emitter, yaml_event_t *event) { if (!ENQUEUE(emitter, emitter->events, *event)) { @@ -468,5 +468,5 @@ default: - assert(1); /* Invalid state. */ + assert(0); /* Invalid state. */ } @@ -1287,5 +1287,5 @@ default: - assert(1); /* Impossible. */ + assert(0); /* Impossible. */ } @@ -1316,10 +1316,10 @@ yaml_tag_directive_t tag_directive) { - yaml_string_t handle = STRING(tag_directive.handle, + yaml_istring_t handle = ISTRING(tag_directive.handle, strlen((char *)tag_directive.handle)); - yaml_string_t prefix = STRING(tag_directive.prefix, + yaml_istring_t prefix = ISTRING(tag_directive.prefix, strlen((char *)tag_directive.prefix)); - if (!handle.capacity) { + if (!handle.length) { return EMITTER_ERROR_INIT(emitter, "tag handle must not be empty"); } @@ -1329,5 +1329,5 @@ } - if (handle.buffer[handle.capacity-1] != '!') { + if (handle.buffer[handle.length-1] != '!') { return EMITTER_ERROR_INIT(emitter, "tag handle must end with '!'"); } @@ -1335,5 +1335,5 @@ handle.pointer ++; - while (handle.pointer < handle.capacity-1) { + while (handle.pointer < handle.length-1) { if (!IS_ALPHA(handle)) { return EMITTER_ERROR_INIT(emitter, @@ -1343,5 +1343,5 @@ } - if (!prefix.capacity) { + if (!prefix.length) { return EMITTER_ERROR_INIT(emitter, "tag prefix must not be empty"); } @@ -1358,7 +1358,7 @@ yaml_char_t *anchor, int is_alias) { - yaml_string_t string = STRING(anchor, strlen((char *)anchor)); - - if (!string.capacity) { + yaml_istring_t string = ISTRING(anchor, strlen((char *)anchor)); + + if (!string.length) { return EMITTER_ERROR_INIT(emitter, is_alias ? "alias value must not be empty" : @@ -1366,5 +1366,5 @@ } - while (string.pointer < string.capacity) { + while (string.pointer < string.length) { if (!IS_ALPHA(string)) { return EMITTER_ERROR_INIT(emitter, is_alias ? @@ -1376,5 +1376,5 @@ emitter->anchor_data.anchor = string.buffer; - emitter->anchor_data.anchor_length = string.capacity; + emitter->anchor_data.anchor_length = string.length; emitter->anchor_data.is_alias = is_alias; @@ -1390,15 +1390,16 @@ yaml_char_t *tag) { - yaml_string_t string = STRING(tag, strlen((char *)tag)); + yaml_istring_t string = ISTRING(tag, strlen((char *)tag)); size_t idx; - if (!string.capacity) { + if (!string.length) { return EMITTER_ERROR_INIT(emitter, "tag value must not be empty"); } for (idx = 0; idx < emitter->tag_directives.length; idx ++) { - yaml_tag_directive_t *tag_directive = emitter->tag_directives.list+idx; + yaml_tag_directive_t *tag_directive = + STACK_ITER(emitter, emitter->tag_directives, idx); size_t prefix_length = strlen((char *)tag_directive->prefix); - if (prefix_length < string.capacity + if (prefix_length < string.length && strncmp((char *)tag_directive->prefix, (char *)string.buffer, prefix_length) == 0) @@ -1408,5 +1409,5 @@ strlen((char *)tag_directive->handle); emitter->tag_data.suffix = string.buffer + prefix_length; - emitter->tag_data.suffix_length = string.capacity - prefix_length; + emitter->tag_data.suffix_length = string.length - prefix_length; return 1; } @@ -1414,5 +1415,5 @@ emitter->tag_data.suffix = string.buffer; - emitter->tag_data.suffix_length = string.capacity; + emitter->tag_data.suffix_length = string.length; return 1; @@ -1427,5 +1428,5 @@ yaml_char_t *value, size_t length) { - yaml_string_t string = STRING(value, length); + yaml_istring_t string = ISTRING(value, length); int block_indicators = 0; @@ -1453,5 +1454,5 @@ emitter->scalar_data.length = length; - if (!string.capacity) + if (!string.length) { emitter->scalar_data.is_multiline = 0; @@ -1477,5 +1478,5 @@ followed_by_space = IS_BLANKZ_AT(string, WIDTH(string)); - while (string.pointer < string.capacity) + while (string.pointer < string.length) { if (!string.pointer) @@ -1584,5 +1585,5 @@ } - if ((spaces || breaks) && string.pointer == string.capacity-1) + if ((spaces || breaks) && string.pointer == string.length-1) { if (spaces && breaks) { @@ -1605,5 +1606,5 @@ preceeded_by_space = IS_BLANKZ(string); MOVE(string); - if (string.pointer < string.capacity) { + if (string.pointer < string.length) { followed_by_space = IS_BLANKZ_AT(string, WIDTH(string)); } @@ -1770,8 +1771,8 @@ static int yaml_emitter_write_indicator(yaml_emitter_t *emitter, - char *indicator, int need_whitespace, + const char *indicator, int need_whitespace, int is_whitespace, int is_indention) { - yaml_string_t string = STRING((yaml_char_t *)indicator, strlen(indicator)); + yaml_istring_t string = ISTRING((yaml_char_t *)indicator, strlen(indicator)); if (need_whitespace && !emitter->is_whitespace) { @@ -1779,5 +1780,5 @@ } - while (string.pointer < string.capacity) { + while (string.pointer < string.length) { if (!WRITE(emitter, string)) return 0; } @@ -1791,9 +1792,9 @@ static int yaml_emitter_write_anchor(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length) -{ - yaml_string_t string = STRING(value, length); - - while (string.pointer < string.capacity) { + const yaml_char_t *value, size_t length) +{ + yaml_istring_t string = ISTRING(value, length); + + while (string.pointer < string.length) { if (!WRITE(emitter, string)) return 0; } @@ -1807,7 +1808,7 @@ static int yaml_emitter_write_tag_handle(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length) -{ - yaml_string_t string = STRING(value, length); + const yaml_char_t *value, size_t length) +{ + yaml_istring_t string = ISTRING(value, length); if (!emitter->is_whitespace) { @@ -1815,5 +1816,5 @@ } - while (string.pointer < string.capacity) { + while (string.pointer < string.length) { if (!WRITE(emitter, string)) return 0; } @@ -1827,8 +1828,8 @@ static int yaml_emitter_write_tag_content(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length, + const yaml_char_t *value, size_t length, int need_whitespace) { - yaml_string_t string = STRING(value, length); + yaml_istring_t string = ISTRING(value, length); if (need_whitespace && !emitter->is_whitespace) { @@ -1836,5 +1837,5 @@ } - while (string.pointer < string.capacity) { + while (string.pointer < string.length) { if (IS_ALPHA(string) || CHECK(string, ';') || CHECK(string, '/') @@ -1875,7 +1876,7 @@ static int yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length, int allow_breaks) -{ - yaml_string_t string = STRING(value, length); + const yaml_char_t *value, size_t length, int allow_breaks) +{ + yaml_istring_t string = ISTRING(value, length); int spaces = 0; int breaks = 0; @@ -1885,5 +1886,5 @@ } - while (string.pointer < string.capacity) + while (string.pointer < string.length) { if (IS_SPACE(string)) @@ -1929,7 +1930,7 @@ static int yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length, int allow_breaks) -{ - yaml_string_t string = STRING(value, length); + const yaml_char_t *value, size_t length, int allow_breaks) +{ + yaml_istring_t string = ISTRING(value, length); int spaces = 0; int breaks = 0; @@ -1938,5 +1939,5 @@ return 0; - while (string.pointer < string.capacity) + while (string.pointer < string.length) { if (IS_SPACE(string)) @@ -1944,6 +1945,5 @@ if (allow_breaks && !spaces && emitter->column > emitter->best_width - && string.pointer != 0 - && string.pointer != string.capacity - 1 + && string.pointer > 0 && string.pointer < string.length && !IS_SPACE_AT(string, 1)) { if (!yaml_emitter_write_indent(emitter)) return 0; @@ -1990,7 +1990,7 @@ static int yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length, int allow_breaks) -{ - yaml_string_t string = STRING(value, length); + const yaml_char_t *value, size_t length, int allow_breaks) +{ + yaml_istring_t string = ISTRING(value, length); int spaces = 0; @@ -1998,5 +1998,5 @@ return 0; - while (string.pointer < string.capacity) + while (string.pointer < string.length) { if (!IS_PRINTABLE(string) || (!emitter->is_unicode && !IS_ASCII(string)) @@ -2113,6 +2113,6 @@ if (allow_breaks && !spaces && emitter->column > emitter->best_width - && string.pointer != 0 - && string.pointer != string.capacity - 1) { + && string.pointer > 0 + && string.pointer < string.length) { if (!yaml_emitter_write_indent(emitter)) return 0; if (IS_SPACE_AT(string, 1)) { @@ -2144,7 +2144,7 @@ static int yaml_emitter_determine_chomping(yaml_emitter_t *emitter, - yaml_string_t string) -{ - string.pointer = string.capacity; + yaml_istring_t string) +{ + string.pointer = string.length; if (!string.pointer) return -1; @@ -2167,7 +2167,7 @@ static int yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length) -{ - yaml_string_t string = STRING(value, length); + const yaml_char_t *value, size_t length) +{ + yaml_istring_t string = ISTRING(value, length); int chomp = yaml_emitter_determine_chomping(emitter, string); int breaks = 0; @@ -2179,5 +2179,5 @@ return 0; - while (string.pointer < string.capacity) + while (string.pointer < string.length) { if (IS_BREAK(string)) @@ -2203,7 +2203,7 @@ static int yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter, - yaml_char_t *value, size_t length) -{ - yaml_string_t string = STRING(value, length); + const yaml_char_t *value, size_t length) +{ + yaml_istring_t string = ISTRING(value, length); int chomp = yaml_emitter_determine_chomping(emitter, string); int breaks = 1; @@ -2216,5 +2216,5 @@ return 0; - while (string.pointer < string.capacity) + while (string.pointer < string.length) { if (IS_BREAK(string)) Index: /libyaml/trunk/src/scanner.c =================================================================== --- /libyaml/trunk/src/scanner.c (revision 263) +++ /libyaml/trunk/src/scanner.c (revision 264) @@ -516,7 +516,7 @@ */ -#define READ(parser,string) \ - (STRING_EXTEND(parser,string) ? \ - (COPY(string,parser->input), \ +#define READ(parser, string) \ + (OSTRING_EXTEND(parser, string) ? \ + (COPY(string, parser->input), \ parser->mark.index ++, \ parser->mark.column ++, \ @@ -528,8 +528,8 @@ */ -#define READ_LINE(parser,string) \ - (STRING_EXTEND(parser,string) ? \ - (((CHECK_AT(parser->input,'\r',0) \ - && CHECK_AT(parser->input,'\n',1)) ? /* CR LF -> LF */ \ +#define READ_LINE(parser, string) \ + (OSTRING_EXTEND(parser, string) ? \ + (((CHECK_AT(parser->input, '\r', 0) \ + && CHECK_AT(parser->input, '\n', 1)) ? /* CR LF -> LF */ \ (JOIN_OCTET(string, (yaml_char_t) '\n'), \ parser->input.pointer += 2, \ @@ -538,7 +538,7 @@ parser->mark.line ++, \ parser->unread -= 2) : \ - (CHECK_AT(parser->input,'\r',0) \ - || CHECK_AT(parser->input,'\n',0)) ? /* CR|LF -> LF */ \ - (JOIN_OCTET(string,(yaml_char_t) '\n'), \ + (CHECK_AT(parser->input, '\r', 0) \ + || CHECK_AT(parser->input, '\n', 0)) ? /* CR|LF -> LF */ \ + (JOIN_OCTET(string, (yaml_char_t) '\n'), \ parser->input.pointer ++, \ parser->mark.index ++, \ @@ -546,7 +546,7 @@ parser->mark.line ++, \ parser->unread --) : \ - (CHECK_AT(parser->input,'\xC2',0) \ - && CHECK_AT(parser->input,'\x85',1)) ? /* NEL -> LF */ \ - (JOIN_OCTET(string,(yaml_char_t) '\n'), \ + (CHECK_AT(parser->input, '\xC2', 0) \ + && CHECK_AT(parser->input, '\x85', 1)) ? /* NEL -> LF */ \ + (JOIN_OCTET(string, (yaml_char_t) '\n'), \ parser->input.pointer += 2, \ parser->mark.index ++, \ @@ -554,11 +554,11 @@ parser->mark.line ++, \ parser->unread --) : \ - (CHECK_AT(parser->input,'\xE2',0) && \ - CHECK_AT(parser->input,'\x80',1) && \ - (CHECK_AT(parser->input,'\xA8',2) || \ - CHECK_AT(parser->input,'\xA9',2))) ? /* LS|PS -> LS|PS */ \ - (COPY_OCTET(string,parser->input), \ - COPY_OCTET(string,parser->input), \ - COPY_OCTET(string,parser->input), \ + (CHECK_AT(parser->input, '\xE2', 0) && \ + CHECK_AT(parser->input, '\x80', 1) && \ + (CHECK_AT(parser->input, '\xA8', 2) || \ + CHECK_AT(parser->input, '\xA9', 2))) ? /* LS|PS -> LS|PS */ \ + (COPY_OCTET(string, parser->input), \ + COPY_OCTET(string, parser->input), \ + COPY_OCTET(string, parser->input), \ parser->mark.index ++, \ parser->mark.column = 0, \ @@ -572,5 +572,5 @@ YAML_DECLARE(int) -yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token); +yaml_parser_parse_token(yaml_parser_t *parser, yaml_token_t *token); /* @@ -709,5 +709,5 @@ static int yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive, - yaml_mark_t start_mark, yaml_string_t *string); + yaml_mark_t start_mark, yaml_ostring_t *string); static int @@ -717,5 +717,5 @@ static int yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser, - int *indent, yaml_string_t *breaks, + int *indent, yaml_ostring_t *breaks, yaml_mark_t start_mark, yaml_mark_t *end_mark); @@ -732,5 +732,5 @@ YAML_DECLARE(int) -yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token) +yaml_parser_parse_token(yaml_parser_t *parser, yaml_token_t *token) { assert(parser); /* Non-NULL parser object is expected. */ @@ -2093,7 +2093,7 @@ yaml_mark_t start_mark, yaml_char_t **name) { - yaml_string_t string = NULL_STRING; - - if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) + yaml_ostring_t string = NULL_OSTRING; + + if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) goto error; @@ -2131,5 +2131,5 @@ error: - STRING_DEL(parser, string); + OSTRING_DEL(parser, string); return 0; } @@ -2312,7 +2312,7 @@ int length = 0; yaml_mark_t start_mark, end_mark; - yaml_string_t string = NULL_STRING; - - if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) + yaml_ostring_t string = NULL_OSTRING; + + if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) goto error; @@ -2367,5 +2367,5 @@ error: - STRING_DEL(parser, string); + OSTRING_DEL(parser, string); return 0; } @@ -2496,7 +2496,7 @@ yaml_mark_t start_mark, yaml_char_t **handle) { - yaml_string_t string = NULL_STRING; - - if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) + yaml_ostring_t string = NULL_OSTRING; + + if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) goto error; @@ -2554,5 +2554,5 @@ error: - STRING_DEL(parser, string); + OSTRING_DEL(parser, string); return 0; } @@ -2567,7 +2567,7 @@ { size_t length = head ? strlen((char *)head) : 0; - yaml_string_t string = NULL_STRING; - - if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) + yaml_ostring_t string = NULL_OSTRING; + + if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) goto error; @@ -2575,5 +2575,5 @@ while (string.capacity <= length) { - if (!yaml_string_extend(&string.buffer, &string.capacity)) { + if (!yaml_ostring_extend(&string.buffer, &string.capacity)) { MEMORY_ERROR_INIT(parser); goto error; @@ -2633,5 +2633,5 @@ if (!length) { - if (!STRING_EXTEND(parser, string)) + if (!OSTRING_EXTEND(parser, string)) goto error; @@ -2647,5 +2647,5 @@ error: - STRING_DEL(parser, string); + OSTRING_DEL(parser, string); return 0; } @@ -2657,5 +2657,5 @@ static int yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive, - yaml_mark_t start_mark, yaml_string_t *string) + yaml_mark_t start_mark, yaml_ostring_t *string) { int width = 0; @@ -2731,7 +2731,7 @@ yaml_mark_t start_mark; yaml_mark_t end_mark; - yaml_string_t string = NULL_STRING; - yaml_string_t leading_break = NULL_STRING; - yaml_string_t trailing_breaks = NULL_STRING; + yaml_ostring_t string = NULL_OSTRING; + yaml_ostring_t leading_break = NULL_OSTRING; + yaml_ostring_t trailing_breaks = NULL_OSTRING; int chomping = 0; int increment = 0; @@ -2740,9 +2740,9 @@ int trailing_blank = 0; - if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) goto error; - if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) goto error; - if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) goto error; @@ -2881,5 +2881,5 @@ if (*trailing_breaks.buffer == '\0') { - if (!STRING_EXTEND(parser, string)) goto error; + if (!OSTRING_EXTEND(parser, string)) goto error; JOIN_OCTET(string, ' '); } @@ -2935,13 +2935,13 @@ start_mark, end_mark); - STRING_DEL(parser, leading_break); - STRING_DEL(parser, trailing_breaks); + OSTRING_DEL(parser, leading_break); + OSTRING_DEL(parser, trailing_breaks); return 1; error: - STRING_DEL(parser, string); - STRING_DEL(parser, leading_break); - STRING_DEL(parser, trailing_breaks); + OSTRING_DEL(parser, string); + OSTRING_DEL(parser, leading_break); + OSTRING_DEL(parser, trailing_breaks); return 0; @@ -2955,5 +2955,5 @@ static int yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser, - int *indent, yaml_string_t *breaks, + int *indent, yaml_ostring_t *breaks, yaml_mark_t start_mark, yaml_mark_t *end_mark) { @@ -3023,17 +3023,17 @@ yaml_mark_t start_mark; yaml_mark_t end_mark; - yaml_string_t string = NULL_STRING; - yaml_string_t leading_break = NULL_STRING; - yaml_string_t trailing_breaks = NULL_STRING; - yaml_string_t whitespaces = NULL_STRING; + yaml_ostring_t string = NULL_OSTRING; + yaml_ostring_t leading_break = NULL_OSTRING; + yaml_ostring_t trailing_breaks = NULL_OSTRING; + yaml_ostring_t whitespaces = NULL_OSTRING; int leading_blanks; - if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) goto error; - if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) goto error; - if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) goto error; - if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) goto error; @@ -3089,5 +3089,5 @@ && CHECK_AT(parser->input, '\'', 1)) { - if (!STRING_EXTEND(parser, string)) goto error; + if (!OSTRING_EXTEND(parser, string)) goto error; JOIN_OCTET(string, '\''); SKIP(parser); @@ -3120,5 +3120,5 @@ size_t code_length = 0; - if (!STRING_EXTEND(parser, string)) goto error; + if (!OSTRING_EXTEND(parser, string)) goto error; /* Check the escape character. */ @@ -3342,5 +3342,5 @@ if (leading_break.buffer[0] == '\n') { if (trailing_breaks.buffer[0] == '\0') { - if (!STRING_EXTEND(parser, string)) goto error; + if (!OSTRING_EXTEND(parser, string)) goto error; JOIN_OCTET(string, ' '); } @@ -3377,15 +3377,15 @@ start_mark, end_mark); - STRING_DEL(parser, leading_break); - STRING_DEL(parser, trailing_breaks); - STRING_DEL(parser, whitespaces); + OSTRING_DEL(parser, leading_break); + OSTRING_DEL(parser, trailing_breaks); + OSTRING_DEL(parser, whitespaces); return 1; error: - STRING_DEL(parser, string); - STRING_DEL(parser, leading_break); - STRING_DEL(parser, trailing_breaks); - STRING_DEL(parser, whitespaces); + OSTRING_DEL(parser, string); + OSTRING_DEL(parser, leading_break); + OSTRING_DEL(parser, trailing_breaks); + OSTRING_DEL(parser, whitespaces); return 0; @@ -3401,18 +3401,18 @@ yaml_mark_t start_mark; yaml_mark_t end_mark; - yaml_string_t string = NULL_STRING; - yaml_string_t leading_break = NULL_STRING; - yaml_string_t trailing_breaks = NULL_STRING; - yaml_string_t whitespaces = NULL_STRING; + yaml_ostring_t string = NULL_OSTRING; + yaml_ostring_t leading_break = NULL_OSTRING; + yaml_ostring_t trailing_breaks = NULL_OSTRING; + yaml_ostring_t whitespaces = NULL_OSTRING; int leading_blanks = 0; int indent = parser->indent+1; - if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) goto error; - if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) goto error; - if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) goto error; - if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) + if (!OSTRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) goto error; @@ -3476,5 +3476,5 @@ if (leading_break.buffer[0] == '\n') { if (trailing_breaks.buffer[0] == '\0') { - if (!STRING_EXTEND(parser, string)) goto error; + if (!OSTRING_EXTEND(parser, string)) goto error; JOIN_OCTET(string, ' '); } @@ -3580,15 +3580,15 @@ } - STRING_DEL(parser, leading_break); - STRING_DEL(parser, trailing_breaks); - STRING_DEL(parser, whitespaces); + OSTRING_DEL(parser, leading_break); + OSTRING_DEL(parser, trailing_breaks); + OSTRING_DEL(parser, whitespaces); return 1; error: - STRING_DEL(parser, string); - STRING_DEL(parser, leading_break); - STRING_DEL(parser, trailing_breaks); - STRING_DEL(parser, whitespaces); + OSTRING_DEL(parser, string); + OSTRING_DEL(parser, leading_break); + OSTRING_DEL(parser, trailing_breaks); + OSTRING_DEL(parser, whitespaces); return 0; Index: /libyaml/trunk/src/parser.c =================================================================== --- /libyaml/trunk/src/parser.c (revision 263) +++ /libyaml/trunk/src/parser.c (revision 264) @@ -48,5 +48,5 @@ #define PEEK_TOKEN(parser) \ ((parser->is_token_available || yaml_parser_fetch_more_tokens(parser)) ? \ - parser->tokens.list + parser->tokens.head : NULL) + QUEUE_ITER(parser, parser->tokens, 0) : NULL) /* @@ -58,5 +58,5 @@ parser->tokens_parsed ++, \ parser->is_stream_end_produced = \ - (parser->tokens.list[parser->tokens.head].type == YAML_STREAM_END_TOKEN), \ + (QUEUE_ITER(parser, parser->tokens, 0)->type == YAML_STREAM_END_TOKEN), \ parser->tokens.head ++) @@ -66,5 +66,5 @@ YAML_DECLARE(int) -yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event); +yaml_parser_parse_event(yaml_parser_t *parser, yaml_event_t *event); /* @@ -156,5 +156,5 @@ YAML_DECLARE(int) -yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event) +yaml_parser_parse_event(yaml_parser_t *parser, yaml_event_t *event) { assert(parser); /* Non-NULL parser object is expected. */ @@ -256,5 +256,5 @@ default: - assert(1); /* Invalid state. */ + assert(0); /* Invalid state. */ } @@ -563,5 +563,6 @@ int idx; for (idx = 0; idx < parser->tag_directives.length; idx++) { - yaml_tag_directive_t *tag_directive = parser->tag_directives.list + idx; + yaml_tag_directive_t *tag_directive = + STACK_ITER(parser, parser->tag_directives, idx); if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) { size_t prefix_len = strlen((char *)tag_directive->prefix); @@ -1311,5 +1312,6 @@ for (idx = 0; idx < parser->tag_directives.length; idx++) { - yaml_tag_directive_t *tag_directive = parser->tag_directives.list + idx; + yaml_tag_directive_t *tag_directive = + STACK_ITER(parser, parser->tag_directives, idx); if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) { if (allow_duplicates) Index: /libyaml/trunk/src/writer.c =================================================================== --- /libyaml/trunk/src/writer.c (revision 263) +++ /libyaml/trunk/src/writer.c (revision 264) @@ -28,7 +28,7 @@ } - /* Switch the pointer to the beginning of the buffer. */ + /* Switch the buffer into the input mode. */ - emitter->output.capacity = emitter->output.pointer; + emitter->output.length = emitter->output.pointer; emitter->output.pointer = 0; @@ -38,11 +38,12 @@ { if (emitter->writer(emitter->writer_data, - emitter->output.buffer, emitter->output.capacity)) { - emitter->offset += emitter->output.capacity; - emitter->output.capacity = OUTPUT_BUFFER_CAPACITY; + emitter->output.buffer, emitter->output.length)) { + emitter->offset += emitter->output.length; + emitter->output.length = 0; return 1; } else { - return WRITER_ERROR_INIT(emitter, "Write error", emitter->offset); + return WRITER_ERROR_INIT(emitter, + "write handler error", emitter->offset); } } @@ -53,5 +54,5 @@ high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0); - while (emitter->output.pointer != emitter->output.capacity) + while (emitter->output.pointer < emitter->output.length) { unsigned char octet; @@ -114,5 +115,5 @@ emitter->raw_output.buffer, emitter->raw_output.pointer)) { emitter->output.pointer = 0; - emitter->output.capacity = OUTPUT_BUFFER_CAPACITY; + emitter->output.length = 0; emitter->offset += emitter->raw_output.pointer; emitter->raw_output.pointer = 0; @@ -120,5 +121,6 @@ } else { - return WRITER_ERROR_INIT(emitter, "Write error", emitter->offset); + return WRITER_ERROR_INIT(emitter, + "write handler error", emitter->offset); } } Index: /libyaml/trunk/src/yaml_private.h =================================================================== --- /libyaml/trunk/src/yaml_private.h (revision 263) +++ /libyaml/trunk/src/yaml_private.h (revision 264) @@ -29,85 +29,103 @@ */ -#define ERROR_INIT(error,error_type) \ - (memset(&(error), 0, sizeof(error)), \ - (error).type = (error_type), \ +/* + * Generic error initializers; not to be used directly. + */ + +#define ERROR_INIT(error, _type) \ + (memset(&(error), 0, sizeof(yaml_error_t)), \ + (error).type = (_type), \ 0) -#define READING_ERROR_INIT(error,error_type,error_problem,error_offset,error_value) \ - (memset(&(error), 0, sizeof(error)), \ - (error).type = (error_type), \ - (error).data.reading.problem = (error_problem), \ - (error).data.reading.offset = (error_offset), \ - (error).data.reading.value = (error_value), \ +#define READING_ERROR_INIT(error, _type, _problem, _offset, _value) \ + (ERROR_INIT(error, _type), \ + (error).data.reading.problem = (_problem), \ + (error).data.reading.offset = (_offset), \ + (error).data.reading.value = (_value), \ 0) -#define LOADING_ERROR_INIT(error,error_type,error_problem,error_problem_mark) \ - (memset(&(error), 0, sizeof(error)), \ - (error).type = (error_type), \ +#define LOADING_ERROR_INIT(error, _type, _problem, _problem_mark) \ + (ERROR_INIT(error, _type), \ (error).data.loading.context = NULL, \ (error).data.loading.context_mark.index = 0, \ (error).data.loading.context_mark.line = 0, \ (error).data.loading.context_mark.column = 0, \ - (error).data.loading.problem = (error_problem), \ - (error).data.loading.problem_mark = (error_problem_mark), \ + (error).data.loading.problem = (_problem), \ + (error).data.loading.problem_mark = (_problem_mark), \ 0) -#define LOADING_ERROR_WITH_CONTEXT_INIT(error,error_type,error_context,error_context_mark,error_problem,error_problem_mark) \ - (memset(&(error), 0, sizeof(error)), \ - (error).type = (error_type), \ - (error).data.loading.context = (error_context), \ - (error).data.loading.context_mark = (error_context_mark), \ - (error).data.loading.problem = (error_problem), \ - (error).data.loading.problem_mark = (error_problem_mark), \ +#define LOADING_ERROR_WITH_CONTEXT_INIT(error, _type, _context, _context_mark, \ + _problem, _problem_mark) \ + (ERROR_INIT(error, _type), \ + (error).data.loading.context = (_context), \ + (error).data.loading.context_mark = (_context_mark), \ + (error).data.loading.problem = (_problem), \ + (error).data.loading.problem_mark = (_problem_mark), \ 0) -#define WRITING_ERROR_INIT(error,error_type,error_problem,error_offset) \ - (memset(&(error), 0, sizeof(error)), \ - (error).type = (error_type), \ - (error).data.writing.problem = (error_problem), \ - (error).data.writing.offset = (error_offset), \ +#define WRITING_ERROR_INIT(error, _type, _problem, _offset) \ + (ERROR_INIT(error, _type), \ + (error).data.writing.problem = (_problem), \ + (error).data.writing.offset = (_offset), \ 0) -#define DUMPING_ERROR_INIT(error,error_type,error_problem) \ - (memset(&(error), 0, sizeof(error)), \ - (error).type = (error_type), \ - (error).data.dumping.problem = (error_problem), \ +#define DUMPING_ERROR_INIT(error, _type, _problem) \ + (ERROR_INIT(error, _type), \ + (error).data.dumping.problem = (_problem), \ 0) +#define RESOLVING_ERROR_INIT(error, _type, _problem) \ + (ERROR_INIT(error, _type), \ + (error).data.resolving.problem = (_problem), \ + 0) + +/* + * Specific error initializers. + */ + #define MEMORY_ERROR_INIT(self) \ - ERROR_INIT((self)->error,YAML_MEMORY_ERROR) - -#define READER_ERROR_INIT(self,problem,offset) \ - READING_ERROR_INIT((self)->error,YAML_READER_ERROR,problem,offset,-1) - -#define DECODER_ERROR_INIT(self,problem,offset,value) \ - READING_ERROR_INIT((self)->error,YAML_DECODER_ERROR,problem,offset,value) - -#define SCANNER_ERROR_INIT(self,problem,problem_mark) \ - LOADING_ERROR_INIT((self)->error,YAML_SCANNER_ERROR,problem,problem_mark) - -#define SCANNER_ERROR_WITH_CONTEXT_INIT(self,context,context_mark,problem,problem_mark) \ - LOADING_ERROR_WITH_CONTEXT_INIT((self)->error,YAML_SCANNER_ERROR,context,context_mark,problem,problem_mark) - -#define PARSER_ERROR_INIT(self,problem,problem_mark) \ - LOADING_ERROR_INIT((self)->error,YAML_PARSER_ERROR,problem,problem_mark) - -#define PARSER_ERROR_WITH_CONTEXT_INIT(self,context,context_mark,problem,problem_mark) \ - LOADING_ERROR_WITH_CONTEXT_INIT((self)->error,YAML_PARSER_ERROR,context,context_mark,problem,problem_mark) - -#define COMPOSER_ERROR_INIT(self,problem,problem_mark) \ - LOADING_ERROR_INIT((self)->error,YAML_COMPOSER_ERROR,problem,problem_mark) - -#define COMPOSER_ERROR_WITH_CONTEXT_INIT(self,context,context_mark,problem,problem_mark) \ - LOADING_ERROR_WITH_CONTEXT_INIT((self)->error,YAML_COMPOSER_ERROR,context,context_mark,problem,problem_mark) - -#define WRITER_ERROR_INIT(self,problem,offset) \ - WRITING_ERROR_INIT((self)->error,YAML_WRITER_ERROR,problem,offset) - -#define EMITTER_ERROR_INIT(self,problem) \ - DUMPING_ERROR_INIT((self)->error,YAML_EMITTER_ERROR,problem) - -#define SERIALIZER_ERROR_INIT(self,context) \ - DUMPING_ERROR_INIT((self)->error,YAML_SERIALIZER_ERROR,problem) + ERROR_INIT((self)->error, YAML_MEMORY_ERROR) + +#define READER_ERROR_INIT(self, _problem, _offset) \ + READING_ERROR_INIT((self)->error, YAML_READER_ERROR, _problem, _offset, -1) + +#define DECODER_ERROR_INIT(self, _problem, _offset, _value) \ + READING_ERROR_INIT((self)->error, YAML_DECODER_ERROR, _problem, _offset, _value) + +#define SCANNER_ERROR_INIT(self, _problem, _problem_mark) \ + LOADING_ERROR_INIT((self)->error, YAML_SCANNER_ERROR, _problem, _problem_mark) + +#define SCANNER_ERROR_WITH_CONTEXT_INIT(self, _context, _context_mark, \ + _problem, _problem_mark) \ + LOADING_ERROR_WITH_CONTEXT_INIT((self)->error, YAML_SCANNER_ERROR, \ + _context, _context_mark, _problem, _problem_mark) + +#define PARSER_ERROR_INIT(self, _problem, _problem_mark) \ + LOADING_ERROR_INIT((self)->error, YAML_PARSER_ERROR, _problem, _problem_mark) + +#define PARSER_ERROR_WITH_CONTEXT_INIT(self, _context, _context_mark, \ + _problem, _problem_mark) \ + LOADING_ERROR_WITH_CONTEXT_INIT((self)->error, YAML_PARSER_ERROR, \ + _context, _context_mark, _problem, _problem_mark) + +#define COMPOSER_ERROR_INIT(self, _problem, _problem_mark) \ + LOADING_ERROR_INIT((self)->error, YAML_COMPOSER_ERROR, _problem, _problem_mark) + +#define COMPOSER_ERROR_WITH_CONTEXT_INIT(self, _context, _context_mark, \ + _problem, _problem_mark) \ + LOADING_ERROR_WITH_CONTEXT_INIT((self)->error, YAML_COMPOSER_ERROR, \ + _context, _context_mark, _problem, _problem_mark) + +#define WRITER_ERROR_INIT(self, _problem, _offset) \ + WRITING_ERROR_INIT((self)->error, YAML_WRITER_ERROR, _problem, _offset) + +#define EMITTER_ERROR_INIT(self, _problem) \ + DUMPING_ERROR_INIT((self)->error, YAML_EMITTER_ERROR, _problem) + +#define SERIALIZER_ERROR_INIT(self, _problem) \ + DUMPING_ERROR_INIT((self)->error, YAML_SERIALIZER_ERROR, _problem) + +#define RESOLVER_ERROR_INIT(self, _problem) \ + RESOLVER_ERROR_INIT((self)->error, YAML_RESOLVER_ERROR, _problem) /* @@ -153,51 +171,101 @@ */ -typedef struct yaml_string_s { +/* + * An immutable string used as an input buffer. + */ + +typedef struct yaml_istring_s { + const yaml_char_t *buffer; + size_t pointer; + size_t length; +} yaml_istring_t; + +/* + * A string that is used as an output buffer. + */ + +typedef struct yaml_ostring_s { yaml_char_t *buffer; size_t pointer; size_t capacity; -} yaml_string_t; +} yaml_ostring_t; + +/* + * A string that could be used both as an input and an output buffer. + */ + +typedef struct yaml_iostring_s { + yaml_char_t *buffer; + size_t pointer; + size_t length; + size_t capacity; +} yaml_iostring_t; + +/* + * Separate type for non-UTF-8 i/o strings. + */ + +typedef struct yaml_raw_iostring_s { + unsigned char *buffer; + size_t pointer; + size_t length; + size_t capacity; +} yaml_raw_iostring_t; YAML_DECLARE(int) -yaml_string_extend(yaml_char_t **buffer, size_t *capacity); +yaml_ostring_extend(yaml_char_t **buffer, size_t *capacity); YAML_DECLARE(int) -yaml_string_join( +yaml_ostring_join( yaml_char_t **base_buffer, size_t *base_pointer, size_t *base_capacity, - yaml_char_t *adj_buffer, size_t adj_pointer, size_t adj_capacity); - -#define NULL_STRING { NULL, 0, 0 } - -#define STRING(string,capacity) { (string), 0, (capacity) } - -#define STRING_INIT(self,string,string_capacity) \ - (((string).buffer = yaml_malloc(string_capacity)) ? \ - ((string).pointer = 0, \ - (string).capacity = (string_capacity), \ - memset((string).buffer, 0, (string_capacity)), \ + yaml_char_t *adj_buffer, size_t adj_pointer); + +#define ISTRING(buffer, length) { (buffer), 0, (length) } + +#define NULL_OSTRING { NULL, 0, 0 } + +#define IOSTRING_INIT(self, string, _capacity) \ + (((string).buffer = yaml_malloc(_capacity)) ? \ + ((string).pointer = (string).length = 0, \ + (string).capacity = (_capacity), \ + memset((string).buffer, 0, (_capacity)), \ 1) : \ ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) -#define STRING_DEL(self,string) \ +#define IOSTRING_DEL(self, string) \ + (yaml_free((string).buffer), \ + (string).buffer = NULL, \ + ((string).pointer = (string).length = (string).capacity = 0)) + +#define OSTRING_INIT(self, string, _capacity) \ + (((string).buffer = yaml_malloc(_capacity)) ? \ + ((string).pointer = 0, \ + (string).capacity = (_capacity), \ + memset((string).buffer, 0, (_capacity)), \ + 1) : \ + ((self)->error.type = YAML_MEMORY_ERROR, \ + 0)) + +#define OSTRING_DEL(self, string) \ (yaml_free((string).buffer), \ (string).buffer = NULL, \ ((string).pointer = (string).capacity = 0)) -#define STRING_EXTEND(self,string) \ +#define OSTRING_EXTEND(self, string) \ ((((string).pointer+5 < (string).capacity) \ - || yaml_string_extend(&(string).buffer, &(string).capacity)) ? \ + || yaml_ostring_extend(&(string).buffer, &(string).capacity)) ? \ 1 : \ ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) -#define CLEAR(self,string) \ +#define CLEAR(self, string) \ ((string).pointer = 0, \ memset((string).buffer, 0, (string).capacity)) -#define JOIN(self,base_string,adj_string) \ - ((yaml_string_join(&(base_string).buffer, &(base_string).pointer, \ - &(base_string).capacity, (adj_string).buffer, \ - (adj_string).pointer, (adj_string).capacity)) ? \ +#define JOIN(self, base_string, adj_string) \ + ((yaml_ostring_join(&(base_string).buffer, &(base_string).pointer, \ + &(base_string).capacity, \ + (adj_string).buffer, (adj_string).pointer)) ? \ ((adj_string).pointer = 0, \ 1) : \ @@ -213,5 +281,5 @@ */ -#define OCTET_AT(string,offset) \ +#define OCTET_AT(string, offset) \ ((string).buffer[(string).pointer+(offset)]) @@ -220,5 +288,5 @@ */ -#define OCTET(string) OCTET_AT((string),0) +#define OCTET(string) OCTET_AT((string), 0) /* @@ -226,6 +294,6 @@ */ -#define CHECK_AT(string,octet,offset) \ - (OCTET_AT((string),(offset)) == (yaml_char_t)(octet)) +#define CHECK_AT(string, octet, offset) \ + (OCTET_AT((string), (offset)) == (yaml_char_t)(octet)) /* @@ -233,5 +301,5 @@ */ -#define CHECK(string,octet) CHECK_AT((string),(octet),0) +#define CHECK(string, octet) CHECK_AT((string), (octet), 0) /* @@ -240,15 +308,15 @@ */ -#define IS_ALPHA_AT(string,offset) \ - ((OCTET_AT((string),(offset)) >= (yaml_char_t) '0' && \ - OCTET_AT((string),(offset)) <= (yaml_char_t) '9') || \ - (OCTET_AT((string),(offset)) >= (yaml_char_t) 'A' && \ - OCTET_AT((string),(offset)) <= (yaml_char_t) 'Z') || \ - (OCTET_AT((string),(offset)) >= (yaml_char_t) 'a' && \ - OCTET_AT((string),(offset)) <= (yaml_char_t) 'z') || \ - OCTET_AT((string),(offset)) == '_' || \ - OCTET_AT((string),(offset)) == '-') - -#define IS_ALPHA(string) IS_ALPHA_AT((string),0) +#define IS_ALPHA_AT(string, offset) \ + ((OCTET_AT((string), (offset)) >= (yaml_char_t) '0' && \ + OCTET_AT((string), (offset)) <= (yaml_char_t) '9') || \ + (OCTET_AT((string), (offset)) >= (yaml_char_t) 'A' && \ + OCTET_AT((string), (offset)) <= (yaml_char_t) 'Z') || \ + (OCTET_AT((string), (offset)) >= (yaml_char_t) 'a' && \ + OCTET_AT((string), (offset)) <= (yaml_char_t) 'z') || \ + OCTET_AT((string), (offset)) == '_' || \ + OCTET_AT((string), (offset)) == '-') + +#define IS_ALPHA(string) IS_ALPHA_AT((string), 0) /* @@ -256,9 +324,9 @@ */ -#define IS_DIGIT_AT(string,offset) \ - ((OCTET_AT((string),(offset)) >= (yaml_char_t) '0' && \ - OCTET_AT((string),(offset)) <= (yaml_char_t) '9')) - -#define IS_DIGIT(string) IS_DIGIT_AT((string),0) +#define IS_DIGIT_AT(string, offset) \ + ((OCTET_AT((string), (offset)) >= (yaml_char_t) '0' && \ + OCTET_AT((string), (offset)) <= (yaml_char_t) '9')) + +#define IS_DIGIT(string) IS_DIGIT_AT((string), 0) /* @@ -266,8 +334,8 @@ */ -#define AS_DIGIT_AT(string,offset) \ - (OCTET_AT((string),(offset)) - (yaml_char_t) '0') - -#define AS_DIGIT(string) AS_DIGIT_AT((string),0) +#define AS_DIGIT_AT(string, offset) \ + (OCTET_AT((string), (offset)) - (yaml_char_t) '0') + +#define AS_DIGIT(string) AS_DIGIT_AT((string), 0) /* @@ -275,13 +343,13 @@ */ -#define IS_HEX_AT(string,offset) \ - ((OCTET_AT((string),(offset)) >= (yaml_char_t) '0' && \ - OCTET_AT((string),(offset)) <= (yaml_char_t) '9') || \ - (OCTET_AT((string),(offset)) >= (yaml_char_t) 'A' && \ - OCTET_AT((string),(offset)) <= (yaml_char_t) 'F') || \ - (OCTET_AT((string),(offset)) >= (yaml_char_t) 'a' && \ - OCTET_AT((string),(offset)) <= (yaml_char_t) 'f')) - -#define IS_HEX(string) IS_HEX_AT((string),0) +#define IS_HEX_AT(string, offset) \ + ((OCTET_AT((string), (offset)) >= (yaml_char_t) '0' && \ + OCTET_AT((string), (offset)) <= (yaml_char_t) '9') || \ + (OCTET_AT((string), (offset)) >= (yaml_char_t) 'A' && \ + OCTET_AT((string), (offset)) <= (yaml_char_t) 'F') || \ + (OCTET_AT((string), (offset)) >= (yaml_char_t) 'a' && \ + OCTET_AT((string), (offset)) <= (yaml_char_t) 'f')) + +#define IS_HEX(string) IS_HEX_AT((string), 0) /* @@ -289,14 +357,14 @@ */ -#define AS_HEX_AT(string,offset) \ - ((OCTET_AT((string),(offset)) >= (yaml_char_t) 'A' && \ - OCTET_AT((string),(offset)) <= (yaml_char_t) 'F') ? \ - (OCTET_AT((string),(offset)) - (yaml_char_t) 'A' + 10) : \ - (OCTET_AT((string),(offset)) >= (yaml_char_t) 'a' && \ - OCTET_AT((string),(offset)) <= (yaml_char_t) 'f') ? \ - (OCTET_AT((string),(offset)) - (yaml_char_t) 'a' + 10) : \ - (OCTET_AT((string),(offset)) - (yaml_char_t) '0')) +#define AS_HEX_AT(string, offset) \ + ((OCTET_AT((string), (offset)) >= (yaml_char_t) 'A' && \ + OCTET_AT((string), (offset)) <= (yaml_char_t) 'F') ? \ + (OCTET_AT((string), (offset)) - (yaml_char_t) 'A' + 10) : \ + (OCTET_AT((string), (offset)) >= (yaml_char_t) 'a' && \ + OCTET_AT((string), (offset)) <= (yaml_char_t) 'f') ? \ + (OCTET_AT((string), (offset)) - (yaml_char_t) 'a' + 10) : \ + (OCTET_AT((string), (offset)) - (yaml_char_t) '0')) -#define AS_HEX(string) AS_HEX_AT((string),0) +#define AS_HEX(string) AS_HEX_AT((string), 0) /* @@ -304,8 +372,8 @@ */ -#define IS_ASCII_AT(string,offset) \ - (OCTET_AT((string),(offset)) <= (yaml_char_t) '\x7F') - -#define IS_ASCII(string) IS_ASCII_AT((string),0) +#define IS_ASCII_AT(string, offset) \ + (OCTET_AT((string), (offset)) <= (yaml_char_t) '\x7F') + +#define IS_ASCII(string) IS_ASCII_AT((string), 0) /* @@ -313,23 +381,23 @@ */ -#define IS_PRINTABLE_AT(string,offset) \ - ((OCTET_AT((string),(offset)) == 0x0A) /* . == #x0A */ \ - || (OCTET_AT((string),(offset)) >= 0x20 /* #x20 <= . <= #x7E */ \ - && OCTET_AT((string),(offset)) <= 0x7E) \ - || (OCTET_AT((string),(offset)) == 0xC2 /* #0xA0 <= . <= #xD7FF */ \ - && OCTET_AT((string),(offset)+1) >= 0xA0) \ - || (OCTET_AT((string),(offset)) > 0xC2 \ - && OCTET_AT((string),(offset)) < 0xED) \ - || (OCTET_AT((string),(offset)) == 0xED \ - && OCTET_AT((string),(offset)+1) < 0xA0) \ - || (OCTET_AT((string),(offset)) == 0xEE) \ - || (OCTET_AT((string),(offset)) == 0xEF /* #xE000 <= . <= #xFFFD */ \ - && !(OCTET_AT((string),(offset)+1) == 0xBB /* && . != #xFEFF */ \ - && OCTET_AT((string),(offset)+2) == 0xBF) \ - && !(OCTET_AT((string),(offset)+1) == 0xBF \ - && (OCTET_AT((string),(offset)+2) == 0xBE \ - || OCTET_AT((string),(offset)+2) == 0xBF)))) - -#define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0) +#define IS_PRINTABLE_AT(string, offset) \ + ((OCTET_AT((string), (offset)) == 0x0A) /* . == #x0A */ \ + || (OCTET_AT((string), (offset)) >= 0x20 /* #x20 <= . <= #x7E */ \ + && OCTET_AT((string), (offset)) <= 0x7E) \ + || (OCTET_AT((string), (offset)) == 0xC2 /* #0xA0 <= . <= #xD7FF */ \ + && OCTET_AT((string), (offset)+1) >= 0xA0) \ + || (OCTET_AT((string), (offset)) > 0xC2 \ + && OCTET_AT((string), (offset)) < 0xED) \ + || (OCTET_AT((string), (offset)) == 0xED \ + && OCTET_AT((string), (offset)+1) < 0xA0) \ + || (OCTET_AT((string), (offset)) == 0xEE) \ + || (OCTET_AT((string), (offset)) == 0xEF /* #xE000 <= . <= #xFFFD */ \ + && !(OCTET_AT((string), (offset)+1) == 0xBB /* && . != #xFEFF */ \ + && OCTET_AT((string), (offset)+2) == 0xBF) \ + && !(OCTET_AT((string), (offset)+1) == 0xBF \ + && (OCTET_AT((string), (offset)+2) == 0xBE \ + || OCTET_AT((string), (offset)+2) == 0xBF)))) + +#define IS_PRINTABLE(string) IS_PRINTABLE_AT((string), 0) /* @@ -337,7 +405,7 @@ */ -#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset)) - -#define IS_Z(string) IS_Z_AT((string),0) +#define IS_Z_AT(string, offset) CHECK_AT((string), '\0', (offset)) + +#define IS_Z(string) IS_Z_AT((string), 0) /* @@ -345,10 +413,10 @@ */ -#define IS_BOM_AT(string,offset) \ - (CHECK_AT((string),'\xEF',(offset)) \ - && CHECK_AT((string),'\xBB',(offset)+1) \ - && CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */ - -#define IS_BOM(string) IS_BOM_AT(string,0) +#define IS_BOM_AT(string, offset) \ + (CHECK_AT((string), '\xEF', (offset)) \ + && CHECK_AT((string), '\xBB', (offset)+1) \ + && CHECK_AT((string), '\xBF', (offset)+2)) /* BOM (#xFEFF) */ + +#define IS_BOM(string) IS_BOM_AT(string, 0) /* @@ -356,7 +424,7 @@ */ -#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset)) - -#define IS_SPACE(string) IS_SPACE_AT((string),0) +#define IS_SPACE_AT(string, offset) CHECK_AT((string), ' ', (offset)) + +#define IS_SPACE(string) IS_SPACE_AT((string), 0) /* @@ -364,7 +432,7 @@ */ -#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset)) - -#define IS_TAB(string) IS_TAB_AT((string),0) +#define IS_TAB_AT(string, offset) CHECK_AT((string), '\t', (offset)) + +#define IS_TAB(string) IS_TAB_AT((string), 0) /* @@ -372,8 +440,8 @@ */ -#define IS_BLANK_AT(string,offset) \ - (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset))) - -#define IS_BLANK(string) IS_BLANK_AT((string),0) +#define IS_BLANK_AT(string, offset) \ + (IS_SPACE_AT((string), (offset)) || IS_TAB_AT((string), (offset))) + +#define IS_BLANK(string) IS_BLANK_AT((string), 0) /* @@ -381,22 +449,22 @@ */ -#define IS_BREAK_AT(string,offset) \ - (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \ - || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \ - || (CHECK_AT((string),'\xC2',(offset)) \ - && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \ - || (CHECK_AT((string),'\xE2',(offset)) \ - && CHECK_AT((string),'\x80',(offset)+1) \ - && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \ - || (CHECK_AT((string),'\xE2',(offset)) \ - && CHECK_AT((string),'\x80',(offset)+1) \ - && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */ - -#define IS_BREAK(string) IS_BREAK_AT((string),0) - -#define IS_CRLF_AT(string,offset) \ - (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1)) - -#define IS_CRLF(string) IS_CRLF_AT((string),0) +#define IS_BREAK_AT(string, offset) \ + (CHECK_AT((string), '\r', (offset)) /* CR (#xD)*/ \ + || CHECK_AT((string), '\n', (offset)) /* LF (#xA) */ \ + || (CHECK_AT((string), '\xC2', (offset)) \ + && CHECK_AT((string), '\x85', (offset)+1)) /* NEL (#x85) */ \ + || (CHECK_AT((string), '\xE2', (offset)) \ + && CHECK_AT((string), '\x80', (offset)+1) \ + && CHECK_AT((string), '\xA8', (offset)+2)) /* LS (#x2028) */ \ + || (CHECK_AT((string), '\xE2', (offset)) \ + && CHECK_AT((string), '\x80', (offset)+1) \ + && CHECK_AT((string), '\xA9', (offset)+2))) /* PS (#x2029) */ + +#define IS_BREAK(string) IS_BREAK_AT((string), 0) + +#define IS_CRLF_AT(string, offset) \ + (CHECK_AT((string), '\r', (offset)) && CHECK_AT((string), '\n', (offset)+1)) + +#define IS_CRLF(string) IS_CRLF_AT((string), 0) /* @@ -404,8 +472,8 @@ */ -#define IS_BREAKZ_AT(string,offset) \ - (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset))) - -#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0) +#define IS_BREAKZ_AT(string, offset) \ + (IS_BREAK_AT((string), (offset)) || IS_Z_AT((string), (offset))) + +#define IS_BREAKZ(string) IS_BREAKZ_AT((string), 0) /* @@ -413,8 +481,8 @@ */ -#define IS_SPACEZ_AT(string,offset) \ - (IS_SPACE_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) - -#define IS_SPACEZ(string) IS_SPACEZ_AT((string),0) +#define IS_SPACEZ_AT(string, offset) \ + (IS_SPACE_AT((string), (offset)) || IS_BREAKZ_AT((string), (offset))) + +#define IS_SPACEZ(string) IS_SPACEZ_AT((string), 0) /* @@ -422,8 +490,8 @@ */ -#define IS_BLANKZ_AT(string,offset) \ - (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset))) - -#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0) +#define IS_BLANKZ_AT(string, offset) \ + (IS_BLANK_AT((string), (offset)) || IS_BREAKZ_AT((string), (offset))) + +#define IS_BLANKZ(string) IS_BLANKZ_AT((string), 0) /* @@ -431,11 +499,11 @@ */ -#define WIDTH_AT(string,offset) \ - ((OCTET_AT((string),(offset)) & 0x80) == 0x00 ? 1 : \ - (OCTET_AT((string),(offset)) & 0xE0) == 0xC0 ? 2 : \ - (OCTET_AT((string),(offset)) & 0xF0) == 0xE0 ? 3 : \ - (OCTET_AT((string),(offset)) & 0xF8) == 0xF0 ? 4 : 0) - -#define WIDTH(string) WIDTH_AT((string),0) +#define WIDTH_AT(string, offset) \ + ((OCTET_AT((string), (offset)) & 0x80) == 0x00 ? 1 : \ + (OCTET_AT((string), (offset)) & 0xE0) == 0xC0 ? 2 : \ + (OCTET_AT((string), (offset)) & 0xF0) == 0xE0 ? 3 : \ + (OCTET_AT((string), (offset)) & 0xF8) == 0xF0 ? 4 : 0) + +#define WIDTH(string) WIDTH_AT((string), 0) /* @@ -449,5 +517,5 @@ */ -#define JOIN_OCTET(string,octet) \ +#define JOIN_OCTET(string, octet) \ ((string).buffer[(string).pointer++] = (octet)) @@ -456,7 +524,7 @@ */ -#define COPY_OCTET(string_a,string_b) \ - ((string_a).buffer[(string_a).pointer++] \ - = (string_b).buffer[(string_b).pointer++]) +#define COPY_OCTET(target_string, source_string) \ + ((target_string).buffer[(target_string).pointer++] \ + = (source_string).buffer[(source_string).pointer++]) /* @@ -464,19 +532,19 @@ */ -#define COPY(string_a,string_b) \ - ((OCTET(string_b) & 0x80) == 0x00 ? \ - COPY_OCTET((string_a),(string_b)) : \ - (OCTET(string_b) & 0xE0) == 0xC0 ? \ - (COPY_OCTET((string_a),(string_b)), \ - COPY_OCTET((string_a),(string_b))) : \ - (OCTET(string_b) & 0xF0) == 0xE0 ? \ - (COPY_OCTET((string_a),(string_b)), \ - COPY_OCTET((string_a),(string_b)), \ - COPY_OCTET((string_a),(string_b))) : \ - (OCTET(string_b) & 0xF8) == 0xF0 ? \ - (COPY_OCTET((string_a),(string_b)), \ - COPY_OCTET((string_a),(string_b)), \ - COPY_OCTET((string_a),(string_b)), \ - COPY_OCTET((string_a),(string_b))) : 0) \ +#define COPY(target_string, source_string) \ + ((OCTET(source_string) & 0x80) == 0x00 ? \ + COPY_OCTET((target_string), (source_string)) : \ + (OCTET(source_string) & 0xE0) == 0xC0 ? \ + (COPY_OCTET((target_string), (source_string)), \ + COPY_OCTET((target_string), (source_string))) : \ + (OCTET(source_string) & 0xF0) == 0xE0 ? \ + (COPY_OCTET((target_string), (source_string)), \ + COPY_OCTET((target_string), (source_string)), \ + COPY_OCTET((target_string), (source_string))) : \ + (OCTET(source_string) & 0xF8) == 0xF0 ? \ + (COPY_OCTET((target_string), (source_string)), \ + COPY_OCTET((target_string), (source_string)), \ + COPY_OCTET((target_string), (source_string)), \ + COPY_OCTET((target_string), (source_string))) : 0) /* @@ -491,21 +559,24 @@ size_t *head, size_t *tail, size_t *capacity); -#define STACK_INIT(self,stack,stack_capacity) \ - (((stack).list = yaml_malloc((stack_capacity)*sizeof(*(stack).list))) ? \ +#define STACK_INIT(self, stack, _capacity) \ + (((stack).list = yaml_malloc((_capacity)*sizeof(*(stack).list))) ? \ ((stack).length = 0, \ - (stack).capacity = (stack_capacity), \ + (stack).capacity = (_capacity), \ 1) : \ ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) -#define STACK_DEL(self,stack) \ +#define STACK_DEL(self, stack) \ (yaml_free((stack).list), \ (stack).list = NULL, \ (stack).length = (stack).capacity = 0) -#define STACK_EMPTY(self,stack) \ +#define STACK_EMPTY(self, stack) \ ((stack).length == 0) -#define PUSH(self,stack,value) \ +#define STACK_ITER(self, stack, index) \ + ((stack).list + index) + +#define PUSH(self, stack, value) \ (((stack).length < (stack).capacity \ || yaml_stack_extend((void **)&(stack).list, sizeof(*(stack).list), \ @@ -516,24 +587,27 @@ 0)) -#define POP(self,stack) \ +#define POP(self, stack) \ ((stack).list[--(stack).length]) -#define QUEUE_INIT(self,queue,queue_capacity) \ - (((queue).list = yaml_malloc((queue_capacity)*sizeof(*(queue).list))) ? \ +#define QUEUE_INIT(self, queue, _capacity) \ + (((queue).list = yaml_malloc((_capacity)*sizeof(*(queue).list))) ? \ ((queue).head = (queue).tail = 0, \ - (queue).capacity = (queue_capacity), \ + (queue).capacity = (_capacity), \ 1) : \ ((self)->error.type = YAML_MEMORY_ERROR, \ 0)) -#define QUEUE_DEL(self,queue) \ +#define QUEUE_DEL(self, queue) \ (yaml_free((queue).list), \ (queue).list = NULL, \ (queue).head = (queue).tail = (queue).capacity = 0) -#define QUEUE_EMPTY(self,queue) \ +#define QUEUE_EMPTY(self, queue) \ ((queue).head == (queue).tail) -#define ENQUEUE(self,queue,value) \ +#define QUEUE_ITER(self, queue, index) \ + ((queue).list + (queue).head + index) + +#define ENQUEUE(self, queue, value) \ (((queue).tail != (queue).capacity \ || yaml_queue_extend((void **)&(queue).list, sizeof(*(queue).list), \ @@ -544,8 +618,8 @@ 0)) -#define DEQUEUE(self,queue) \ +#define DEQUEUE(self, queue) \ ((queue).list[(queue).head++]) -#define QUEUE_INSERT(self,queue,index,value) \ +#define QUEUE_INSERT(self, queue, index, value) \ (((queue).tail != (queue).capacity \ || yaml_queue_extend((void **)&(queue).list, sizeof(*(queue).list), \ @@ -564,45 +638,45 @@ */ -#define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark) \ +#define TOKEN_INIT(token, _type, _start_mark, _end_mark) \ (memset(&(token), 0, sizeof(yaml_token_t)), \ - (token).type = (token_type), \ - (token).start_mark = (token_start_mark), \ - (token).end_mark = (token_end_mark)) - -#define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark) \ - (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)), \ - (token).data.stream_start.encoding = (token_encoding)) - -#define STREAM_END_TOKEN_INIT(token,start_mark,end_mark) \ - (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark))) - -#define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark) \ - (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)), \ - (token).data.alias.value = (token_value)) - -#define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark) \ - (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)), \ - (token).data.anchor.value = (token_value)) - -#define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark) \ - (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)), \ - (token).data.tag.handle = (token_handle), \ - (token).data.tag.suffix = (token_suffix)) - -#define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark) \ - (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \ - (token).data.scalar.value = (token_value), \ - (token).data.scalar.length = (token_length), \ - (token).data.scalar.style = (token_style)) - -#define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark) \ - (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ - (token).data.version_directive.major = (token_major), \ - (token).data.version_directive.minor = (token_minor)) - -#define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark) \ - (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \ - (token).data.tag_directive.handle = (token_handle), \ - (token).data.tag_directive.prefix = (token_prefix)) + (token).type = (_type), \ + (token).start_mark = (_start_mark), \ + (token).end_mark = (_end_mark)) + +#define STREAM_START_TOKEN_INIT(token, _encoding, _start_mark, _end_mark) \ + (TOKEN_INIT((token), YAML_STREAM_START_TOKEN, (_start_mark), (_end_mark)), \ + (token).data.stream_start.encoding = (_encoding)) + +#define STREAM_END_TOKEN_INIT(token, _start_mark, _end_mark) \ + (TOKEN_INIT((token), YAML_STREAM_END_TOKEN, (_start_mark), (_end_mark))) + +#define ALIAS_TOKEN_INIT(token, _value, _start_mark, _end_mark) \ + (TOKEN_INIT((token), YAML_ALIAS_TOKEN, (_start_mark), (_end_mark)), \ + (token).data.alias.value = (_value)) + +#define ANCHOR_TOKEN_INIT(token, _value, _start_mark, _end_mark) \ + (TOKEN_INIT((token), YAML_ANCHOR_TOKEN, (_start_mark), (_end_mark)), \ + (token).data.anchor.value = (_value)) + +#define TAG_TOKEN_INIT(token, _handle, _suffix, _start_mark, _end_mark) \ + (TOKEN_INIT((token), YAML_TAG_TOKEN, (_start_mark), (_end_mark)), \ + (token).data.tag.handle = (_handle), \ + (token).data.tag.suffix = (_suffix)) + +#define SCALAR_TOKEN_INIT(token, _value, _length, _style, _start_mark, _end_mark) \ + (TOKEN_INIT((token), YAML_SCALAR_TOKEN, (_start_mark), (_end_mark)), \ + (token).data.scalar.value = (_value), \ + (token).data.scalar.length = (_length), \ + (token).data.scalar.style = (_style)) + +#define VERSION_DIRECTIVE_TOKEN_INIT(token, _major, _minor, _start_mark, _end_mark) \ + (TOKEN_INIT((token), YAML_VERSION_DIRECTIVE_TOKEN, (_start_mark), (_end_mark)), \ + (token).data.version_directive.major = (_major), \ + (token).data.version_directive.minor = (_minor)) + +#define TAG_DIRECTIVE_TOKEN_INIT(token, _handle, _prefix, _start_mark, _end_mark) \ + (TOKEN_INIT((token), YAML_TAG_DIRECTIVE_TOKEN, (_start_mark), (_end_mark)), \ + (token).data.tag_directive.handle = (_handle), \ + (token).data.tag_directive.prefix = (_prefix)) /* @@ -610,68 +684,69 @@ */ -#define EVENT_INIT(event,event_type,event_start_mark,event_end_mark) \ +#define EVENT_INIT(event, _type, _start_mark, _end_mark) \ (memset(&(event), 0, sizeof(yaml_event_t)), \ - (event).type = (event_type), \ - (event).start_mark = (event_start_mark), \ - (event).end_mark = (event_end_mark)) - -#define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark) \ - (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \ - (event).data.stream_start.encoding = (event_encoding)) - -#define STREAM_END_EVENT_INIT(event,start_mark,end_mark) \ - (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark))) - -#define DOCUMENT_START_EVENT_INIT(event,event_version_directive, \ - event_tag_directives_list,event_tag_directives_length, \ - event_tag_directives_capacity,event_is_implicit,start_mark,end_mark) \ - (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \ - (event).data.document_start.version_directive = (event_version_directive), \ - (event).data.document_start.tag_directives.list = (event_tag_directives_list), \ - (event).data.document_start.tag_directives.length = (event_tag_directives_length), \ - (event).data.document_start.tag_directives.capacity = (event_tag_directives_capacity), \ - (event).data.document_start.is_implicit = (event_is_implicit)) - -#define DOCUMENT_END_EVENT_INIT(event,event_is_implicit,start_mark,end_mark) \ - (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \ - (event).data.document_end.is_implicit = (event_is_implicit)) - -#define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark) \ - (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \ - (event).data.alias.anchor = (event_anchor)) - -#define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value, \ - event_length,event_is_plain_implicit,event_is_quoted_implicit, \ - event_style,start_mark,end_mark) \ - (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \ - (event).data.scalar.anchor = (event_anchor), \ - (event).data.scalar.tag = (event_tag), \ - (event).data.scalar.value = (event_value), \ - (event).data.scalar.length = (event_length), \ - (event).data.scalar.is_plain_implicit = (event_is_plain_implicit), \ - (event).data.scalar.is_quoted_implicit = (event_is_quoted_implicit), \ - (event).data.scalar.style = (event_style)) - -#define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag, \ - event_is_implicit,event_style,start_mark,end_mark) \ - (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \ - (event).data.sequence_start.anchor = (event_anchor), \ - (event).data.sequence_start.tag = (event_tag), \ - (event).data.sequence_start.is_implicit = (event_is_implicit), \ - (event).data.sequence_start.style = (event_style)) - -#define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark) \ - (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark))) - -#define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag, \ - event_is_implicit,event_style,start_mark,end_mark) \ - (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \ - (event).data.mapping_start.anchor = (event_anchor), \ - (event).data.mapping_start.tag = (event_tag), \ - (event).data.mapping_start.is_implicit = (event_is_implicit), \ - (event).data.mapping_start.style = (event_style)) - -#define MAPPING_END_EVENT_INIT(event,start_mark,end_mark) \ - (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark))) + (event).type = (_type), \ + (event).start_mark = (_start_mark), \ + (event).end_mark = (_end_mark)) + +#define STREAM_START_EVENT_INIT(event, _encoding, _start_mark, _end_mark) \ + (EVENT_INIT((event), YAML_STREAM_START_EVENT, (_start_mark), (_end_mark)), \ + (event).data.stream_start.encoding = (_encoding)) + +#define STREAM_END_EVENT_INIT(event, _start_mark, _end_mark) \ + (EVENT_INIT((event), YAML_STREAM_END_EVENT, (_start_mark), (_end_mark))) + +#define DOCUMENT_START_EVENT_INIT(event, _version_directive, \ + _tag_directives_list, _tag_directives_length, _tag_directives_capacity, \ + _is_implicit, _start_mark, _end_mark) \ + (EVENT_INIT((event), YAML_DOCUMENT_START_EVENT, (_start_mark),(_end_mark)), \ + (event).data.document_start.version_directive = (_version_directive), \ + (event).data.document_start.tag_directives.list = (_tag_directives_list), \ + (event).data.document_start.tag_directives.length = (_tag_directives_length), \ + (event).data.document_start.tag_directives.capacity = (_tag_directives_capacity), \ + (event).data.document_start.is_implicit = (_is_implicit)) + +#define DOCUMENT_END_EVENT_INIT(event, _is_implicit, _start_mark, _end_mark) \ + (EVENT_INIT((event), YAML_DOCUMENT_END_EVENT, (_start_mark), (_end_mark)), \ + (event).data.document_end.is_implicit = (_is_implicit)) + +#define ALIAS_EVENT_INIT(event, _anchor, _start_mark, _end_mark) \ + (EVENT_INIT((event), YAML_ALIAS_EVENT, (_start_mark), (_end_mark)), \ + (event).data.alias.anchor = (_anchor)) + +#define SCALAR_EVENT_INIT(event, _anchor, _tag, _value, _length, \ + _is_plain_implicit, _is_quoted_implicit, _style, _start_mark, _end_mark) \ + (EVENT_INIT((event), YAML_SCALAR_EVENT, (_start_mark), (_end_mark)), \ + (event).data.scalar.anchor = (_anchor), \ + (event).data.scalar.tag = (_tag), \ + (event).data.scalar.value = (_value), \ + (event).data.scalar.length = (_length), \ + (event).data.scalar.is_plain_implicit = (_is_plain_implicit), \ + (event).data.scalar.is_quoted_implicit = (_is_quoted_implicit), \ + (event).data.scalar.style = (_style)) + +#define SEQUENCE_START_EVENT_INIT(event, _anchor, _tag, _is_implicit, _style, \ + _start_mark, _end_mark) \ + (EVENT_INIT((event), YAML_SEQUENCE_START_EVENT, (_start_mark), (_end_mark)), \ + (event).data.sequence_start.anchor = (_anchor), \ + (event).data.sequence_start.tag = (_tag), \ + (event).data.sequence_start.is_implicit = (_is_implicit), \ + (event).data.sequence_start.style = (_style)) + +#define SEQUENCE_END_EVENT_INIT(event, _start_mark, _end_mark) \ + (EVENT_INIT((event), YAML_SEQUENCE_END_EVENT, (_start_mark), (_end_mark))) + +#define MAPPING_START_EVENT_INIT(event, _anchor, _tag, _is_implicit, _style, \ + _start_mark, _end_mark) \ + (EVENT_INIT((event), YAML_MAPPING_START_EVENT, (_start_mark), (_end_mark)), \ + (event).data.mapping_start.anchor = (_anchor), \ + (event).data.mapping_start.tag = (_tag), \ + (event).data.mapping_start.is_implicit = (_is_implicit), \ + (event).data.mapping_start.style = (_style)) + +#define MAPPING_END_EVENT_INIT(event, _start_mark, _end_mark) \ + (EVENT_INIT((event), YAML_MAPPING_END_EVENT, (_start_mark), (_end_mark))) + +#if 0 /* @@ -728,4 +803,6 @@ (node).data.mapping.pairs.top = (node_pairs_start), \ (node).data.mapping.style = (node_style)) + +#endif /* @@ -818,5 +895,5 @@ typedef union yaml_standard_reader_data_u { /* String input data. */ - yaml_string_t string; + yaml_istring_t string; /* File input data. */ FILE *file; @@ -852,9 +929,5 @@ /* The working buffer. */ - struct { - yaml_char_t *buffer; - size_t pointer; - size_t capacity; - } input; + yaml_iostring_t input; /* The number of unread characters in the buffer. */ @@ -862,9 +935,5 @@ /* The raw buffer. */ - struct { - unsigned char *buffer; - size_t pointer; - size_t capacity; - } raw_input; + yaml_raw_iostring_t raw_input; /* The input encoding. */ @@ -1023,5 +1092,5 @@ typedef union yaml_standard_writer_data_u { /* String output data. */ - yaml_string_t string; + yaml_ostring_t string; size_t *length; /* File output data. */ @@ -1055,16 +1124,8 @@ /* The working buffer. */ - struct { - yaml_char_t *buffer; - size_t pointer; - size_t capacity; - } output; + yaml_iostring_t output; /* The raw buffer. */ - struct { - yaml_char_t *buffer; - size_t pointer; - size_t capacity; - } raw_output; + yaml_raw_iostring_t raw_output; /* The offset of the current position (in bytes). */ @@ -1148,5 +1209,5 @@ struct { /* The anchor value. */ - yaml_char_t *anchor; + const yaml_char_t *anchor; /* The anchor length. */ size_t anchor_length; @@ -1158,9 +1219,9 @@ struct { /* The tag handle. */ - yaml_char_t *handle; + const yaml_char_t *handle; /* The tag handle length. */ size_t handle_length; /* The tag suffix. */ - yaml_char_t *suffix; + const yaml_char_t *suffix; /* The tag suffix length. */ size_t suffix_length; @@ -1170,5 +1231,5 @@ struct { /* The scalar value. */ - yaml_char_t *value; + const yaml_char_t *value; /* The scalar length. */ size_t length; Index: /libyaml/trunk/src/reader.c =================================================================== --- /libyaml/trunk/src/reader.c (revision 263) +++ /libyaml/trunk/src/reader.c (revision 264) @@ -36,5 +36,5 @@ /* Ensure that we had enough bytes in the raw buffer. */ - while (!parser->is_eof && parser->raw_input.capacity < 3) { + while (!parser->is_eof && parser->raw_input.length < 3) { if (!yaml_parser_update_raw_buffer(parser)) { return 0; @@ -44,5 +44,5 @@ /* Determine the encoding. */ - if (parser->raw_input.capacity >= 2 + if (parser->raw_input.length >= 2 && !memcmp(parser->raw_input.buffer, BOM_UTF16LE, 2)) { parser->encoding = YAML_UTF16LE_ENCODING; @@ -50,5 +50,5 @@ parser->offset = 2; } - else if (parser->raw_input.capacity >= 2 + else if (parser->raw_input.length >= 2 && !memcmp(parser->raw_input.buffer, BOM_UTF16BE, 2)) { parser->encoding = YAML_UTF16BE_ENCODING; @@ -56,5 +56,5 @@ parser->offset = 2; } - else if (parser->raw_input.capacity >= 3 + else if (parser->raw_input.length >= 3 && !memcmp(parser->raw_input.buffer, BOM_UTF8, 3)) { parser->encoding = YAML_UTF8_ENCODING; @@ -81,5 +81,5 @@ if (parser->raw_input.pointer == 0 && - parser->raw_input.capacity == RAW_INPUT_BUFFER_CAPACITY) + parser->raw_input.length == parser->raw_input.capacity) return 1; @@ -92,10 +92,10 @@ if (parser->raw_input.pointer > 0 && - parser->raw_input.pointer < parser->raw_input.capacity) { + parser->raw_input.pointer < parser->raw_input.length) { memmove(parser->raw_input.buffer, parser->raw_input.buffer + parser->raw_input.pointer, - parser->raw_input.capacity - parser->raw_input.pointer); - } - parser->raw_input.capacity -= parser->raw_input.pointer; + parser->raw_input.length - parser->raw_input.pointer); + } + parser->raw_input.length -= parser->raw_input.pointer; parser->raw_input.pointer = 0; @@ -103,10 +103,10 @@ if (!parser->reader(parser->reader_data, - parser->raw_input.buffer + parser->raw_input.capacity, - RAW_INPUT_BUFFER_CAPACITY - parser->raw_input.capacity, + parser->raw_input.buffer + parser->raw_input.length, + parser->raw_input.capacity - parser->raw_input.length, &length)) { - return READER_ERROR_INIT(parser, "Input error", parser->offset); - } - parser->raw_input.capacity += length; + return READER_ERROR_INIT(parser, "read handler error", parser->offset); + } + parser->raw_input.length += length; if (!length) { parser->is_eof = 1; @@ -126,11 +126,9 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length) { - size_t old_capacity; - assert(parser->reader); /* Read handler must be set. */ /* If the EOF flag is set and the raw buffer is empty, do nothing. */ - if (parser->is_eof && parser->raw_input.pointer == parser->raw_input.capacity) + if (parser->is_eof && parser->raw_input.pointer == parser->raw_input.length) return 1; @@ -150,17 +148,17 @@ if (parser->input.pointer > 0 && - parser->input.pointer < parser->input.capacity) { + parser->input.pointer < parser->input.length) { memmove(parser->input.buffer, parser->input.buffer + parser->input.pointer, - parser->input.capacity - parser->input.pointer); - parser->input.capacity -= parser->input.pointer; - } - else if (parser->input.pointer == parser->input.capacity) { - parser->input.capacity = 0; - } - - /* Set the pointer to the end of the buffer. */ - - parser->input.pointer = parser->input.capacity; + parser->input.length - parser->input.pointer); + parser->input.length -= parser->input.pointer; + } + else if (parser->input.pointer == parser->input.length) { + parser->input.length = 0; + } + + /* Switch the buffer to the output mode. */ + + parser->input.pointer = parser->input.length; /* Fill the buffer until it has enough characters. */ @@ -174,8 +172,8 @@ /* Decode the raw buffer. */ - while (parser->raw_input.pointer != parser->raw_input.capacity) + while (parser->raw_input.pointer < parser->raw_input.length) { size_t raw_unread = - parser->raw_input.capacity - parser->raw_input.pointer; + parser->raw_input.length - parser->raw_input.pointer; unsigned int value = 0, value2 = 0; int is_incomplete = 0; @@ -223,5 +221,5 @@ if (!width) return DECODER_ERROR_INIT(parser, - "Invalid leading UTF-8 octet", + "invalid leading UTF-8 octet", parser->offset, octet); @@ -231,5 +229,5 @@ if (parser->is_eof) { return DECODER_ERROR_INIT(parser, - "Incomplete UTF-8 octet sequence", + "incomplete UTF-8 octet sequence", parser->offset, -1); } @@ -255,5 +253,5 @@ if ((octet & 0xC0) != 0x80) return DECODER_ERROR_INIT(parser, - "Invalid trailing UTF-8 octet", + "invalid trailing UTF-8 octet", parser->offset+idx, octet); @@ -270,5 +268,5 @@ (width == 4 && value >= 0x10000))) return DECODER_ERROR_INIT(parser, - "Invalid length of a UTF-8 sequence", + "invalid length of a UTF-8 sequence", parser->offset, -1); @@ -277,5 +275,5 @@ if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) return DECODER_ERROR_INIT(parser, - "Invalid Unicode character", + "invalid Unicode character", parser->offset, value); @@ -319,5 +317,5 @@ if (parser->is_eof) { return DECODER_ERROR_INIT(parser, - "Incomplete UTF-16 character", + "incomplete UTF-16 character", parser->offset, -1); } @@ -335,5 +333,5 @@ if ((value & 0xFC00) == 0xDC00) return DECODER_ERROR_INIT(parser, - "Unexpected low surrogate area", + "unexpected low surrogate area", parser->offset, value); @@ -349,5 +347,5 @@ if (parser->is_eof) { return DECODER_ERROR_INIT(parser, - "Incomplete UTF-16 surrogate pair", + "incomplete UTF-16 surrogate pair", parser->offset, -1); } @@ -365,5 +363,5 @@ if ((value2 & 0xFC00) != 0xDC00) return DECODER_ERROR_INIT(parser, - "Expected low surrogate area", + "expected low surrogate area", parser->offset+2, value2); @@ -380,5 +378,5 @@ default: - assert(1); /* Impossible. */ + assert(0); /* Impossible. */ } @@ -401,5 +399,5 @@ || (value >= 0x10000 && value <= 0x10FFFF))) return DECODER_ERROR_INIT(parser, - "Control characters are not allowed", + "control characters are not allowed", parser->offset, value); @@ -446,9 +444,9 @@ } - /* Swap the pointer with the end of the buffer. */ - - old_capacity = parser->input.capacity; - parser->input.capacity = parser->input.pointer; - parser->input.pointer = old_capacity; + + /* Switch the the buffer back to the input mode. */ + + parser->input.length = parser->input.pointer; + parser->input.pointer = 0; return 1; Index: /libyaml/trunk/tests/run-scanner.c =================================================================== --- /libyaml/trunk/tests/run-scanner.c (revision 263) +++ /libyaml/trunk/tests/run-scanner.c (revision 264) @@ -24,7 +24,9 @@ yaml_parser_t *parser; yaml_token_t token; + yaml_error_t error; + char error_buffer[256]; int done = 0; int count = 0; - int error = 0; + int failed = 0; printf("[%d] Scanning '%s': ", number, argv[number]); @@ -40,6 +42,6 @@ while (!done) { - if (!yaml_parser_scan(parser, &token)) { - error = 1; + if (!yaml_parser_parse_token(parser, &token)) { + failed = 1; break; } @@ -52,9 +54,15 @@ } + yaml_parser_get_error(parser, &error); + yaml_parser_delete(parser); assert(!fclose(file)); - printf("%s (%d tokens)\n", (error ? "FAILURE" : "SUCCESS"), count); + yaml_error_message(&error, error_buffer, 256); + + printf("%s (%d tokens) -> %s\n", + (failed ? "FAILURE" : "SUCCESS"), + count, error_buffer); }