Changeset 264

Timestamp:

12/27/07 12:14:01 (5 years ago)

Author:

xi

Message:

Another round of API update.

Location:

libyaml/trunk

Files:

• configure.ac (modified) (3 diffs)
• include/yaml.h (modified) (16 diffs)
• src/api.c (modified) (13 diffs)
• src/emitter.c (modified) (43 diffs)
• src/parser.c (modified) (7 diffs)
• src/reader.c (modified) (22 diffs)
• src/scanner.c (modified) (33 diffs)
• src/writer.c (modified) (5 diffs)
• src/yaml_private.h (modified) (40 diffs)
• tests/run-scanner.c (modified) (3 diffs)

libyaml/trunk/configure.ac

@@ -3 +3 @@
 # 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 +19 @@
 #           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 +29 @@
 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.

libyaml/trunk/include/yaml.h

@@ -46 +46 @@
  */
 
-/**
- * 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 +73 @@
 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 +104 @@
     /** Cannot decode the input stream. */
     YAML_DECODER_ERROR,
-
     /** Cannot scan a YAML token. */
     YAML_SCANNER_ERROR,
@@ -97 +113 @@
     /** 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 +161 @@
          */
         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 +167 @@
             /** 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 +189 @@
         } 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 +470 @@
 
 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 +644 @@
 
 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 +828 @@
 
 /** 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 +1264 @@
  */
 
-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 +1436 @@
 
 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 +1460 @@
 
 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 +1487 @@
 
 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 +1685 @@
 
 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 +1732 @@
 
 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

libyaml/trunk/src/api.c

@@ -68 +68 @@
 
 /*
+ * 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 +196 @@
 
 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 +204 @@
 
     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 +278 @@
 
     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 +312 @@
     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 +355 @@
     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 +399 @@
     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 +463 @@
 
     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 +493 @@
     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 +530 @@
 
 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 +552 @@
 
 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 +722 @@
 
 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 +915 @@
 
 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 {

libyaml/trunk/src/emitter.c

@@ -14 +14 @@
  */
 
-#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 +41 @@
  */
 
-#define WRITE(emitter,string)                                                   \
+#define WRITE(emitter, string)                                                  \
     (FLUSH(emitter)                                                             \
-     && (COPY(emitter->output,string),                                          \
+     && (COPY(emitter->output, string),                                         \
          emitter->column ++,                                                    \
          1))
@@ -51 +51 @@
  */
 
-#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 +67 @@
 
 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 +219 @@
 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 +263 @@
 
 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 +468 @@
 
         default:
-            assert(1);      /* Invalid state. */
+            assert(0);      /* Invalid state. */
     }
 
@@ -1287 +1287 @@
 
         default:
-            assert(1);      /* Impossible. */
+            assert(0);      /* Impossible. */
     }
 
@@ -1316 +1316 @@
         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 +1329 @@
     }
 
-    if (handle.buffer[handle.capacity-1] != '!') {
+    if (handle.buffer[handle.length-1] != '!') {
         return EMITTER_ERROR_INIT(emitter, "tag handle must end with '!'");
     }
@@ -1335 +1335 @@
     handle.pointer ++;
 
-    while (handle.pointer < handle.capacity-1) {
+    while (handle.pointer < handle.length-1) {
         if (!IS_ALPHA(handle)) {
             return EMITTER_ERROR_INIT(emitter,
@@ -1343 +1343 @@
     }
 
-    if (!prefix.capacity) {
+    if (!prefix.length) {
         return EMITTER_ERROR_INIT(emitter, "tag prefix must not be empty");
     }
@@ -1358 +1358 @@
         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 +1366 @@
     }
 
-    while (string.pointer < string.capacity) {
+    while (string.pointer < string.length) {
         if (!IS_ALPHA(string)) {
             return EMITTER_ERROR_INIT(emitter, is_alias ?
@@ -1376 +1376 @@
 
     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 +1390 @@
         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 +1409 @@
                 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 +1415 @@
 
     emitter->tag_data.suffix = string.buffer;
-    emitter->tag_data.suffix_length = string.capacity;
+    emitter->tag_data.suffix_length = string.length;
 
     return 1;
@@ -1427 +1428 @@
         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 +1454 @@
     emitter->scalar_data.length = length;
 
-    if (!string.capacity)
+    if (!string.length)
     {
         emitter->scalar_data.is_multiline = 0;
@@ -1477 +1478 @@
     followed_by_space = IS_BLANKZ_AT(string, WIDTH(string));
 
-    while (string.pointer < string.capacity)
+    while (string.pointer < string.length)
     {
         if (!string.pointer)
@@ -1584 +1585 @@
         }
 
-        if ((spaces || breaks) && string.pointer == string.capacity-1)
+        if ((spaces || breaks) && string.pointer == string.length-1)
         {
             if (spaces && breaks) {
@@ -1605 +1606 @@
         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 +1771 @@
 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 +1780 @@
     }
 
-    while (string.pointer < string.capacity) {
+    while (string.pointer < string.length) {
         if (!WRITE(emitter, string)) return 0;
     }
@@ -1791 +1792 @@
 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 +1808 @@
 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 +1816 @@
     }
 
-    while (string.pointer < string.capacity) {
+    while (string.pointer < string.length) {
         if (!WRITE(emitter, string)) return 0;
     }
@@ -1827 +1828 @@
 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 +1837 @@
     }
 
-    while (string.pointer < string.capacity) {
+    while (string.pointer < string.length) {
         if (IS_ALPHA(string)
                 || CHECK(string, ';') || CHECK(string, '/')
@@ -1875 +1876 @@
 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 +1886 @@
     }
 
-    while (string.pointer < string.capacity)
+    while (string.pointer < string.length)
     {
         if (IS_SPACE(string))
@@ -1929 +1930 @@
 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 +1939 @@
         return 0;
 
-    while (string.pointer < string.capacity)
+    while (string.pointer < string.length)
     {
         if (IS_SPACE(string))
@@ -1944 +1945 @@
             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 +1990 @@
 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 +1998 @@
         return 0;
 
-    while (string.pointer < string.capacity)
+    while (string.pointer < string.length)
     {
         if (!IS_PRINTABLE(string) || (!emitter->is_unicode && !IS_ASCII(string))
@@ -2113 +2113 @@
             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 +2144 @@
 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 +2167 @@
 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 +2179 @@
         return 0;
 
-    while (string.pointer < string.capacity)
+    while (string.pointer < string.length)
     {
         if (IS_BREAK(string))
@@ -2203 +2203 @@
 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 +2216 @@
         return 0;
 
-    while (string.pointer < string.capacity)
+    while (string.pointer < string.length)
     {
         if (IS_BREAK(string))

libyaml/trunk/src/parser.c

@@ -48 +48 @@
 #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 +58 @@
      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 +66 @@
 
 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 +156 @@
 
 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 +256 @@
 
         default:
-            assert(1);      /* Invalid state. */
+            assert(0);      /* Invalid state. */
     }
 
@@ -563 +563 @@
                 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 +1312 @@
 
     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)

libyaml/trunk/src/reader.c

@@ -36 +36 @@
     /* 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 +44 @@
     /* 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 +50 @@
         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 +56 @@
         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 +81 @@
 
     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 +92 @@
 
     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 +103 @@
 
     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 +126 @@
 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 +148 @@
 
     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 +172 @@
         /* 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 +221 @@
                     if (!width)
                         return DECODER_ERROR_INIT(parser,
-                                "Invalid leading UTF-8 octet",
+                                "invalid leading UTF-8 octet",
                                 parser->offset, octet);
 
@@ -231 +229 @@
                         if (parser->is_eof) {
                             return DECODER_ERROR_INIT(parser,
-                                    "Incomplete UTF-8 octet sequence",
+                                    "incomplete UTF-8 octet sequence",
                                     parser->offset, -1);
                         }
@@ -255 +253 @@
                         if ((octet & 0xC0) != 0x80)
                             return DECODER_ERROR_INIT(parser,
-                                    "Invalid trailing UTF-8 octet",
+                                    "invalid trailing UTF-8 octet",
                                     parser->offset+idx, octet);
 
@@ -270 +268 @@
                             (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 +275 @@
                     if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF)
                         return DECODER_ERROR_INIT(parser,
-                                "Invalid Unicode character",
+                                "invalid Unicode character",
                                 parser->offset, value);
 
@@ -319 +317 @@
                         if (parser->is_eof) {
                             return DECODER_ERROR_INIT(parser,
-                                    "Incomplete UTF-16 character",
+                                    "incomplete UTF-16 character",
                                     parser->offset, -1);
                         }
@@ -335 +333 @@
                     if ((value & 0xFC00) == 0xDC00)
                         return DECODER_ERROR_INIT(parser,
-                                "Unexpected low surrogate area",
+                                "unexpected low surrogate area",
                                 parser->offset, value);
 
@@ -349 +347 @@
                             if (parser->is_eof) {
                                 return DECODER_ERROR_INIT(parser,
-                                        "Incomplete UTF-16 surrogate pair",
+                                        "incomplete UTF-16 surrogate pair",
                                         parser->offset, -1);
                             }
@@ -365 +363 @@
                         if ((value2 & 0xFC00) != 0xDC00)
                             return DECODER_ERROR_INIT(parser,
-                                    "Expected low surrogate area",
+                                    "expected low surrogate area",
                                     parser->offset+2, value2);
 
@@ -380 +378 @@
 
                 default:
-                    assert(1);      /* Impossible. */
+                    assert(0);      /* Impossible. */
             }
 
@@ -401 +399 @@
                         || (value >= 0x10000 && value <= 0x10FFFF)))
                 return DECODER_ERROR_INIT(parser,
-                        "Control characters are not allowed",
+                        "control characters are not allowed",
                         parser->offset, value);
 
@@ -446 +444 @@
 
     }
-    /* 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;

libyaml/trunk/src/scanner.c

@@ -516 +516 @@
  */
 
-#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 +528 @@
  */
 
-#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 +538 @@
       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 +546 @@
       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 +554 @@
       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 +572 @@
 
 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 +709 @@
 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 +717 @@
 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 +732 @@
 
 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 +2093 @@
         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 +2131 @@
 
 error:
-    STRING_DEL(parser, string);
+    OSTRING_DEL(parser, string);
     return 0;
 }
@@ -2312 +2312 @@
     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 +2367 @@
 
 error:
-    STRING_DEL(parser, string);
+    OSTRING_DEL(parser, string);
     return 0;
 }
@@ -2496 +2496 @@
         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 +2554 @@
 
 error:
-    STRING_DEL(parser, string);
+    OSTRING_DEL(parser, string);
     return 0;
 }
@@ -2567 +2567 @@
 {
     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 +2575 @@
 
     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 +2633 @@
 
     if (!length) {
-        if (!STRING_EXTEND(parser, string))
+        if (!OSTRING_EXTEND(parser, string))
             goto error;
 
@@ -2647 +2647 @@
 
 error:
-    STRING_DEL(parser, string);
+    OSTRING_DEL(parser, string);
     return 0;
 }
@@ -2657 +2657 @@
 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 +2731 @@
     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 +2740 @@
     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 +2881 @@
 
             if (*trailing_breaks.buffer == '\0') {
-                if (!STRING_EXTEND(parser, string)) goto error;
+                if (!OSTRING_EXTEND(parser, string)) goto error;
                 JOIN_OCTET(string, ' ');
             }
@@ -2935 +2935 @@
             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 +2955 @@
 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 +3023 @@
     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 +3089 @@
                     && 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 +3120 @@
                 size_t code_length = 0;
 
-                if (!STRING_EXTEND(parser, string)) goto error;
+                if (!OSTRING_EXTEND(parser, string)) goto error;
 
                 /* Check the escape character. */
@@ -3342 +3342 @@
             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 +3377 @@
             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 +3401 @@
     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 +3476 @@
                     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 +3580 @@
     }
 
-    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;

libyaml/trunk/src/writer.c

@@ -28 +28 @@
     }
 
-    /* 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 +38 @@
     {
         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 +54 @@
     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 +115 @@
                 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 +121 @@
     }
     else {
-        return WRITER_ERROR_INIT(emitter, "Write error", emitter->offset);
+        return WRITER_ERROR_INIT(emitter,
+                "write handler error", emitter->offset);
     }
 }

libyaml/trunk/src/yaml_private.h

@@ -29 +29 @@
  */
 
-#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 +171 @@
  */
 
-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 +281 @@
  */
 
-#define OCTET_AT(string,offset)                                                 \
+#define OCTET_AT(string, offset)                                                \
     ((string).buffer[(string).pointer+(offset)])
 
@@ -220 +288 @@
  */
 
-#define OCTET(string)   OCTET_AT((string),0)
+#define OCTET(string)   OCTET_AT((string), 0)
 
 /*
@@ -226 +294 @@
  */
 
-#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 +301 @@
  */
 
-#define CHECK(string,octet) CHECK_AT((string),(octet),0)
+#define CHECK(string, octet)    CHECK_AT((string), (octet), 0)
 
 /*
@@ -240 +308 @@
  */
 
-#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 +324 @@
  */
 
-#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 +334 @@
  */
 
-#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 +343 @@
  */
 
-#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 +357 @@
  */
 
-#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 +372 @@
  */
 
-#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 +381 @@
  */
 
-#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 +405 @@
  */
 
-#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 +413 @@
  */
 
-#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 +424 @@
  */
 
-#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 +432 @@
  */
 
-#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 +440 @@
  */
 
-#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 +449 @@
  */
 
-#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 +472 @@
  */
 
-#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 +481 @@
  */
 
-#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 +490 @@
  */
 
-#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 +499 @@
  */
 
-#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 +517 @@
  */
 
-#define JOIN_OCTET(string,octet)                                                \
+#define JOIN_OCTET(string, octet)                                               \
     ((string).buffer[(string).pointer++] = (octet))
 
@@ -456 +524 @@
  */
 
-#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 +532 @@
  */
 
-#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 +559 @@
         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 +587 @@
          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 +618 @@
          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 +638 @@
  */
 
-#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 +684 @@
  */
 
-#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 +803 @@
      (node).data.mapping.pairs.top = (node_pairs_start),                        \
      (node).data.mapping.style = (node_style))
+
+#endif
 
 /*
@@ -818 +895 @@
 typedef union yaml_standard_reader_data_u {
     /* String input data. */
-    yaml_string_t string;
+    yaml_istring_t string;
     /* File input data. */
     FILE *file;
@@ -852 +929 @@
 
     /* 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 +935 @@
 
     /* 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 +1092 @@
 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 +1124 @@
 
     /* 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 +1209 @@
     struct {
         /* The anchor value. */
-        yaml_char_t *anchor;
+        const yaml_char_t *anchor;
         /* The anchor length. */
         size_t anchor_length;
@@ -1158 +1219 @@
     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 +1231 @@
     struct {
         /* The scalar value. */
-        yaml_char_t *value;
+        const yaml_char_t *value;
         /* The scalar length. */
         size_t length;

libyaml/trunk/tests/run-scanner.c

@@ -24 +24 @@
         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 +42 @@
         while (!done)
         {
-            if (!yaml_parser_scan(parser, &token)) {
-                error = 1;
+            if (!yaml_parser_parse_token(parser, &token)) {
+                failed = 1;
                 break;
             }
@@ -52 +54 @@
         }
 
+        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);
     }