Changeset 263

Timestamp:

12/27/07 07:05:17 (5 years ago)

Author:

xi

Message:

Completed the first phase of API refactoring.

Location:

libyaml/trunk

Files:

• src/api.c (modified) (4 diffs)
• src/dumper.c (modified) (2 diffs)
• src/emitter.c (modified) (91 diffs)
• src/loader.c (modified) (2 diffs)
• src/parser.c (modified) (30 diffs)
• src/reader.c (modified) (18 diffs)
• src/scanner.c (modified) (131 diffs)
• src/writer.c (modified) (9 diffs)
• src/yaml_private.h (modified) (10 diffs)
• tests/run-scanner.c (modified) (3 diffs)

libyaml/trunk/src/api.c

@@ -173 +173 @@
 
     memset(parser, 0, sizeof(yaml_parser_t));
-    if (!BUFFER_INIT(parser, parser->raw_input, RAW_INPUT_BUFFER_CAPACITY))
+    if (!STRING_INIT(parser, parser->raw_input, RAW_INPUT_BUFFER_CAPACITY))
         goto error;
-    if (!BUFFER_INIT(parser, parser->input, INPUT_BUFFER_CAPACITY))
+    if (!STRING_INIT(parser, parser->input, INPUT_BUFFER_CAPACITY))
         goto error;
     if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_CAPACITY))
@@ -207 +207 @@
     assert(parser); /* Non-NULL parser object expected. */
 
-    BUFFER_DEL(parser, parser->raw_input);
-    BUFFER_DEL(parser, parser->input);
+    STRING_DEL(parser, parser->raw_input);
+    STRING_DEL(parser, parser->input);
     while (!QUEUE_EMPTY(parser, parser->tokens)) {
         yaml_token_destroy(&DEQUEUE(parser, parser->tokens));
@@ -358 +358 @@
 
     memset(emitter, 0, sizeof(yaml_emitter_t));
-    if (!BUFFER_INIT(emitter, emitter->output, OUTPUT_BUFFER_CAPACITY))
+    if (!STRING_INIT(emitter, emitter->output, OUTPUT_BUFFER_CAPACITY))
         goto error;
-    if (!BUFFER_INIT(emitter, emitter->raw_output, RAW_OUTPUT_BUFFER_CAPACITY))
+    if (!STRING_INIT(emitter, emitter->raw_output, RAW_OUTPUT_BUFFER_CAPACITY))
         goto error;
     if (!STACK_INIT(emitter, emitter->states, INITIAL_STACK_CAPACITY))
@@ -388 +388 @@
     assert(emitter);    /* Non-NULL emitter object expected. */
 
-    BUFFER_DEL(emitter, emitter->output);
-    BUFFER_DEL(emitter, emitter->raw_output);
+    STRING_DEL(emitter, emitter->output);
+    STRING_DEL(emitter, emitter->raw_output);
     STACK_DEL(emitter, emitter->states);
     while (!QUEUE_EMPTY(emitter, emitter->events)) {

libyaml/trunk/src/dumper.c

@@ -1 +1 @@
 
 #include "yaml_private.h"
+
+#if 0
 
 /*
@@ -393 +395 @@
 }
 
+#endif
+

libyaml/trunk/src/emitter.c

@@ -7 +7 @@
 
 #define FLUSH(emitter)                                                          \
-    ((emitter->buffer.pointer+5 < emitter->buffer.end)                          \
+    ((emitter->output.pointer+5 < emitter->output.capacity)                     \
      || yaml_emitter_flush(emitter))
 
@@ -16 +16 @@
 #define PUT(emitter,value)                                                      \
     (FLUSH(emitter)                                                             \
-     && (*(emitter->buffer.pointer++) = (yaml_char_t)(value),                   \
+     && (JOIN_OCTET(emitter->output,(yaml_char_t)(value)),                      \
          emitter->column ++,                                                    \
          1))
@@ -27 +27 @@
     (FLUSH(emitter)                                                             \
      && ((emitter->line_break == YAML_CR_BREAK ?                                \
-             (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') :              \
+             JOIN_OCTET(emitter->output, (yaml_char_t) '\r') :                  \
           emitter->line_break == YAML_LN_BREAK ?                                \
-             (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') :              \
+             JOIN_OCTET(emitter->output, (yaml_char_t) '\n') :                  \
           emitter->line_break == YAML_CRLN_BREAK ?                              \
-             (*(emitter->buffer.pointer++) = (yaml_char_t) '\r',                \
-              *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0),          \
+             (JOIN_OCTET(emitter->output, (yaml_char_t) '\r'),                  \
+              JOIN_OCTET(emitter->output, (yaml_char_t) '\n')) : 0),            \
          emitter->column = 0,                                                   \
          emitter->line ++,                                                      \
@@ -43 +43 @@
 #define WRITE(emitter,string)                                                   \
     (FLUSH(emitter)                                                             \
-     && (COPY(emitter->buffer,string),                                          \
+     && (COPY(emitter->output,string),                                          \
          emitter->column ++,                                                    \
          1))
@@ -57 +57 @@
           string.pointer ++,                                                    \
           1) :                                                                  \
-         (COPY(emitter->buffer,string),                                         \
+         (COPY(emitter->output,string),                                         \
           emitter->column = 0,                                                  \
           emitter->line ++,                                                     \
@@ -74 +74 @@
 
 static int
-yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem);
-
-static int
 yaml_emitter_need_more_events(yaml_emitter_t *emitter);
 
@@ -136 +133 @@
 static int
 yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
-        int root, int sequence, int mapping, int simple_key);
+        int is_root, int is_sequence, int is_mapping, int is_simple_key);
 
 static int
@@ -262 +259 @@
 
 /*
- * Set an emitter error and return 0.
- */
-
-static int
-yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem)
-{
-    emitter->error = YAML_EMITTER_ERROR;
-    emitter->problem = problem;
-
-    return 0;
-}
-
-/*
  * Emit an event.
  */
@@ -287 +271 @@
 
     while (!yaml_emitter_need_more_events(emitter)) {
-        if (!yaml_emitter_analyze_event(emitter, emitter->events.head))
-            return 0;
-        if (!yaml_emitter_state_machine(emitter, emitter->events.head))
+        if (!yaml_emitter_analyze_event(emitter,
+                    emitter->events.list + emitter->events.head))
+            return 0;
+        if (!yaml_emitter_state_machine(emitter,
+                    emitter->events.list + emitter->events.head))
             return 0;
         yaml_event_delete(&DEQUEUE(emitter, emitter->events));
@@ -311 +297 @@
     int level = 0;
     int accumulate = 0;
-    yaml_event_t *event;
+    size_t idx;
 
     if (QUEUE_EMPTY(emitter, emitter->events))
         return 1;
 
-    switch (emitter->events.head->type) {
+    switch (emitter->events.list[emitter->events.head].type) {
         case YAML_DOCUMENT_START_EVENT:
             accumulate = 1;
@@ -333 +319 @@
         return 0;
 
-    for (event = emitter->events.head; event != emitter->events.tail; event ++) {
+    for (idx = emitter->events.head; idx < emitter->events.tail; idx ++) {
+        yaml_event_t *event = emitter->events.list+idx;
         switch (event->type) {
             case YAML_STREAM_START_EVENT:
@@ -365 +352 @@
         yaml_tag_directive_t value, int allow_duplicates)
 {
-    yaml_tag_directive_t *tag_directive;
+    int idx;
     yaml_tag_directive_t copy = { NULL, NULL };
 
-    for (tag_directive = emitter->tag_directives.start;
-            tag_directive != emitter->tag_directives.top; tag_directive ++) {
+    for (idx = 0; idx < emitter->tag_directives.length; idx ++) {
+        yaml_tag_directive_t *tag_directive = emitter->tag_directives.list+idx;
         if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
             if (allow_duplicates)
                 return 1;
-            return yaml_emitter_set_emitter_error(emitter,
-                    "duplicate %TAG directive");
+            return EMITTER_ERROR_INIT(emitter, "duplicate %TAG directive");
         }
     }
@@ -381 +367 @@
     copy.prefix = yaml_strdup(value.prefix);
     if (!copy.handle || !copy.prefix) {
-        emitter->error = YAML_MEMORY_ERROR;
+        MEMORY_ERROR_INIT(emitter);
         goto error;
     }
@@ -478 +464 @@
 
         case YAML_EMIT_END_STATE:
-            return yaml_emitter_set_emitter_error(emitter,
+            return EMITTER_ERROR_INIT(emitter,
                     "expected nothing after STREAM-END");
 
@@ -527 +513 @@
         emitter->line = 0;
         emitter->column = 0;
-        emitter->whitespace = 1;
-        emitter->indention = 1;
+        emitter->is_whitespace = 1;
+        emitter->is_indention = 1;
 
         if (emitter->encoding != YAML_UTF8_ENCODING) {
@@ -540 +526 @@
     }
 
-    return yaml_emitter_set_emitter_error(emitter,
-            "expected STREAM-START");
+    return EMITTER_ERROR_INIT(emitter, "expected STREAM-START");
 }
 
@@ -560 +545 @@
         };
         yaml_tag_directive_t *tag_directive;
-        int implicit;
+        int is_implicit;
+        int idx;
 
         if (event->data.document_start.version_directive) {
@@ -568 +554 @@
         }
 
-        for (tag_directive = event->data.document_start.tag_directives.start;
-                tag_directive != event->data.document_start.tag_directives.end;
-                tag_directive ++) {
+        for (idx = 0; idx < event->data.document_start.tag_directives.length; idx++) {
+            tag_directive = event->data.document_start.tag_directives.list+idx;
             if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive))
                 return 0;
@@ -583 +568 @@
         }
 
-        implicit = event->data.document_start.implicit;
-        if (!first || emitter->canonical) {
-            implicit = 0;
+        is_implicit = event->data.document_start.is_implicit;
+        if (!first || emitter->is_canonical) {
+            is_implicit = 0;
         }
 
         if (event->data.document_start.version_directive) {
-            implicit = 0;
+            is_implicit = 0;
             if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0))
                 return 0;
@@ -598 +583 @@
         }
         
-        if (event->data.document_start.tag_directives.start
-                != event->data.document_start.tag_directives.end) {
-            implicit = 0;
-            for (tag_directive = event->data.document_start.tag_directives.start;
-                    tag_directive != event->data.document_start.tag_directives.end;
-                    tag_directive ++) {
+        if (event->data.document_start.tag_directives.length) {
+            is_implicit = 0;
+            for (idx = 0; idx < event->data.document_start.tag_directives.length;
+                    idx++) {
+                tag_directive = event->data.document_start.tag_directives.list+idx;
                 if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0))
                     return 0;
@@ -618 +602 @@
 
         if (yaml_emitter_check_empty_document(emitter)) {
-            implicit = 0;
-        }
-
-        if (!implicit) {
+            is_implicit = 0;
+        }
+
+        if (!is_implicit) {
             if (!yaml_emitter_write_indent(emitter))
                 return 0;
             if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0))
                 return 0;
-            if (emitter->canonical) {
+            if (emitter->is_canonical) {
                 if (!yaml_emitter_write_indent(emitter))
                     return 0;
@@ -647 +631 @@
     }
 
-    return yaml_emitter_set_emitter_error(emitter,
-            "expected DOCUMENT-START or STREAM-END");
+    return EMITTER_ERROR_INIT(emitter, "expected DOCUMENT-START or STREAM-END");
 }
 
@@ -677 +660 @@
         if (!yaml_emitter_write_indent(emitter))
             return 0;
-        if (!event->data.document_end.implicit) {
+        if (!event->data.document_end.is_implicit) {
             if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
                 return 0;
@@ -698 +681 @@
     }
 
-    return yaml_emitter_set_emitter_error(emitter,
-            "expected DOCUMENT-END");
+    return EMITTER_ERROR_INIT(emitter, "expected DOCUMENT-END");
 }
 
@@ -724 +706 @@
         emitter->flow_level --;
         emitter->indent = POP(emitter, emitter->indents);
-        if (emitter->canonical && !first) {
+        if (emitter->is_canonical && !first) {
             if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
                 return 0;
@@ -742 +724 @@
     }
 
-    if (emitter->canonical || emitter->column > emitter->best_width) {
+    if (emitter->is_canonical || emitter->column > emitter->best_width) {
         if (!yaml_emitter_write_indent(emitter))
             return 0;
@@ -773 +755 @@
         emitter->flow_level --;
         emitter->indent = POP(emitter, emitter->indents);
-        if (emitter->canonical && !first) {
+        if (emitter->is_canonical && !first) {
             if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
                 return 0;
@@ -790 +772 @@
             return 0;
     }
-    if (emitter->canonical || emitter->column > emitter->best_width) {
+    if (emitter->is_canonical || emitter->column > emitter->best_width) {
         if (!yaml_emitter_write_indent(emitter))
             return 0;
     }
 
-    if (!emitter->canonical && yaml_emitter_check_simple_key(emitter))
+    if (!emitter->is_canonical && yaml_emitter_check_simple_key(emitter))
     {
         if (!PUSH(emitter, emitter->states,
@@ -828 +810 @@
     }
     else {
-        if (emitter->canonical || emitter->column > emitter->best_width) {
+        if (emitter->is_canonical || emitter->column > emitter->best_width) {
             if (!yaml_emitter_write_indent(emitter))
                 return 0;
@@ -851 +833 @@
     {
         if (!yaml_emitter_increase_indent(emitter, 0,
-                    (emitter->mapping_context && !emitter->indention)))
+                    (emitter->is_mapping_context && !emitter->is_indention)))
             return 0;
     }
@@ -950 +932 @@
 static int
 yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
-        int root, int sequence, int mapping, int simple_key)
-{
-    emitter->root_context = root;
-    emitter->sequence_context = sequence;
-    emitter->mapping_context = mapping;
-    emitter->simple_key_context = simple_key;
+        int is_root, int is_sequence, int is_mapping, int is_simple_key)
+{
+    emitter->is_root_context = is_root;
+    emitter->is_sequence_context = is_sequence;
+    emitter->is_mapping_context = is_mapping;
+    emitter->is_simple_key_context = is_simple_key;
 
     switch (event->type)
@@ -972 +954 @@
 
         default:
-            return yaml_emitter_set_emitter_error(emitter,
+            return EMITTER_ERROR_INIT(emitter,
                     "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS");
     }
@@ -1028 +1010 @@
         return 0;
 
-    if (emitter->flow_level || emitter->canonical
+    if (emitter->flow_level || emitter->is_canonical
             || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE
             || yaml_emitter_check_empty_sequence(emitter)) {
@@ -1052 +1034 @@
         return 0;
 
-    if (emitter->flow_level || emitter->canonical
+    if (emitter->flow_level || emitter->is_canonical
             || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE
             || yaml_emitter_check_empty_mapping(emitter)) {
@@ -1084 +1066 @@
         return 0;
 
-    return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT
-            && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT);
+    return (emitter->events.list[emitter->events.head].type
+                            == YAML_SEQUENCE_START_EVENT &&
+            emitter->events.list[emitter->events.head+1].type
+                            == YAML_SEQUENCE_END_EVENT);
 }
 
@@ -1098 +1082 @@
         return 0;
 
-    return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT
-            && emitter->events.head[1].type == YAML_MAPPING_END_EVENT);
+    return (emitter->events.list[emitter->events.head].type
+                            == YAML_MAPPING_START_EVENT &&
+            emitter->events.list[emitter->events.head+1].type
+                            == YAML_MAPPING_END_EVENT);
 }
 
@@ -1109 +1095 @@
 yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
 {
-    yaml_event_t *event = emitter->events.head;
+    yaml_event_t *event = emitter->events.list + emitter->events.head;
     size_t length = 0;
 
@@ -1119 +1105 @@
 
         case YAML_SCALAR_EVENT:
-            if (emitter->scalar_data.multiline)
+            if (emitter->scalar_data.is_multiline)
                 return 0;
             length += emitter->anchor_data.anchor_length
@@ -1163 +1149 @@
     int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix);
 
-    if (no_tag && !event->data.scalar.plain_implicit
-            && !event->data.scalar.quoted_implicit) {
-        return yaml_emitter_set_emitter_error(emitter,
+    if (no_tag && !event->data.scalar.is_plain_implicit
+            && !event->data.scalar.is_quoted_implicit) {
+        return EMITTER_ERROR_INIT(emitter,
                 "neither tag nor implicit flags are specified");
     }
@@ -1172 +1158 @@
         style = YAML_PLAIN_SCALAR_STYLE;
 
-    if (emitter->canonical)
+    if (emitter->is_canonical)
         style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
 
-    if (emitter->simple_key_context && emitter->scalar_data.multiline)
+    if (emitter->is_simple_key_context && emitter->scalar_data.is_multiline)
         style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
 
     if (style == YAML_PLAIN_SCALAR_STYLE)
     {
-        if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed)
-                || (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed))
+        if ((emitter->flow_level && !emitter->scalar_data.is_flow_plain_allowed)
+                || (!emitter->flow_level && !emitter->scalar_data.is_block_plain_allowed))
             style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
         if (!emitter->scalar_data.length
-                && (emitter->flow_level || emitter->simple_key_context))
+                && (emitter->flow_level || emitter->is_simple_key_context))
             style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
-        if (no_tag && !event->data.scalar.plain_implicit)
+        if (no_tag && !event->data.scalar.is_plain_implicit)
             style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
     }
@@ -1192 +1178 @@
     if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE)
     {
-        if (!emitter->scalar_data.single_quoted_allowed)
+        if (!emitter->scalar_data.is_single_quoted_allowed)
             style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
     }
@@ -1198 +1184 @@
     if (style == YAML_LITERAL_SCALAR_STYLE || style == YAML_FOLDED_SCALAR_STYLE)
     {
-        if (!emitter->scalar_data.block_allowed
-                || emitter->flow_level || emitter->simple_key_context)
+        if (!emitter->scalar_data.is_block_allowed
+                || emitter->flow_level || emitter->is_simple_key_context)
             style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
     }
 
-    if (no_tag && !event->data.scalar.quoted_implicit
+    if (no_tag && !event->data.scalar.is_quoted_implicit
             && style != YAML_PLAIN_SCALAR_STYLE)
     {
@@ -1226 +1212 @@
 
     if (!yaml_emitter_write_indicator(emitter,
-                (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0))
+                (emitter->anchor_data.is_alias ? "*" : "&"), 1, 0, 0))
         return 0;
 
@@ -1280 +1266 @@
             return yaml_emitter_write_plain_scalar(emitter,
                     emitter->scalar_data.value, emitter->scalar_data.length,
-                    !emitter->simple_key_context);
+                    !emitter->is_simple_key_context);
 
         case YAML_SINGLE_QUOTED_SCALAR_STYLE:
             return yaml_emitter_write_single_quoted_scalar(emitter,
                     emitter->scalar_data.value, emitter->scalar_data.length,
-                    !emitter->simple_key_context);
+                    !emitter->is_simple_key_context);
 
         case YAML_DOUBLE_QUOTED_SCALAR_STYLE:
             return yaml_emitter_write_double_quoted_scalar(emitter,
                     emitter->scalar_data.value, emitter->scalar_data.length,
-                    !emitter->simple_key_context);
+                    !emitter->is_simple_key_context);
 
         case YAML_LITERAL_SCALAR_STYLE:
@@ -1316 +1302 @@
 {
     if (version_directive.major != 1 || version_directive.minor != 1) {
-        return yaml_emitter_set_emitter_error(emitter,
-                "incompatible %YAML directive");
+        return EMITTER_ERROR_INIT(emitter, "incompatible %YAML directive");
     }
 
@@ -1336 +1321 @@
             strlen((char *)tag_directive.prefix));
 
-    if (handle.start == handle.end) {
-        return yaml_emitter_set_emitter_error(emitter,
-                "tag handle must not be empty");
-    }
-
-    if (handle.start[0] != '!') {
-        return yaml_emitter_set_emitter_error(emitter,
-                "tag handle must start with '!'");
-    }
-
-    if (handle.end[-1] != '!') {
-        return yaml_emitter_set_emitter_error(emitter,
-                "tag handle must end with '!'");
+    if (!handle.capacity) {
+        return EMITTER_ERROR_INIT(emitter, "tag handle must not be empty");
+    }
+
+    if (handle.buffer[0] != '!') {
+        return EMITTER_ERROR_INIT(emitter, "tag handle must start with '!'");
+    }
+
+    if (handle.buffer[handle.capacity-1] != '!') {
+        return EMITTER_ERROR_INIT(emitter, "tag handle must end with '!'");
     }
 
     handle.pointer ++;
 
-    while (handle.pointer < handle.end-1) {
+    while (handle.pointer < handle.capacity-1) {
         if (!IS_ALPHA(handle)) {
-            return yaml_emitter_set_emitter_error(emitter,
+            return EMITTER_ERROR_INIT(emitter,
                     "tag handle must contain alphanumerical characters only");
         }
@@ -1361 +1343 @@
     }
 
-    if (prefix.start == prefix.end) {
-        return yaml_emitter_set_emitter_error(emitter,
-                "tag prefix must not be empty");
+    if (!prefix.capacity) {
+        return EMITTER_ERROR_INIT(emitter, "tag prefix must not be empty");
     }
 
@@ -1375 +1356 @@
 static int
 yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
-        yaml_char_t *anchor, int alias)
+        yaml_char_t *anchor, int is_alias)
 {
     yaml_string_t string = STRING(anchor, strlen((char *)anchor));
 
-    if (string.start == string.end) {
-        return yaml_emitter_set_emitter_error(emitter, alias ?
+    if (!string.capacity) {
+        return EMITTER_ERROR_INIT(emitter, is_alias ?
                 "alias value must not be empty" :
                 "anchor value must not be empty");
     }
 
-    while (string.pointer != string.end) {
+    while (string.pointer < string.capacity) {
         if (!IS_ALPHA(string)) {
-            return yaml_emitter_set_emitter_error(emitter, alias ?
+            return EMITTER_ERROR_INIT(emitter, is_alias ?
                     "alias value must contain alphanumerical characters only" :
                     "anchor value must contain alphanumerical characters only");
@@ -1394 +1375 @@
     }
 
-    emitter->anchor_data.anchor = string.start;
-    emitter->anchor_data.anchor_length = string.end - string.start;
-    emitter->anchor_data.alias = alias;
+    emitter->anchor_data.anchor = string.buffer;
+    emitter->anchor_data.anchor_length = string.capacity;
+    emitter->anchor_data.is_alias = is_alias;
 
     return 1;
@@ -1410 +1391 @@
 {
     yaml_string_t string = STRING(tag, strlen((char *)tag));
-    yaml_tag_directive_t *tag_directive;
-
-    if (string.start == string.end) {
-        return yaml_emitter_set_emitter_error(emitter,
-                "tag value must not be empty");
-    }
-
-    for (tag_directive = emitter->tag_directives.start;
-            tag_directive != emitter->tag_directives.top; tag_directive ++) {
+    size_t idx;
+
+    if (!string.capacity) {
+        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;
         size_t prefix_length = strlen((char *)tag_directive->prefix);
-        if (prefix_length < (size_t)(string.end - string.start)
-                && strncmp((char *)tag_directive->prefix, (char *)string.start,
+        if (prefix_length < string.capacity
+                && strncmp((char *)tag_directive->prefix, (char *)string.buffer,
                     prefix_length) == 0)
         {
@@ -1427 +1407 @@
             emitter->tag_data.handle_length =
                 strlen((char *)tag_directive->handle);
-            emitter->tag_data.suffix = string.start + prefix_length;
-            emitter->tag_data.suffix_length =
-                (string.end - string.start) - prefix_length;
+            emitter->tag_data.suffix = string.buffer + prefix_length;
+            emitter->tag_data.suffix_length = string.capacity - prefix_length;
             return 1;
         }
     }
 
-    emitter->tag_data.suffix = string.start;
-    emitter->tag_data.suffix_length = string.end - string.start;
+    emitter->tag_data.suffix = string.buffer;
+    emitter->tag_data.suffix_length = string.capacity;
 
     return 1;
@@ -1474 +1453 @@
     emitter->scalar_data.length = length;
 
-    if (string.start == string.end)
-    {
-        emitter->scalar_data.multiline = 0;
-        emitter->scalar_data.flow_plain_allowed = 0;
-        emitter->scalar_data.block_plain_allowed = 1;
-        emitter->scalar_data.single_quoted_allowed = 1;
-        emitter->scalar_data.block_allowed = 0;
+    if (!string.capacity)
+    {
+        emitter->scalar_data.is_multiline = 0;
+        emitter->scalar_data.is_flow_plain_allowed = 0;
+        emitter->scalar_data.is_block_plain_allowed = 1;
+        emitter->scalar_data.is_single_quoted_allowed = 1;
+        emitter->scalar_data.is_block_allowed = 0;
 
         return 1;
@@ -1498 +1477 @@
     followed_by_space = IS_BLANKZ_AT(string, WIDTH(string));
 
-    while (string.pointer != string.end)
-    {
-        if (string.start == string.pointer)
+    while (string.pointer < string.capacity)
+    {
+        if (!string.pointer)
         {
             if (CHECK(string, '#') || CHECK(string, ',')
@@ -1548 +1527 @@
 
         if (!IS_PRINTABLE(string)
-                || (!IS_ASCII(string) && !emitter->unicode)) {
+                || (!IS_ASCII(string) && !emitter->is_unicode)) {
             special_characters = 1;
         }
@@ -1559 +1538 @@
         {
             spaces = 1;
-            if (string.start == string.pointer) {
+            if (!string.pointer) {
                 leading = 1;
             }
@@ -1570 +1549 @@
             }
             breaks = 1;
-            if (string.start == string.pointer) {
+            if (!string.pointer) {
                 leading = 1;
             }
@@ -1605 +1584 @@
         }
 
-        if ((spaces || breaks) && string.pointer == string.end-1)
+        if ((spaces || breaks) && string.pointer == string.capacity-1)
         {
             if (spaces && breaks) {
@@ -1626 +1605 @@
         preceeded_by_space = IS_BLANKZ(string);
         MOVE(string);
-        if (string.pointer != string.end) {
+        if (string.pointer < string.capacity) {
             followed_by_space = IS_BLANKZ_AT(string, WIDTH(string));
         }
     }
 
-    emitter->scalar_data.multiline = line_breaks;
-
-    emitter->scalar_data.flow_plain_allowed = 1;
-    emitter->scalar_data.block_plain_allowed = 1;
-    emitter->scalar_data.single_quoted_allowed = 1;
-    emitter->scalar_data.block_allowed = 1;
+    emitter->scalar_data.is_multiline = line_breaks;
+
+    emitter->scalar_data.is_flow_plain_allowed = 1;
+    emitter->scalar_data.is_block_plain_allowed = 1;
+    emitter->scalar_data.is_single_quoted_allowed = 1;
+    emitter->scalar_data.is_block_allowed = 1;
 
     if (leading_spaces || leading_breaks || trailing_spaces) {
-        emitter->scalar_data.flow_plain_allowed = 0;
-        emitter->scalar_data.block_plain_allowed = 0;
-        emitter->scalar_data.block_allowed = 0;
+        emitter->scalar_data.is_flow_plain_allowed = 0;
+        emitter->scalar_data.is_block_plain_allowed = 0;
+        emitter->scalar_data.is_block_allowed = 0;
     }
 
     if (trailing_breaks) {
-        emitter->scalar_data.flow_plain_allowed = 0;
-        emitter->scalar_data.block_plain_allowed = 0;
+        emitter->scalar_data.is_flow_plain_allowed = 0;
+        emitter->scalar_data.is_block_plain_allowed = 0;
     }
 
     if (inline_breaks_spaces) {
-        emitter->scalar_data.flow_plain_allowed = 0;
-        emitter->scalar_data.block_plain_allowed = 0;
-        emitter->scalar_data.single_quoted_allowed = 0;
+        emitter->scalar_data.is_flow_plain_allowed = 0;
+        emitter->scalar_data.is_block_plain_allowed = 0;
+        emitter->scalar_data.is_single_quoted_allowed = 0;
     }
 
     if (mixed_breaks_spaces || special_characters) {
-        emitter->scalar_data.flow_plain_allowed = 0;
-        emitter->scalar_data.block_plain_allowed = 0;
-        emitter->scalar_data.single_quoted_allowed = 0;
-        emitter->scalar_data.block_allowed = 0;
+        emitter->scalar_data.is_flow_plain_allowed = 0;
+        emitter->scalar_data.is_block_plain_allowed = 0;
+        emitter->scalar_data.is_single_quoted_allowed = 0;
+        emitter->scalar_data.is_block_allowed = 0;
     }
 
     if (line_breaks) {
-        emitter->scalar_data.flow_plain_allowed = 0;
-        emitter->scalar_data.block_plain_allowed = 0;
+        emitter->scalar_data.is_flow_plain_allowed = 0;
+        emitter->scalar_data.is_block_plain_allowed = 0;
     }
 
     if (flow_indicators) {
-        emitter->scalar_data.flow_plain_allowed = 0;
+        emitter->scalar_data.is_flow_plain_allowed = 0;
     }
 
     if (block_indicators) {
-        emitter->scalar_data.block_plain_allowed = 0;
+        emitter->scalar_data.is_block_plain_allowed = 0;
     }
 
@@ -1709 +1688 @@
                     return 0;
             }
-            if (event->data.scalar.tag && (emitter->canonical ||
-                        (!event->data.scalar.plain_implicit
-                         && !event->data.scalar.quoted_implicit))) {
+            if (event->data.scalar.tag && (emitter->is_canonical ||
+                        (!event->data.scalar.is_plain_implicit
+                         && !event->data.scalar.is_quoted_implicit))) {
                 if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag))
                     return 0;
@@ -1726 +1705 @@
                     return 0;
             }
-            if (event->data.sequence_start.tag && (emitter->canonical ||
-                        !event->data.sequence_start.implicit)) {
+            if (event->data.sequence_start.tag && (emitter->is_canonical ||
+                        !event->data.sequence_start.is_implicit)) {
                 if (!yaml_emitter_analyze_tag(emitter,
                             event->data.sequence_start.tag))
@@ -1740 +1719 @@
                     return 0;
             }
-            if (event->data.mapping_start.tag && (emitter->canonical ||
-                        !event->data.mapping_start.implicit)) {
+            if (event->data.mapping_start.tag && (emitter->is_canonical ||
+                        !event->data.mapping_start.is_implicit)) {
                 if (!yaml_emitter_analyze_tag(emitter,
                             event->data.mapping_start.tag))
@@ -1762 +1741 @@
     if (!FLUSH(emitter)) return 0;
 
-    *(emitter->buffer.pointer++) = (yaml_char_t) '\xEF';
-    *(emitter->buffer.pointer++) = (yaml_char_t) '\xBB';
-    *(emitter->buffer.pointer++) = (yaml_char_t) '\xBF';
+    JOIN_OCTET(emitter->output, (yaml_char_t) '\xEF');
+    JOIN_OCTET(emitter->output, (yaml_char_t) '\xBB');
+    JOIN_OCTET(emitter->output, (yaml_char_t) '\xBF');
 
     return 1;
@@ -1774 +1753 @@
     int indent = (emitter->indent >= 0) ? emitter->indent : 0;
 
-    if (!emitter->indention || emitter->column > indent
-            || (emitter->column == indent && !emitter->whitespace)) {
+    if (!emitter->is_indention || emitter->column > indent
+            || (emitter->column == indent && !emitter->is_whitespace)) {
         if (!PUT_BREAK(emitter)) return 0;
     }
@@ -1783 +1762 @@
     }
 
-    emitter->whitespace = 1;
-    emitter->indention = 1;
+    emitter->is_whitespace = 1;
+    emitter->is_indention = 1;
 
     return 1;
@@ -1796 +1775 @@
     yaml_string_t string = STRING((yaml_char_t *)indicator, strlen(indicator));
 
-    if (need_whitespace && !emitter->whitespace) {
+    if (need_whitespace && !emitter->is_whitespace) {
         if (!PUT(emitter, ' ')) return 0;
     }
 
-    while (string.pointer != string.end) {
+    while (string.pointer < string.capacity) {
         if (!WRITE(emitter, string)) return 0;
     }
 
-    emitter->whitespace = is_whitespace;
-    emitter->indention = (emitter->indention && is_indention);
+    emitter->is_whitespace = is_whitespace;
+    emitter->is_indention = (emitter->is_indention && is_indention);
 
     return 1;
@@ -1816 +1795 @@
     yaml_string_t string = STRING(value, length);
 
-    while (string.pointer != string.end) {
+    while (string.pointer < string.capacity) {
         if (!WRITE(emitter, string)) return 0;
     }
 
-    emitter->whitespace = 0;
-    emitter->indention = 0;
+    emitter->is_whitespace = 0;
+    emitter->is_indention = 0;
 
     return 1;
@@ -1832 +1811 @@
     yaml_string_t string = STRING(value, length);
 
-    if (!emitter->whitespace) {
+    if (!emitter->is_whitespace) {
         if (!PUT(emitter, ' ')) return 0;
     }
 
-    while (string.pointer != string.end) {
+    while (string.pointer < string.capacity) {
         if (!WRITE(emitter, string)) return 0;
     }
 
-    emitter->whitespace = 0;
-    emitter->indention = 0;
+    emitter->is_whitespace = 0;
+    emitter->is_indention = 0;
 
     return 1;
@@ -1853 +1832 @@
     yaml_string_t string = STRING(value, length);
 
-    if (need_whitespace && !emitter->whitespace) {
+    if (need_whitespace && !emitter->is_whitespace) {
         if (!PUT(emitter, ' ')) return 0;
     }
 
-    while (string.pointer != string.end) {
+    while (string.pointer < string.capacity) {
         if (IS_ALPHA(string)
                 || CHECK(string, ';') || CHECK(string, '/')
@@ -1875 +1854 @@
             unsigned int value;
             while (width --) {
-                value = *(string.pointer++);
+                value = OCTET(string);
+                string.pointer ++;
                 if (!PUT(emitter, '%')) return 0;
                 if (!PUT(emitter, (value >> 4)
@@ -1887 +1867 @@
     }
 
-    emitter->whitespace = 0;
-    emitter->indention = 0;
+    emitter->is_whitespace = 0;
+    emitter->is_indention = 0;
 
     return 1;
@@ -1901 +1881 @@
     int breaks = 0;
 
-    if (!emitter->whitespace) {
+    if (!emitter->is_whitespace) {
         if (!PUT(emitter, ' ')) return 0;
     }
 
-    while (string.pointer != string.end)
+    while (string.pointer < string.capacity)
     {
         if (IS_SPACE(string))
@@ -1926 +1906 @@
             }
             if (!WRITE_BREAK(emitter, string)) return 0;
-            emitter->indention = 1;
+            emitter->is_indention = 1;
             breaks = 1;
         }
@@ -1935 +1915 @@
             }
             if (!WRITE(emitter, string)) return 0;
-            emitter->indention = 0;
+            emitter->is_indention = 0;
             spaces = 0;
             breaks = 0;
@@ -1941 +1921 @@
     }
 
-    emitter->whitespace = 0;
-    emitter->indention = 0;
+    emitter->is_whitespace = 0;
+    emitter->is_indention = 0;
 
     return 1;
@@ -1958 +1938 @@
         return 0;
 
-    while (string.pointer != string.end)
+    while (string.pointer < string.capacity)
     {
         if (IS_SPACE(string))
@@ -1964 +1944 @@
             if (allow_breaks && !spaces
                     && emitter->column > emitter->best_width
-                    && string.pointer != string.start
-                    && string.pointer != string.end - 1
+                    && string.pointer != 0
+                    && string.pointer != string.capacity - 1
                     && !IS_SPACE_AT(string, 1)) {
                 if (!yaml_emitter_write_indent(emitter)) return 0;
@@ -1981 +1961 @@
             }
             if (!WRITE_BREAK(emitter, string)) return 0;
-            emitter->indention = 1;
+            emitter->is_indention = 1;
             breaks = 1;
         }
@@ -1993 +1973 @@
             }
             if (!WRITE(emitter, string)) return 0;
-            emitter->indention = 0;
+            emitter->is_indention = 0;
             spaces = 0;
             breaks = 0;
@@ -2002 +1982 @@
         return 0;
 
-    emitter->whitespace = 0;
-    emitter->indention = 0;
+    emitter->is_whitespace = 0;
+    emitter->is_indention = 0;
 
     return 1;
@@ -2018 +1998 @@
         return 0;
 
-    while (string.pointer != string.end)
-    {
-        if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string))
+    while (string.pointer < string.capacity)
+    {
+        if (!IS_PRINTABLE(string) || (!emitter->is_unicode && !IS_ASCII(string))
                 || IS_BOM(string) || IS_BREAK(string)
                 || CHECK(string, '"') || CHECK(string, '\\'))
@@ -2027 +2007 @@
             unsigned int width;
             unsigned int value;
-            int k;
-
-            octet = string.pointer[0];
+            int idx;
+
+            octet = OCTET(string);
             width = (octet & 0x80) == 0x00 ? 1 :
                     (octet & 0xE0) == 0xC0 ? 2 :
@@ -2038 +2018 @@
                     (octet & 0xF0) == 0xE0 ? octet & 0x0F :
                     (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
-            for (k = 1; k < (int)width; k ++) {
-                octet = string.pointer[k];
+            for (idx = 1; idx < width; idx ++) {
+                octet = OCTET_AT(string, idx);
                 value = (value << 6) + (octet & 0x3F);
             }
@@ -2121 +2101 @@
                         width = 8;
                     }
-                    for (k = (width-1)*4; k >= 0; k -= 4) {
-                        int digit = (value >> k) & 0x0F;
+                    for (idx = (width-1)*4; idx >= 0; idx -= 4) {
+                        int digit = (value >> idx) & 0x0F;
                         if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10)))
                             return 0;
@@ -2133 +2113 @@
             if (allow_breaks && !spaces
                     && emitter->column > emitter->best_width
-                    && string.pointer != string.start
-                    && string.pointer != string.end - 1) {
+                    && string.pointer != 0
+                    && string.pointer != string.capacity - 1) {
                 if (!yaml_emitter_write_indent(emitter)) return 0;
                 if (IS_SPACE_AT(string, 1)) {
@@ -2156 +2136 @@
         return 0;
 
-    emitter->whitespace = 0;
-    emitter->indention = 0;
+    emitter->is_whitespace = 0;
+    emitter->is_indention = 0;
 
     return 1;
@@ -2166 +2146 @@
         yaml_string_t string)
 {
-    string.pointer = string.end;
-    if (string.start == string.pointer)
+    string.pointer = string.capacity;
+    if (!string.pointer)
         return -1;
     do {
         string.pointer --;
-    } while ((*string.pointer & 0xC0) == 0x80);
+    } while ((OCTET(string) & 0xC0) == 0x80);
     if (!IS_BREAK(string))
         return -1;
-    if (string.start == string.pointer)
+    if (!string.pointer)
         return 0;
     do {
         string.pointer --;
-    } while ((*string.pointer & 0xC0) == 0x80);
+    } while ((OCTET(string) & 0xC0) == 0x80);
     if (!IS_BREAK(string))
         return 0;
@@ -2199 +2179 @@
         return 0;
 
-    while (string.pointer != string.end)
+    while (string.pointer < string.capacity)
     {
         if (IS_BREAK(string))
         {
             if (!WRITE_BREAK(emitter, string)) return 0;
-            emitter->indention = 1;
+            emitter->is_indention = 1;
             breaks = 1;
         }
@@ -2213 +2193 @@
             }
             if (!WRITE(emitter, string)) return 0;
-            emitter->indention = 0;
+            emitter->is_indention = 0;
             breaks = 0;
         }
@@ -2236 +2216 @@
         return 0;
 
-    while (string.pointer != string.end)
+    while (string.pointer < string.capacity)
     {
         if (IS_BREAK(string))
@@ -2250 +2230 @@
             }
             if (!WRITE_BREAK(emitter, string)) return 0;
-            emitter->indention = 1;
+            emitter->is_indention = 1;
             breaks = 1;
         }
@@ -2267 +2247 @@
                 if (!WRITE(emitter, string)) return 0;
             }
-            emitter->indention = 0;
+            emitter->is_indention = 0;
             breaks = 0;
         }

libyaml/trunk/src/loader.c

@@ -1 +1 @@
 
 #include "yaml_private.h"
+
+#if 0
 
 /*
@@ -429 +431 @@
 }
 
+#endif
+

libyaml/trunk/src/parser.c

@@ -47 +47 @@
 
 #define PEEK_TOKEN(parser)                                                      \
-    ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ?       \
-        parser->tokens.head : NULL)
+    ((parser->is_token_available || yaml_parser_fetch_more_tokens(parser)) ?    \
+        parser->tokens.list + parser->tokens.head : NULL)
 
 /*
@@ -55 +55 @@
 
 #define SKIP_TOKEN(parser)                                                      \
-    (parser->token_available = 0,                                               \
+    (parser->is_token_available = 0,                                            \
      parser->tokens_parsed ++,                                                  \
-     parser->stream_end_produced =                                              \
-        (parser->tokens.head->type == YAML_STREAM_END_TOKEN),                   \
+     parser->is_stream_end_produced =                                           \
+        (parser->tokens.list[parser->tokens.head].type == YAML_STREAM_END_TOKEN),   \
      parser->tokens.head ++)
 
@@ -69 +69 @@
 
 /*
- * Error handling.
- */
-
-static int
-yaml_parser_set_parser_error(yaml_parser_t *parser,
-        const char *problem, yaml_mark_t problem_mark);
-
-static int
-yaml_parser_set_parser_error_context(yaml_parser_t *parser,
-        const char *context, yaml_mark_t context_mark,
-        const char *problem, yaml_mark_t problem_mark);
-
-/*
  * State functions.
  */
@@ -156 +143 @@
 yaml_parser_process_directives(yaml_parser_t *parser,
         yaml_version_directive_t **version_directive_ref,
-        yaml_tag_directive_t **tag_directives_start_ref,
-        yaml_tag_directive_t **tag_directives_end_ref);
+        yaml_tag_directive_t **tag_directives_list_ref,
+        size_t *tag_directives_length_ref,
+        size_t *tag_directives_capacity_ref);
 
 static int
@@ -179 +167 @@
     /* No events after the end of the stream or error. */
 
-    if (parser->stream_end_produced || parser->error ||
-            parser->state == YAML_PARSE_END_STATE) {
+    if (parser->is_stream_end_produced || parser->error.type
+            || parser->state == YAML_PARSE_END_STATE) {
         return 1;
     }
@@ -188 +176 @@
     return yaml_parser_state_machine(parser, event);
 }
-
-/*
- * Set parser error.
- */
-
-static int
-yaml_parser_set_parser_error(yaml_parser_t *parser,
-        const char *problem, yaml_mark_t problem_mark)
-{
-    parser->error = YAML_PARSER_ERROR;
-    parser->problem = problem;
-    parser->problem_mark = problem_mark;
-
-    return 0;
-}
-
-static int
-yaml_parser_set_parser_error_context(yaml_parser_t *parser,
-        const char *context, yaml_mark_t context_mark,
-        const char *problem, yaml_mark_t problem_mark)
-{
-    parser->error = YAML_PARSER_ERROR;
-    parser->context = context;
-    parser->context_mark = context_mark;
-    parser->problem = problem;
-    parser->problem_mark = problem_mark;
-
-    return 0;
-}
-
 
 /*
@@ -319 +277 @@
 
     if (token->type != YAML_STREAM_START_TOKEN) {
-        return yaml_parser_set_parser_error(parser,
+        return PARSER_ERROR_INIT(parser,
                 "did not found expected <stream-start>", token->start_mark);
     }
@@ -346 +304 @@
     yaml_version_directive_t *version_directive = NULL;
     struct {
-        yaml_tag_directive_t *start;
-        yaml_tag_directive_t *end;
-    } tag_directives = { NULL, NULL };
+        yaml_tag_directive_t *list;
+        size_t length;
+        size_t capacity;
+    } tag_directives = { NULL, 0, 0 };
 
     token = PEEK_TOKEN(parser);
@@ -371 +330 @@
             token->type != YAML_STREAM_END_TOKEN)
     {
-        if (!yaml_parser_process_directives(parser, NULL, NULL, NULL))
+        if (!yaml_parser_process_directives(parser, NULL, NULL, NULL, NULL))
             return 0;
         if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
             return 0;
         parser->state = YAML_PARSE_BLOCK_NODE_STATE;
-        DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1,
+        DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, 0, 0, 1,
                 token->start_mark, token->start_mark);
         return 1;
@@ -388 +347 @@
         start_mark = token->start_mark;
         if (!yaml_parser_process_directives(parser, &version_directive,
-                    &tag_directives.start, &tag_directives.end))
+                    &tag_directives.list, &tag_directives.length,
+                    &tag_directives.capacity))
             return 0;
         token = PEEK_TOKEN(parser);
         if (!token) goto error;
         if (token->type != YAML_DOCUMENT_START_TOKEN) {
-            yaml_parser_set_parser_error(parser,
+            PARSER_ERROR_INIT(parser,
                     "did not found expected <document start>", token->start_mark);
             goto error;
@@ -402 +362 @@
         end_mark = token->end_mark;
         DOCUMENT_START_EVENT_INIT(*event, version_directive,
-                tag_directives.start, tag_directives.end, 0,
+                tag_directives.list, tag_directives.length,
+                tag_directives.capacity, 0,
                 start_mark, end_mark);
         SKIP_TOKEN(parser);
         version_directive = NULL;
-        tag_directives.start = tag_directives.end = NULL;
+        tag_directives.list = NULL;
+        tag_directives.length = tag_directives.capacity = 0;
         return 1;
     }
@@ -422 +384 @@
 error:
     yaml_free(version_directive);
-    while (tag_directives.start != tag_directives.end) {
-        yaml_free(tag_directives.end[-1].handle);
-        yaml_free(tag_directives.end[-1].prefix);
-        tag_directives.end --;
-    }
-    yaml_free(tag_directives.start);
+    while (!STACK_EMPTY(parser, tag_directives)) {
+        yaml_tag_directive_t tag_directive = POP(parser, tag_directives);
+        yaml_free(tag_directive.handle);
+        yaml_free(tag_directive.prefix);
+    }
+    STACK_DEL(parser, tag_directives);
     return 0;
 }
@@ -599 +561 @@
             }
             else {
-                yaml_tag_directive_t *tag_directive;
-                for (tag_directive = parser->tag_directives.start;
-                        tag_directive != parser->tag_directives.top;
-                        tag_directive ++) {
+                int idx;
+                for (idx = 0; idx < parser->tag_directives.length; idx++) {
+                    yaml_tag_directive_t *tag_directive = parser->tag_directives.list + idx;
                     if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {
                         size_t prefix_len = strlen((char *)tag_directive->prefix);
@@ -608 +569 @@
                         tag = yaml_malloc(prefix_len+suffix_len+1);
                         if (!tag) {
-                            parser->error = YAML_MEMORY_ERROR;
+                            MEMORY_ERROR_INIT(parser);
                             goto error;
                         }
@@ -621 +582 @@
                 }
                 if (!tag) {
-                    yaml_parser_set_parser_error_context(parser,
+                    PARSER_ERROR_WITH_CONTEXT_INIT(parser,
                             "while parsing a node", start_mark,
                             "found undefined tag handle", tag_mark);
@@ -688 +649 @@
                 yaml_char_t *value = yaml_malloc(1);
                 if (!value) {
-                    parser->error = YAML_MEMORY_ERROR;
+                    MEMORY_ERROR_INIT(parser);
                     goto error;
                 }
@@ -699 +660 @@
             }
             else {
-                yaml_parser_set_parser_error_context(parser,
+                PARSER_ERROR_WITH_CONTEXT_INIT(parser,
                         (block ? "while parsing a block node"
                          : "while parsing a flow node"), start_mark,
@@ -770 +731 @@
     else
     {
-        return yaml_parser_set_parser_error_context(parser,
+        return PARSER_ERROR_WITH_CONTEXT_INIT(parser,
                 "while parsing a block collection", POP(parser, parser->marks),
                 "did not found expected '-' indicator", token->start_mark);
@@ -880 +841 @@
     else
     {
-        return yaml_parser_set_parser_error_context(parser,
+        return PARSER_ERROR_WITH_CONTEXT_INIT(parser,
                 "while parsing a block mapping", POP(parser, parser->marks),
                 "did not found expected key", token->start_mark);
@@ -974 +935 @@
             }
             else {
-                return yaml_parser_set_parser_error_context(parser,
+                return PARSER_ERROR_WITH_CONTEXT_INIT(parser,
                         "while parsing a flow sequence", POP(parser, parser->marks),
                         "did not found expected ',' or ']'", token->start_mark);
@@ -1126 +1087 @@
             }
             else {
-                return yaml_parser_set_parser_error_context(parser,
+                return PARSER_ERROR_WITH_CONTEXT_INIT(parser,
                         "while parsing a flow mapping", POP(parser, parser->marks),
                         "did not found expected ',' or '}'", token->start_mark);
@@ -1215 +1176 @@
     value = yaml_malloc(1);
     if (!value) {
-        parser->error = YAML_MEMORY_ERROR;
-        return 0;
+        return MEMORY_ERROR_INIT(parser);
     }
     value[0] = '\0';
@@ -1233 +1193 @@
 yaml_parser_process_directives(yaml_parser_t *parser,
         yaml_version_directive_t **version_directive_ref,
-        yaml_tag_directive_t **tag_directives_start_ref,
-        yaml_tag_directive_t **tag_directives_end_ref)
+        yaml_tag_directive_t **tag_directives_list_ref,
+        size_t *tag_directives_length_ref,
+        size_t *tag_directives_capacity_ref)
 {
     yaml_tag_directive_t default_tag_directives[] = {
@@ -1244 +1205 @@
     yaml_version_directive_t *version_directive = NULL;
     struct {
-        yaml_tag_directive_t *start;
-        yaml_tag_directive_t *end;
-        yaml_tag_directive_t *top;
-    } tag_directives = { NULL, NULL, NULL };
-    yaml_token_t *token;
-
-    if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE))
+        yaml_tag_directive_t *list;
+        size_t length;
+        size_t capacity;
+    } tag_directives = { NULL, 0, 0 };
+    yaml_token_t *token;
+
+    if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_CAPACITY))
         goto error;
 
@@ -1261 +1222 @@
         if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) {
             if (version_directive) {
-                yaml_parser_set_parser_error(parser,
+                PARSER_ERROR_INIT(parser,
                         "found duplicate %YAML directive", token->start_mark);
                 goto error;
@@ -1267 +1228 @@
             if (token->data.version_directive.major != 1
                     || token->data.version_directive.minor != 1) {
-                yaml_parser_set_parser_error(parser,
+                PARSER_ERROR_INIT(parser,
                         "found incompatible YAML document", token->start_mark);
                 goto error;
@@ -1273 +1234 @@
             version_directive = yaml_malloc(sizeof(yaml_version_directive_t));
             if (!version_directive) {
-                parser->error = YAML_MEMORY_ERROR;
+                MEMORY_ERROR_INIT(parser);
                 goto error;
             }
@@ -1307 +1268 @@
         *version_directive_ref = version_directive;
     }
-    if (tag_directives_start_ref) {
+    if (tag_directives_list_ref) {
         if (STACK_EMPTY(parser, tag_directives)) {
-            *tag_directives_start_ref = *tag_directives_end_ref = NULL;
+            *tag_directives_list_ref = NULL;
+            *tag_directives_length_ref = 0;
+            *tag_directives_capacity_ref = 0;
             STACK_DEL(parser, tag_directives);
         }
         else {
-            *tag_directives_start_ref = tag_directives.start;
-            *tag_directives_end_ref = tag_directives.top;
+            *tag_directives_list_ref = tag_directives.list;
+            *tag_directives_length_ref = tag_directives.length;
+            *tag_directives_capacity_ref = tag_directives.capacity;
         }
     }
@@ -1344 +1308 @@
     yaml_tag_directive_t *tag_directive;
     yaml_tag_directive_t copy = { NULL, NULL };
-
-    for (tag_directive = parser->tag_directives.start;
-            tag_directive != parser->tag_directives.top; tag_directive ++) {
+    int idx;
+
+    for (idx = 0; idx < parser->tag_directives.length; idx++) {
+        yaml_tag_directive_t *tag_directive = parser->tag_directives.list + idx;
         if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
             if (allow_duplicates)
                 return 1;
-            return yaml_parser_set_parser_error(parser,
+            return PARSER_ERROR_INIT(parser,
                     "found duplicate %TAG directive", mark);
         }
@@ -1358 +1323 @@
     copy.prefix = yaml_strdup(value.prefix);
     if (!copy.handle || !copy.prefix) {
-        parser->error = YAML_MEMORY_ERROR;
+        MEMORY_ERROR_INIT(parser);
         goto error;
     }

libyaml/trunk/src/reader.c

@@ -36 +36 @@
     /* Ensure that we had enough bytes in the raw buffer. */
 
-    while (!parser->is_eof && parser->raw_input.length < 3) {
+    while (!parser->is_eof && parser->raw_input.capacity < 3) {
         if (!yaml_parser_update_raw_buffer(parser)) {
             return 0;
@@ -44 +44 @@
     /* Determine the encoding. */
 
-    if (parser->raw_input.length >= 2
+    if (parser->raw_input.capacity >= 2
             && !memcmp(parser->raw_input.buffer, BOM_UTF16LE, 2)) {
         parser->encoding = YAML_UTF16LE_ENCODING;
@@ -50 +50 @@
         parser->offset = 2;
     }
-    else if (parser->raw_input.length >= 2
+    else if (parser->raw_input.capacity >= 2
             && !memcmp(parser->raw_input.buffer, BOM_UTF16BE, 2)) {
         parser->encoding = YAML_UTF16BE_ENCODING;
@@ -56 +56 @@
         parser->offset = 2;
     }
-    else if (parser->raw_input.length >= 3
+    else if (parser->raw_input.capacity >= 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.length == parser->raw_input.capacity)
+            parser->raw_input.capacity == RAW_INPUT_BUFFER_CAPACITY)
         return 1;
 
@@ -92 +92 @@
 
     if (parser->raw_input.pointer > 0 &&
-            parser->raw_input.pointer < parser->raw_input.length) {
+            parser->raw_input.pointer < parser->raw_input.capacity) {
         memmove(parser->raw_input.buffer,
                 parser->raw_input.buffer + parser->raw_input.pointer,
-                parser->raw_input.length - parser->raw_input.pointer);
-    }
+                parser->raw_input.capacity - parser->raw_input.pointer);
+    }
+    parser->raw_input.capacity -= parser->raw_input.pointer;
     parser->raw_input.pointer = 0;
 
@@ -102 +103 @@
 
     if (!parser->reader(parser->reader_data,
-                parser->raw_input.buffer + parser->raw_input.length,
-                parser->raw_input.capacity - parser->raw_input.length,
+                parser->raw_input.buffer + parser->raw_input.capacity,
+                RAW_INPUT_BUFFER_CAPACITY - parser->raw_input.capacity,
                 &length)) {
         return READER_ERROR_INIT(parser, "Input error", parser->offset);
     }
-    parser->raw_input.length += length;
+    parser->raw_input.capacity += length;
     if (!length) {
         parser->is_eof = 1;
@@ -125 +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.length)
+    if (parser->is_eof && parser->raw_input.pointer == parser->raw_input.capacity)
         return 1;
 
@@ -147 +150 @@
 
     if (parser->input.pointer > 0 &&
-            parser->input.pointer < parser->input.length) {
+            parser->input.pointer < parser->input.capacity) {
         memmove(parser->input.buffer,
                 parser->input.buffer + parser->input.pointer,
-                parser->input.length - parser->input.pointer);
-        parser->input.length -= parser->input.pointer;
-        parser->input.pointer = 0;
-    }
-    else if (parser->input.pointer == parser->input.length) {
-        parser->input.pointer = parser->input.length = 0;
-    }
+                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;
 
     /* Fill the buffer until it has enough characters. */
@@ -168 +174 @@
         /* Decode the raw buffer. */
 
-        while (parser->raw_input.pointer != parser->raw_input.length)
+        while (parser->raw_input.pointer != parser->raw_input.capacity)
         {
-            unsigned char *raw_buffer =
-                parser->raw_input.buffer + parser->raw_input.pointer;
             size_t raw_unread =
-                parser->raw_input.length - parser->raw_input.pointer;
+                parser->raw_input.capacity - parser->raw_input.pointer;
             unsigned int value = 0, value2 = 0;
             int is_incomplete = 0;
@@ -179 +183 @@
             unsigned int width = 0;
             int low, high;
-            size_t k;
+            size_t idx;
 
             /* Decode the next character. */
@@ -209 +213 @@
                     /* Determine the length of the UTF-8 sequence. */
 
-                    octet = *raw_buffer;
+                    octet = OCTET(parser->raw_input);
                     width = (octet & 0x80) == 0x00 ? 1 :
                             (octet & 0xE0) == 0xC0 ? 2 :
@@ -243 +247 @@
                     /* Check and decode the trailing octets. */
 
-                    for (k = 1; k < width; k ++)
+                    for (idx = 1; idx < width; idx ++)
                     {
-                        octet = raw_buffer[k];
+                        octet = OCTET_AT(parser->raw_input, idx);
 
                         /* Check if the octet is valid. */
@@ -252 +256 @@
                             return DECODER_ERROR_INIT(parser,
                                     "Invalid trailing UTF-8 octet",
-                                    parser->offset+k, octet);
+                                    parser->offset+idx, octet);
 
                         /* Decode the octet. */
@@ -324 +328 @@
                     /* Get the character. */
 
-                    value = raw_buffer[low] + (raw_buffer[high] << 8);
+                    value = OCTET_AT(parser->raw_input, low)
+                        + (OCTET_AT(parser->raw_input, high) << 8);
 
                     /* Check for unexpected low surrogate area. */
@@ -353 +358 @@
                         /* Get the next character. */
 
-                        value2 = raw_buffer[low+2] + (raw_buffer[high+2] << 8);
+                        value2 = OCTET_AT(parser->raw_input, low+2)
+                            + (OCTET_AT(parser->raw_input, high+2) << 8);
 
                         /* Check for a low surrogate area. */
@@ -407 +413 @@
             /* 0000 0000-0000 007F -> 0xxxxxxx */
             if (value <= 0x7F) {
-                parser->input.buffer[parser->input.length++] = value;
+                JOIN_OCTET(parser->input, value);
             }
             /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */
             else if (value <= 0x7FF) {
-                parser->input.buffer[parser->input.length++] = 0xC0 + (value >> 6);
-                parser->input.buffer[parser->input.length++] = 0x80 + (value & 0x3F);
+                JOIN_OCTET(parser->input, 0xC0 + (value >> 6));
+                JOIN_OCTET(parser->input, 0x80 + (value & 0x3F));
             }
             /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */
             else if (value <= 0xFFFF) {
-                parser->input.buffer[parser->input.length++] = 0xE0 + (value >> 12);
-                parser->input.buffer[parser->input.length++] = 0x80 + ((value >> 6) & 0x3F);
-                parser->input.buffer[parser->input.length++] = 0x80 + (value & 0x3F);
+                JOIN_OCTET(parser->input, 0xE0 + (value >> 12));
+                JOIN_OCTET(parser->input, 0x80 + ((value >> 6) & 0x3F));
+                JOIN_OCTET(parser->input, 0x80 + (value & 0x3F));
             }
             /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
             else {
-                parser->input.buffer[parser->input.length++] = 0xF0 + (value >> 18);
-                parser->input.buffer[parser->input.length++] = 0x80 + ((value >> 12) & 0x3F);
-                parser->input.buffer[parser->input.length++] = 0x80 + ((value >> 6) & 0x3F);
-                parser->input.buffer[parser->input.length++] = 0x80 + (value & 0x3F);
+                JOIN_OCTET(parser->input, 0xF0 + (value >> 18));
+                JOIN_OCTET(parser->input, 0x80 + ((value >> 12) & 0x3F));
+                JOIN_OCTET(parser->input, 0x80 + ((value >> 6) & 0x3F));
+                JOIN_OCTET(parser->input, 0x80 + (value & 0x3F));
             }
 
@@ -431 +437 @@
         }
 
-        /* On EOF, put NUL into the buffer and return. */
+        /* On EOF, put NUL into the buffer and stop. */
 
         if (parser->is_eof) {
-            parser->input.buffer[parser->input.length++] = '\0';
+            JOIN_OCTET(parser->input, '\0');
             parser->unread ++;
-            return 1;
+            break;
         }
 
     }
+    /* 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;
 
     return 1;

libyaml/trunk/src/scanner.c

@@ -496 +496 @@
       parser->mark.column ++,                                                   \
       parser->unread --,                                                        \
-      parser->buffer.pointer += WIDTH(parser->buffer))
+      parser->input.pointer += WIDTH(parser->input))
 
 #define SKIP_LINE(parser)                                                       \
-     (IS_CRLF(parser->buffer) ?                                                 \
+     (IS_CRLF(parser->input) ?                                                  \
       (parser->mark.index += 2,                                                 \
        parser->mark.column = 0,                                                 \
        parser->mark.line ++,                                                    \
        parser->unread -= 2,                                                     \
-       parser->buffer.pointer += 2) :                                           \
-      IS_BREAK(parser->buffer) ?                                                \
+       parser->input.pointer += 2) :                                            \
+      IS_BREAK(parser->input) ?                                                 \
       (parser->mark.index ++,                                                   \
        parser->mark.column = 0,                                                 \
        parser->mark.line ++,                                                    \
        parser->unread --,                                                       \
-       parser->buffer.pointer += WIDTH(parser->buffer)) : 0)
+       parser->input.pointer += WIDTH(parser->input)) : 0)
 
 /*
@@ -518 +518 @@
 #define READ(parser,string)                                                     \
      (STRING_EXTEND(parser,string) ?                                            \
-         (COPY(string,parser->buffer),                                          \
+         (COPY(string,parser->input),                                           \
           parser->mark.index ++,                                                \
           parser->mark.column ++,                                               \
@@ -530 +530 @@
 #define READ_LINE(parser,string)                                                \
     (STRING_EXTEND(parser,string) ?                                             \
-    (((CHECK_AT(parser->buffer,'\r',0)                                          \
-       && CHECK_AT(parser->buffer,'\n',1)) ?        /* CR LF -> LF */           \
-     (*((string).pointer++) = (yaml_char_t) '\n',                               \
-      parser->buffer.pointer += 2,                                              \
+    (((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,                                               \
       parser->mark.index += 2,                                                  \
       parser->mark.column = 0,                                                  \
       parser->mark.line ++,                                                     \
       parser->unread -= 2) :                                                    \
-     (CHECK_AT(parser->buffer,'\r',0)                                           \
-      || CHECK_AT(parser->buffer,'\n',0)) ?         /* CR|LF -> LF */           \
-     (*((string).pointer++) = (yaml_char_t) '\n',                               \
-      parser->buffer.pointer ++,                                                \
+     (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 ++,                                                    \
       parser->mark.column = 0,                                                  \
       parser->mark.line ++,                                                     \
       parser->unread --) :                                                      \
-     (CHECK_AT(parser->buffer,'\xC2',0)                                         \
-      && CHECK_AT(parser->buffer,'\x85',1)) ?       /* NEL -> LF */             \
-     (*((string).pointer++) = (yaml_char_t) '\n',                               \
-      parser->buffer.pointer += 2,                                              \
+     (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 ++,                                                    \
       parser->mark.column = 0,                                                  \
       parser->mark.line ++,                                                     \
       parser->unread --) :                                                      \
-     (CHECK_AT(parser->buffer,'\xE2',0) &&                                      \
-      CHECK_AT(parser->buffer,'\x80',1) &&                                      \
-      (CHECK_AT(parser->buffer,'\xA8',2) ||                                     \
-       CHECK_AT(parser->buffer,'\xA9',2))) ?        /* LS|PS -> LS|PS */        \
-     (*((string).pointer++) = *(parser->buffer.pointer++),                      \
-      *((string).pointer++) = *(parser->buffer.pointer++),                      \
-      *((string).pointer++) = *(parser->buffer.pointer++),                      \
+     (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,                                                  \
@@ -575 +575 @@
 
 /*
- * Error handling.
- */
-
-static int
-yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context,
-        yaml_mark_t context_mark, const char *problem);
-
-/*
  * High-level token API.
  */
@@ -751 +743 @@
     /* No tokens after STREAM-END or error. */
 
-    if (parser->stream_end_produced || parser->error) {
+    if (parser->is_stream_end_produced || parser->error.type) {
         return 1;
     }
@@ -757 +749 @@
     /* Ensure that the tokens queue contains enough tokens. */
 
-    if (!parser->token_available) {
+    if (!parser->is_token_available) {
         if (!yaml_parser_fetch_more_tokens(parser))
             return 0;
@@ -765 +757 @@
     
     *token = DEQUEUE(parser, parser->tokens);
-    parser->token_available = 0;
+    parser->is_token_available = 0;
     parser->tokens_parsed ++;
 
     if (token->type == YAML_STREAM_END_TOKEN) {
-        parser->stream_end_produced = 1;
-    }
-
-    return 1;
-}
-
-/*
- * Set the scanner error and return 0.
- */
-
-static int
-yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context,
-        yaml_mark_t context_mark, const char *problem)
-{
-    parser->error = YAML_SCANNER_ERROR;
-    parser->context = context;
-    parser->context_mark = context_mark;
-    parser->problem = problem;
-    parser->problem_mark = parser->mark;
-
-    return 0;
+        parser->is_stream_end_produced = 1;
+    }
+
+    return 1;
 }
 
@@ -820 +795 @@
         else
         {
-            yaml_simple_key_t *simple_key;
+            size_t idx;
 
             /* Check if any potential simple key may occupy the head position. */
@@ -827 +802 @@
                 return 0;
 
-            for (simple_key = parser->simple_keys.start;
-                    simple_key != parser->simple_keys.top; simple_key++) {
-                if (simple_key->possible
+            for (idx = 0; idx < parser->simple_keys.length; idx++) {
+                yaml_simple_key_t *simple_key  = parser->simple_keys.list + idx;
+                if (simple_key->is_possible
                         && simple_key->token_number == parser->tokens_parsed) {
                     need_more_tokens = 1;
@@ -848 +823 @@
     }
 
-    parser->token_available = 1;
+    parser->is_token_available = 1;
 
     return 1;
@@ -860 +835 @@
 yaml_parser_fetch_next_token(yaml_parser_t *parser)
 {
+    yaml_mark_t start_mark = parser->mark;
+
     /* Ensure that the buffer is initialized. */
 
@@ -867 +844 @@
     /* Check if we just started scanning.  Fetch STREAM-START then. */
 
-    if (!parser->stream_start_produced)
+    if (!parser->is_stream_start_produced)
         return yaml_parser_fetch_stream_start(parser);
 
@@ -895 +872 @@
     /* Is it the end of the stream? */
 
-    if (IS_Z(parser->buffer))
+    if (IS_Z(parser->input))
         return yaml_parser_fetch_stream_end(parser);
 
     /* Is it a directive? */
 
-    if (parser->mark.column == 0 && CHECK(parser->buffer, '%'))
+    if (parser->mark.column == 0 && CHECK(parser->input, '%'))
         return yaml_parser_fetch_directive(parser);
 
@@ -906 +883 @@
 
     if (parser->mark.column == 0
-            && CHECK_AT(parser->buffer, '-', 0)
-            && CHECK_AT(parser->buffer, '-', 1)
-            && CHECK_AT(parser->buffer, '-', 2)
-            && IS_BLANKZ_AT(parser->buffer, 3))
+            && CHECK_AT(parser->input, '-', 0)
+            && CHECK_AT(parser->input, '-', 1)
+            && CHECK_AT(parser->input, '-', 2)
+            && IS_BLANKZ_AT(parser->input, 3))
         return yaml_parser_fetch_document_indicator(parser,
                 YAML_DOCUMENT_START_TOKEN);
@@ -916 +893 @@
 
     if (parser->mark.column == 0
-            && CHECK_AT(parser->buffer, '.', 0)
-            && CHECK_AT(parser->buffer, '.', 1)
-            && CHECK_AT(parser->buffer, '.', 2)
-            && IS_BLANKZ_AT(parser->buffer, 3))
+            && CHECK_AT(parser->input, '.', 0)
+            && CHECK_AT(parser->input, '.', 1)
+            && CHECK_AT(parser->input, '.', 2)
+            && IS_BLANKZ_AT(parser->input, 3))
         return yaml_parser_fetch_document_indicator(parser,
                 YAML_DOCUMENT_END_TOKEN);
@@ -925 +902 @@
     /* Is it the flow sequence start indicator? */
 
-    if (CHECK(parser->buffer, '['))
+    if (CHECK(parser->input, '['))
         return yaml_parser_fetch_flow_collection_start(parser,
                 YAML_FLOW_SEQUENCE_START_TOKEN);
@@ -931 +908 @@
     /* Is it the flow mapping start indicator? */
 
-    if (CHECK(parser->buffer, '{'))
+    if (CHECK(parser->input, '{'))
         return yaml_parser_fetch_flow_collection_start(parser,
                 YAML_FLOW_MAPPING_START_TOKEN);
@@ -937 +914 @@
     /* Is it the flow sequence end indicator? */
 
-    if (CHECK(parser->buffer, ']'))
+    if (CHECK(parser->input, ']'))
         return yaml_parser_fetch_flow_collection_end(parser,
                 YAML_FLOW_SEQUENCE_END_TOKEN);
@@ -943 +920 @@
     /* Is it the flow mapping end indicator? */
 
-    if (CHECK(parser->buffer, '}'))
+    if (CHECK(parser->input, '}'))
         return yaml_parser_fetch_flow_collection_end(parser,
                 YAML_FLOW_MAPPING_END_TOKEN);
@@ -949 +926 @@
     /* Is it the flow entry indicator? */
 
-    if (CHECK(parser->buffer, ','))
+    if (CHECK(parser->input, ','))
         return yaml_parser_fetch_flow_entry(parser);
 
     /* Is it the block entry indicator? */
 
-    if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))
+    if (CHECK(parser->input, '-') && IS_BLANKZ_AT(parser->input, 1))
         return yaml_parser_fetch_block_entry(parser);
 
     /* Is it the key indicator? */
 
-    if (CHECK(parser->buffer, '?')
-            && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))
+    if (CHECK(parser->input, '?')
+            && (parser->flow_level || IS_BLANKZ_AT(parser->input, 1)))
         return yaml_parser_fetch_key(parser);
 
     /* Is it the value indicator? */
 
-    if (CHECK(parser->buffer, ':')
-            && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))
+    if (CHECK(parser->input, ':')
+            && (parser->flow_level || IS_BLANKZ_AT(parser->input, 1)))
         return yaml_parser_fetch_value(parser);
 
     /* Is it an alias? */
 
-    if (CHECK(parser->buffer, '*'))
+    if (CHECK(parser->input, '*'))
         return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN);
 
     /* Is it an anchor? */
 
-    if (CHECK(parser->buffer, '&'))
+    if (CHECK(parser->input, '&'))
         return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN);
 
     /* Is it a tag? */
 
-    if (CHECK(parser->buffer, '!'))
+    if (CHECK(parser->input, '!'))
         return yaml_parser_fetch_tag(parser);
 
     /* Is it a literal scalar? */
 
-    if (CHECK(parser->buffer, '|') && !parser->flow_level)
+    if (CHECK(parser->input, '|') && !parser->flow_level)
         return yaml_parser_fetch_block_scalar(parser, 1);
 
     /* Is it a folded scalar? */
 
-    if (CHECK(parser->buffer, '>') && !parser->flow_level)
+    if (CHECK(parser->input, '>') && !parser->flow_level)
         return yaml_parser_fetch_block_scalar(parser, 0);
 
     /* Is it a single-quoted scalar? */
 
-    if (CHECK(parser->buffer, '\''))
+    if (CHECK(parser->input, '\''))
         return yaml_parser_fetch_flow_scalar(parser, 1);
 
     /* Is it a double-quoted scalar? */
 
-    if (CHECK(parser->buffer, '"'))
+    if (CHECK(parser->input, '"'))
         return yaml_parser_fetch_flow_scalar(parser, 0);
 
@@ -1023 +1000 @@
      */
 
-    if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')
-                || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')
-                || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[')
-                || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')
-                || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#')
-                || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*')
-                || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|')
-                || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'')
-                || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%')
-                || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) ||
-            (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) ||
+    if (!(IS_BLANKZ(parser->input) || CHECK(parser->input, '-')
+                || CHECK(parser->input, '?') || CHECK(parser->input, ':')
+                || CHECK(parser->input, ',') || CHECK(parser->input, '[')
+                || CHECK(parser->input, ']') || CHECK(parser->input, '{')
+                || CHECK(parser->input, '}') || CHECK(parser->input, '#')
+                || CHECK(parser->input, '&') || CHECK(parser->input, '*')
+                || CHECK(parser->input, '!') || CHECK(parser->input, '|')
+                || CHECK(parser->input, '>') || CHECK(parser->input, '\'')
+                || CHECK(parser->input, '"') || CHECK(parser->input, '%')
+                || CHECK(parser->input, '@') || CHECK(parser->input, '`')) ||
+            (CHECK(parser->input, '-') && !IS_BLANK_AT(parser->input, 1)) ||
             (!parser->flow_level &&
-             (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':'))
-             && !IS_BLANKZ_AT(parser->buffer, 1)))
+             (CHECK(parser->input, '?') || CHECK(parser->input, ':'))
+             && !IS_BLANKZ_AT(parser->input, 1)))
         return yaml_parser_fetch_plain_scalar(parser);
 
@@ -1043 +1020 @@
      */
 
-    return yaml_parser_set_scanner_error(parser,
-            "while scanning for the next token", parser->mark,
-            "found character that cannot start any token");
+    return SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+            "while scanning for the next token", start_mark,
+            "found character that cannot start any token", parser->mark);
 }
 
@@ -1056 +1033 @@
 yaml_parser_stale_simple_keys(yaml_parser_t *parser)
 {
-    yaml_simple_key_t *simple_key;
+    size_t idx;
 
     /* Check for a potential simple key for each flow level. */
 
-    for (simple_key = parser->simple_keys.start;
-            simple_key != parser->simple_keys.top; simple_key ++)
+    for (idx = 0; idx < parser->simple_keys.length; idx ++)
     {
+        yaml_simple_key_t *simple_key = parser->simple_keys.list + idx;
+
         /*
          * The specification requires that a simple key
@@ -1070 +1048 @@
          */
 
-        if (simple_key->possible
+        if (simple_key->is_possible
                 && (simple_key->mark.line < parser->mark.line
                     || simple_key->mark.index+1024 < parser->mark.index)) {
@@ -1076 +1054 @@
             /* Check if the potential simple key to be removed is required. */
 
-            if (simple_key->required) {
-                return yaml_parser_set_scanner_error(parser,
+            if (simple_key->is_required) {
+                return SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
                         "while scanning a simple key", simple_key->mark,
-                        "could not found expected ':'");
+                        "could not found expected ':'", parser->mark);
             }
 
-            simple_key->possible = 0;
+            simple_key->is_possible = 0;
         }
     }
@@ -1103 +1081 @@
      */
 
-    int required = (!parser->flow_level
+    int is_required = (!parser->flow_level
             && parser->indent == (int)parser->mark.column);
 
@@ -1111 +1089 @@
      */
 
-    assert(parser->simple_key_allowed || !required);    /* Impossible. */
+    assert(parser->is_simple_key_allowed || !is_required);  /* Impossible. */
 
     /*
@@ -1117 +1095 @@
      */
 
-    if (parser->simple_key_allowed)
+    if (parser->is_simple_key_allowed)
     {
-        yaml_simple_key_t simple_key = { 1, required,
+        yaml_simple_key_t simple_key = { 1, is_required,
             parser->tokens_parsed + parser->tokens.tail - parser->tokens.head,
             { 0, 0, 0 } };
@@ -1126 +1104 @@
         if (!yaml_parser_remove_simple_key(parser)) return 0;
 
-        *(parser->simple_keys.top-1) = simple_key;
+        parser->simple_keys.list[parser->simple_keys.length-1] = simple_key;
     }
 
@@ -1139 +1117 @@
 yaml_parser_remove_simple_key(yaml_parser_t *parser)
 {
-    yaml_simple_key_t *simple_key = parser->simple_keys.top-1;
-
-    if (simple_key->possible)
+    yaml_simple_key_t *simple_key =
+        parser->simple_keys.list + parser->simple_keys.length - 1;
+
+    if (simple_key->is_possible)
     {
         /* If the key is required, it is an error. */
 
-        if (simple_key->required) {
-            return yaml_parser_set_scanner_error(parser,
+        if (simple_key->is_required) {
+            return SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
                     "while scanning a simple key", simple_key->mark,
-                    "could not found expected ':'");
+                    "could not found expected ':'", parser->mark);
         }
     }
@@ -1154 +1133 @@
     /* Remove the key from the stack. */
 
-    simple_key->possible = 0;
+    simple_key->is_possible = 0;
 
     return 1;
@@ -1302 +1281 @@
     /* A simple key is allowed at the beginning of the stream. */
 
-    parser->simple_key_allowed = 1;
+    parser->is_simple_key_allowed = 1;
 
     /* We have started. */
 
-    parser->stream_start_produced = 1;
+    parser->is_stream_start_produced = 1;
 
     /* Create the STREAM-START token and append it to the queue. */
@@ -1345 +1324 @@
         return 0;
 
-    parser->simple_key_allowed = 0;
+    parser->is_simple_key_allowed = 0;
 
     /* Create the STREAM-END token and append it to the queue. */
@@ -1376 +1355 @@
         return 0;
 
-    parser->simple_key_allowed = 0;
+    parser->is_simple_key_allowed = 0;
 
     /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */
@@ -1414 +1393 @@
         return 0;
 
-    parser->simple_key_allowed = 0;
+    parser->is_simple_key_allowed = 0;
 
     /* Consume the token. */
@@ -1461 +1440 @@
     /* A simple key may follow the indicators '[' and '{'. */
 
-    parser->simple_key_allowed = 1;
+    parser->is_simple_key_allowed = 1;
 
     /* Consume the token. */
@@ -1504 +1483 @@
     /* No simple keys after the indicators ']' and '}'. */
 
-    parser->simple_key_allowed = 0;
+    parser->is_simple_key_allowed = 0;
 
     /* Consume the token. */
@@ -1541 +1520 @@
     /* Simple keys are allowed after ','. */
 
-    parser->simple_key_allowed = 1;
+    parser->is_simple_key_allowed = 1;
 
     /* Consume the token. */
@@ -1575 +1554 @@
         /* Check if we are allowed to start a new entry. */
 
-        if (!parser->simple_key_allowed) {
-            return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
-                    "block sequence entries are not allowed in this context");
+        if (!parser->is_simple_key_allowed) {
+            return SCANNER_ERROR_INIT(parser,
+                    "block sequence entries are not allowed in this context",
+                    parser->mark);
         }
 
@@ -1602 +1582 @@
     /* Simple keys are allowed after '-'. */
 
-    parser->simple_key_allowed = 1;
+    parser->is_simple_key_allowed = 1;
 
     /* Consume the token. */
@@ -1636 +1616 @@
         /* Check if we are allowed to start a new key (not nessesary simple). */
 
-        if (!parser->simple_key_allowed) {
-            return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
-                    "mapping keys are not allowed in this context");
+        if (!parser->is_simple_key_allowed) {
+            return SCANNER_ERROR_INIT(parser,
+                    "mapping keys are not allowed in this context", parser->mark);
         }
 
@@ -1655 +1635 @@
     /* Simple keys are allowed after '?' in the block context. */
 
-    parser->simple_key_allowed = (!parser->flow_level);
+    parser->is_simple_key_allowed = (!parser->flow_level);
 
     /* Consume the token. */
@@ -1682 +1662 @@
     yaml_mark_t start_mark, end_mark;
     yaml_token_t token;
-    yaml_simple_key_t *simple_key = parser->simple_keys.top-1;
+    yaml_simple_key_t *simple_key =
+        parser->simple_keys.list + parser->simple_keys.length - 1;
 
     /* Have we found a simple key? */
 
-    if (simple_key->possible)
+    if (simple_key->is_possible)
     {
 
@@ -1706 +1687 @@
         /* Remove the simple key. */
 
-        simple_key->possible = 0;
+        simple_key->is_possible = 0;
 
         /* A simple key cannot follow another simple key. */
 
-        parser->simple_key_allowed = 0;
+        parser->is_simple_key_allowed = 0;
     }
     else
@@ -1722 +1703 @@
             /* Check if we are allowed to start a complex value. */
 
-            if (!parser->simple_key_allowed) {
-                return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
-                        "mapping values are not allowed in this context");
+            if (!parser->is_simple_key_allowed) {
+                return SCANNER_ERROR_INIT(parser,
+                        "mapping values are not allowed in this context",
+                        parser->mark);
             }
 
@@ -1736 +1718 @@
         /* Simple keys after ':' are allowed in the block context. */
 
-        parser->simple_key_allowed = (!parser->flow_level);
+        parser->is_simple_key_allowed = (!parser->flow_level);
     }
 
@@ -1771 +1753 @@
     /* A simple key cannot follow an anchor or an alias. */
 
-    parser->simple_key_allowed = 0;
+    parser->is_simple_key_allowed = 0;
 
     /* Create the ALIAS or ANCHOR token and append it to the queue. */
@@ -1801 +1783 @@
     /* A simple key cannot follow a tag. */
 
-    parser->simple_key_allowed = 0;
+    parser->is_simple_key_allowed = 0;
 
     /* Create the TAG token and append it to the queue. */
@@ -1832 +1814 @@
     /* A simple key may follow a block scalar. */
 
-    parser->simple_key_allowed = 1;
+    parser->is_simple_key_allowed = 1;
 
     /* Create the SCALAR token and append it to the queue. */
@@ -1863 +1845 @@
     /* A simple key cannot follow a flow scalar. */
 
-    parser->simple_key_allowed = 0;
+    parser->is_simple_key_allowed = 0;
 
     /* Create the SCALAR token and append it to the queue. */
@@ -1894 +1876 @@
     /* A simple key cannot follow a flow scalar. */
 
-    parser->simple_key_allowed = 0;
+    parser->is_simple_key_allowed = 0;
 
     /* Create the SCALAR token and append it to the queue. */
@@ -1924 +1906 @@
         if (!CACHE(parser, 1)) return 0;
 
-        if (parser->mark.column == 0 && IS_BOM(parser->buffer))
+        if (parser->mark.column == 0 && IS_BOM(parser->input))
             SKIP(parser);
 
@@ -1939 +1921 @@
         if (!CACHE(parser, 1)) return 0;
 
-        while (CHECK(parser->buffer,' ') ||
-                ((parser->flow_level || !parser->simple_key_allowed) &&
-                 CHECK(parser->buffer, '\t'))) {
+        while (CHECK(parser->input,' ') ||
+                ((parser->flow_level || !parser->is_simple_key_allowed) &&
+                 CHECK(parser->input, '\t'))) {
             SKIP(parser);
             if (!CACHE(parser, 1)) return 0;
@@ -1948 +1930 @@
         /* Eat a comment until a line break. */
 
-        if (CHECK(parser->buffer, '#')) {
-            while (!IS_BREAKZ(parser->buffer)) {
+        if (CHECK(parser->input, '#')) {
+            while (!IS_BREAKZ(parser->input)) {
                 SKIP(parser);
                 if (!CACHE(parser, 1)) return 0;
@@ -1957 +1939 @@
         /* If it is a line break, eat it. */
 
-        if (IS_BREAK(parser->buffer))
+        if (IS_BREAK(parser->input))
         {
             if (!CACHE(parser, 2)) return 0;
@@ -1965 +1947 @@
 
             if (!parser->flow_level) {
-                parser->simple_key_allowed = 1;
+                parser->is_simple_key_allowed = 1;
             }
         }
@@ -2048 +2030 @@
     else
     {
-        yaml_parser_set_scanner_error(parser, "while scanning a directive",
-                start_mark, "found uknown directive name");
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                "while scanning a directive", start_mark,
+                "found uknown directive name", parser->mark);
         goto error;
     }
@@ -2057 +2040 @@
     if (!CACHE(parser, 1)) goto error;
 
-    while (IS_BLANK(parser->buffer)) {
+    while (IS_BLANK(parser->input)) {
         SKIP(parser);
         if (!CACHE(parser, 1)) goto error;
     }
 
-    if (CHECK(parser->buffer, '#')) {
-        while (!IS_BREAKZ(parser->buffer)) {
+    if (CHECK(parser->input, '#')) {
+        while (!IS_BREAKZ(parser->input)) {
             SKIP(parser);
             if (!CACHE(parser, 1)) goto error;
@@ -2071 +2054 @@
     /* Check if we are at the end of the line. */
 
-    if (!IS_BREAKZ(parser->buffer)) {
-        yaml_parser_set_scanner_error(parser, "while scanning a directive",
-                start_mark, "did not found expected comment or line break");
+    if (!IS_BREAKZ(parser->input)) {
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                "while scanning a directive", start_mark,
+                "did not found expected comment or line break", parser->mark);
         goto error;
     }
@@ -2079 +2063 @@
     /* Eat a line break. */
 
-    if (IS_BREAK(parser->buffer)) {
+    if (IS_BREAK(parser->input)) {
         if (!CACHE(parser, 2)) goto error;
         SKIP_LINE(parser);
@@ -2111 +2095 @@
     yaml_string_t string = NULL_STRING;
 
-    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY))
+        goto error;
 
     /* Consume the directive name. */
@@ -2117 +2102 @@
     if (!CACHE(parser, 1)) goto error;
 
-    while (IS_ALPHA(parser->buffer))
+    while (IS_ALPHA(parser->input))
     {
         if (!READ(parser, string)) goto error;
@@ -2125 +2110 @@
     /* Check if the name is empty. */
 
-    if (string.start == string.pointer) {
-        yaml_parser_set_scanner_error(parser, "while scanning a directive",
-                start_mark, "cannot found expected directive name");
+    if (!string.pointer) {
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                "while scanning a directive", start_mark,
+                "cannot found expected directive name", parser->mark);
         goto error;
     }
@@ -2133 +2119 @@
     /* Check for an blank character after the name. */
 
-    if (!IS_BLANKZ(parser->buffer)) {
-        yaml_parser_set_scanner_error(parser, "while scanning a directive",
-                start_mark, "found unexpected non-alphabetical character");
+    if (!IS_BLANKZ(parser->input)) {
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                "while scanning a directive", start_mark,
+                "found unexpected non-alphabetical character", parser->mark);
         goto error;
     }
 
-    *name = string.start;
+    *name = string.buffer;
 
     return 1;
@@ -2164 +2151 @@
     if (!CACHE(parser, 1)) return 0;
 
-    while (IS_BLANK(parser->buffer)) {
+    while (IS_BLANK(parser->input)) {
         SKIP(parser);
         if (!CACHE(parser, 1)) return 0;
@@ -2176 +2163 @@
     /* Eat '.'. */
 
-    if (!CHECK(parser->buffer, '.')) {
-        return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
-                start_mark, "did not find expected digit or '.' character");
+    if (!CHECK(parser->input, '.')) {
+        return SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                "while scanning a %YAML directive", start_mark,
+                "did not find expected digit or '.' character", parser->mark);
     }
 
@@ -2214 +2202 @@
     if (!CACHE(parser, 1)) return 0;
 
-    while (IS_DIGIT(parser->buffer))
+    while (IS_DIGIT(parser->input))
     {
         /* Check if the number is too long. */
 
         if (++length > MAX_NUMBER_LENGTH) {
-            return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
-                    start_mark, "found extremely long version number");
-        }
-
-        value = value*10 + AS_DIGIT(parser->buffer);
+            return SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                    "while scanning a %YAML directive", start_mark,
+                    "found extremely long version number", parser->mark);
+        }
+
+        value = value*10 + AS_DIGIT(parser->input);
 
         SKIP(parser);
@@ -2233 +2222 @@
 
     if (!length) {
-        return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
-                start_mark, "did not find expected version number");
+        return SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                "while scanning a %YAML directive", start_mark,
+                "did not find expected version number", parser->mark);
     }
 
@@ -2261 +2251 @@
     if (!CACHE(parser, 1)) goto error;
 
-    while (IS_BLANK(parser->buffer)) {
+    while (IS_BLANK(parser->input)) {
         SKIP(parser);
         if (!CACHE(parser, 1)) goto error;
@@ -2275 +2265 @@
     if (!CACHE(parser, 1)) goto error;
 
-    if (!IS_BLANK(parser->buffer)) {
-        yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
-                start_mark, "did not find expected whitespace");
+    if (!IS_BLANK(parser->input)) {
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                "while scanning a %TAG directive", start_mark,
+                "did not find expected whitespace", parser->mark);
         goto error;
     }
@@ -2283 +2274 @@
     /* Eat whitespaces. */
 
-    while (IS_BLANK(parser->buffer)) {
+    while (IS_BLANK(parser->input)) {
         SKIP(parser);
         if (!CACHE(parser, 1)) goto error;
@@ -2297 +2288 @@
     if (!CACHE(parser, 1)) goto error;
 
-    if (!IS_BLANKZ(parser->buffer)) {
-        yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
-                start_mark, "did not find expected whitespace or line break");
+    if (!IS_BLANKZ(parser->input)) {
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                "while scanning a %TAG directive", start_mark,
+                "did not find expected whitespace or line break", parser->mark);
         goto error;
     }
@@ -2322 +2314 @@
     yaml_string_t string = NULL_STRING;
 
-    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY))
+        goto error;
 
     /* Eat the indicator character. */
@@ -2334 +2327 @@
     if (!CACHE(parser, 1)) goto error;
 
-    while (IS_ALPHA(parser->buffer)) {
+    while (IS_ALPHA(parser->input)) {
         if (!READ(parser, string)) goto error;
         if (!CACHE(parser, 1)) goto error;
@@ -2349 +2342 @@
      */
 
-    if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')
-                || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',')
-                || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}')
-                || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@')
-                || CHECK(parser->buffer, '`'))) {
-        yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ?
-                "while scanning an anchor" : "while scanning an alias", start_mark,
-                "did not find expected alphabetic or numeric character");
+    if (!length || !(IS_BLANKZ(parser->input) || CHECK(parser->input, '?')
+                || CHECK(parser->input, ':') || CHECK(parser->input, ',')
+                || CHECK(parser->input, ']') || CHECK(parser->input, '}')
+                || CHECK(parser->input, '%') || CHECK(parser->input, '@')
+                || CHECK(parser->input, '`'))) {
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, type == YAML_ANCHOR_TOKEN ?
+                "while scanning an anchor" : "while scanning an alias",
+                start_mark,
+                "did not find expected alphabetic or numeric character",
+                parser->mark);
         goto error;
     }
@@ -2363 +2358 @@
 
     if (type == YAML_ANCHOR_TOKEN) {
-        ANCHOR_TOKEN_INIT(*token, string.start, start_mark, end_mark);
+        ANCHOR_TOKEN_INIT(*token, string.buffer, start_mark, end_mark);
     }
     else {
-        ALIAS_TOKEN_INIT(*token, string.start, start_mark, end_mark);
+        ALIAS_TOKEN_INIT(*token, string.buffer, start_mark, end_mark);
     }
 
@@ -2393 +2388 @@
     if (!CACHE(parser, 2)) goto error;
 
-    if (CHECK_AT(parser->buffer, '<', 1))
+    if (CHECK_AT(parser->input, '<', 1))
     {
         /* Set the handle to '' */
@@ -2413 +2408 @@
         /* Check for '>' and eat it. */
 
-        if (!CHECK(parser->buffer, '>')) {
-            yaml_parser_set_scanner_error(parser, "while scanning a tag",
-                    start_mark, "did not find the expected '>'");
+        if (!CHECK(parser->input, '>')) {
+            SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                    "while scanning a tag", start_mark,
+                    "did not find the expected '>'", parser->mark);
             goto error;
         }
@@ -2471 +2467 @@
     if (!CACHE(parser, 1)) goto error;
 
-    if (!IS_BLANKZ(parser->buffer)) {
-        yaml_parser_set_scanner_error(parser, "while scanning a tag",
-                start_mark, "did not found expected whitespace or line break");
+    if (!IS_BLANKZ(parser->input)) {
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                "while scanning a tag", start_mark,
+                "did not found expected whitespace or line break", parser->mark);
         goto error;
     }
@@ -2501 +2498 @@
     yaml_string_t string = NULL_STRING;
 
-    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY))
+        goto error;
 
     /* Check the initial '!' character. */
@@ -2507 +2505 @@
     if (!CACHE(parser, 1)) goto error;
 
-    if (!CHECK(parser->buffer, '!')) {
-        yaml_parser_set_scanner_error(parser, directive ?
+    if (!CHECK(parser->input, '!')) {
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, directive ?
                 "while scanning a tag directive" : "while scanning a tag",
-                start_mark, "did not find expected '!'");
+                start_mark, "did not find expected '!'", parser->mark);
         goto error;
     }
@@ -2522 +2520 @@
     if (!CACHE(parser, 1)) goto error;
 
-    while (IS_ALPHA(parser->buffer))
+    while (IS_ALPHA(parser->input))
     {
         if (!READ(parser, string)) goto error;
@@ -2530 +2528 @@
     /* Check if the trailing character is '!' and copy it. */
 
-    if (CHECK(parser->buffer, '!'))
+    if (CHECK(parser->input, '!'))
     {
         if (!READ(parser, string)) goto error;
@@ -2542 +2540 @@
          */
 
-        if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) {
-            yaml_parser_set_scanner_error(parser, "while parsing a tag directive",
-                    start_mark, "did not find expected '!'");
+        if (directive &&
+                !(string.buffer[0] == '!' && string.buffer[1] == '\0')) {
+            SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                    "while parsing a tag directive", start_mark,
+                    "did not find expected '!'", parser->mark);
             goto error;
         }
     }
 
-    *handle = string.start;
+    *handle = string.buffer;
 
     return 1;
@@ -2569 +2569 @@
     yaml_string_t string = NULL_STRING;
 
-    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY))
+        goto error;
 
     /* Resize the string to include the head. */
 
-    while (string.end - string.start <= (int)length) {
-        if (!yaml_string_extend(&string.start, &string.pointer, &string.end)) {
-            parser->error = YAML_MEMORY_ERROR;
+    while (string.capacity <= length) {
+        if (!yaml_string_extend(&string.buffer, &string.capacity)) {
+            MEMORY_ERROR_INIT(parser);
             goto error;
         }
@@ -2587 +2588 @@
 
     if (length > 1) {
-        memcpy(string.start, head+1, length-1);
+        memcpy(string.buffer, head+1, length-1);
         string.pointer += length-1;
     }
@@ -2603 +2604 @@
      */
 
-    while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')
-            || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?')
-            || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@')
-            || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=')
-            || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$')
-            || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '.')
-            || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~')
-            || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'')
-            || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')')
-            || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']')
-            || CHECK(parser->buffer, '%'))
+    while (IS_ALPHA(parser->input) || CHECK(parser->input, ';')
+            || CHECK(parser->input, '/') || CHECK(parser->input, '?')
+            || CHECK(parser->input, ':') || CHECK(parser->input, '@')
+            || CHECK(parser->input, '&') || CHECK(parser->input, '=')
+            || CHECK(parser->input, '+') || CHECK(parser->input, '$')
+            || CHECK(parser->input, ',') || CHECK(parser->input, '.')
+            || CHECK(parser->input, '!') || CHECK(parser->input, '~')
+            || CHECK(parser->input, '*') || CHECK(parser->input, '\'')
+            || CHECK(parser->input, '(') || CHECK(parser->input, ')')
+            || CHECK(parser->input, '[') || CHECK(parser->input, ']')
+            || CHECK(parser->input, '%'))
     {
         /* Check if it is a URI-escape sequence. */
 
-        if (CHECK(parser->buffer, '%')) {
+        if (CHECK(parser->input, '%')) {
             if (!yaml_parser_scan_uri_escapes(parser,
                         directive, start_mark, &string)) goto error;
@@ -2635 +2636 @@
             goto error;
 
-        yaml_parser_set_scanner_error(parser, directive ?
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser, directive ?
                 "while parsing a %TAG directive" : "while parsing a tag",
-                start_mark, "did not find expected tag URI");
+                start_mark, "did not find expected tag URI", parser->mark);
         goto error;
     }
 
-    *uri = string.start;
+    *uri = string.buffer;
 
     return 1;
@@ -2663 +2664 @@
 
     do {
-
         unsigned char octet = 0;
 
@@ -2670 +2670 @@
         if (!CACHE(parser, 3)) return 0;
 
-        if (!(CHECK(parser->buffer, '%')
-                    && IS_HEX_AT(parser->buffer, 1)
-                    && IS_HEX_AT(parser->buffer, 2))) {
-            return yaml_parser_set_scanner_error(parser, directive ?
+        if (!(CHECK(parser->input, '%')
+                    && IS_HEX_AT(parser->input, 1)
+                    && IS_HEX_AT(parser->input, 2))) {
+            return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, directive ?
                     "while parsing a %TAG directive" : "while parsing a tag",
-                    start_mark, "did not find URI escaped octet");
+                    start_mark, "did not find URI escaped octet", parser->mark);
         }
 
         /* Get the octet. */
 
-        octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);
+        octet = (AS_HEX_AT(parser->input, 1) << 4) + AS_HEX_AT(parser->input, 2);
 
         /* If it is the leading octet, determine the length of the UTF-8 sequence. */
@@ -2691 +2691 @@
                     (octet & 0xF8) == 0xF0 ? 4 : 0;
             if (!width) {
-                return yaml_parser_set_scanner_error(parser, directive ?
+                return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, directive ?
                         "while parsing a %TAG directive" : "while parsing a tag",
-                        start_mark, "found an incorrect leading UTF-8 octet");
+                        start_mark, "found an incorrect leading UTF-8 octet",
+                        parser->mark);
             }
         }
@@ -2701 +2702 @@
 
             if ((octet & 0xC0) != 0x80) {
-                return yaml_parser_set_scanner_error(parser, directive ?
+                return SCANNER_ERROR_WITH_CONTEXT_INIT(parser, directive ?
                         "while parsing a %TAG directive" : "while parsing a tag",
-                        start_mark, "found an incorrect trailing UTF-8 octet");
+                        start_mark, "found an incorrect trailing UTF-8 octet",
+                        parser->mark);
             }
         }
@@ -2709 +2711 @@
         /* Copy the octet and move the pointers. */
 
-        *(string->pointer++) = octet;
+        JOIN_OCTET(*string, octet);
         SKIP(parser);
         SKIP(parser);
@@ -2738 +2740 @@
     int trailing_blank = 0;
 
-    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
-    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
-    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
+    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY))
+        goto error;
+    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY))
+        goto error;
+    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY))
+        goto error;
 
     /* Eat the indicator '|' or '>'. */
@@ -2754 +2759 @@
     /* Check for a chomping indicator. */
 
-    if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-'))
+    if (CHECK(parser->input, '+') || CHECK(parser->input, '-'))
     {
         /* Set the chomping method and eat the indicator. */
 
-        chomping = CHECK(parser->buffer, '+') ? +1 : -1;
+        chomping = CHECK(parser->input, '+') ? +1 : -1;
 
         SKIP(parser);
@@ -2766 +2771 @@
         if (!CACHE(parser, 1)) goto error;
 
-        if (IS_DIGIT(parser->buffer))
+        if (IS_DIGIT(parser->input))
         {
             /* Check that the intendation is greater than 0. */
 
-            if (CHECK(parser->buffer, '0')) {
-                yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
-                        start_mark, "found an intendation indicator equal to 0");
+            if (CHECK(parser->input, '0')) {
+                SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                        "while scanning a block scalar", start_mark,
+                        "found an intendation indicator equal to 0", parser->mark);
                 goto error;
             }
@@ -2778 +2784 @@
             /* Get the intendation level and eat the indicator. */
 
-            increment = AS_DIGIT(parser->buffer);
+            increment = AS_DIGIT(parser->input);
 
             SKIP(parser);
@@ -2786 +2792 @@
     /* Do the same as above, but in the opposite order. */
 
-    else if (IS_DIGIT(parser->buffer))
+    else if (IS_DIGIT(parser->input))
     {
-        if (CHECK(parser->buffer, '0')) {
-            yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
-                    start_mark, "found an intendation indicator equal to 0");
+        if (CHECK(parser->input, '0')) {
+            SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                    "while scanning a block scalar", start_mark,
+                    "found an intendation indicator equal to 0", parser->mark);
             goto error;
         }
 
-        increment = AS_DIGIT(parser->buffer);
+        increment = AS_DIGIT(parser->input);
 
         SKIP(parser);
@@ -2800 +2807 @@
         if (!CACHE(parser, 1)) goto error;
 
-        if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) {
-            chomping = CHECK(parser->buffer, '+') ? +1 : -1;
+        if (CHECK(parser->input, '+') || CHECK(parser->input, '-')) {
+            chomping = CHECK(parser->input, '+') ? +1 : -1;
 
             SKIP(parser);
@@ -2811 +2818 @@
     if (!CACHE(parser, 1)) goto error;
 
-    while (IS_BLANK(parser->buffer)) {
+    while (IS_BLANK(parser->input)) {
         SKIP(parser);
         if (!CACHE(parser, 1)) goto error;
     }
 
-    if (CHECK(parser->buffer, '#')) {
-        while (!IS_BREAKZ(parser->buffer)) {
+    if (CHECK(parser->input, '#')) {
+        while (!IS_BREAKZ(parser->input)) {
             SKIP(parser);
             if (!CACHE(parser, 1)) goto error;
@@ -2825 +2832 @@
     /* Check if we are at the end of the line. */
 
-    if (!IS_BREAKZ(parser->buffer)) {
-        yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
-                start_mark, "did not found expected comment or line break");
+    if (!IS_BREAKZ(parser->input)) {
+        SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                "while scanning a block scalar", start_mark,
+                "did not found expected comment or line break", parser->mark);
         goto error;
     }
@@ -2833 +2841 @@
     /* Eat a line break. */
 
-    if (IS_BREAK(parser->buffer)) {
+    if (IS_BREAK(parser->input)) {
         if (!CACHE(parser, 2)) goto error;
         SKIP_LINE(parser);
@@ -2855 +2863 @@
     if (!CACHE(parser, 1)) goto error;
 
-    while ((int)parser->mark.column == indent && !IS_Z(parser->buffer))
+    while ((int)parser->mark.column == indent && !IS_Z(parser->input))
     {
         /*
@@ -2863 +2871 @@
         /* Is it a trailing whitespace? */
 
-        trailing_blank = IS_BLANK(parser->buffer);
+        trailing_blank = IS_BLANK(parser->input);
 
         /* Check if we need to fold the leading line break. */
 
-        if (!literal && (*leading_break.start == '\n')
+        if (!literal && (*leading_break.buffer == '\n')
                 && !leading_blank && !trailing_blank)
         {
             /* Do we need to join the lines by space? */
 
-            if (*trailing_breaks.start == '\0') {
+            if (*trailing_breaks.buffer == '\0') {
                 if (!STRING_EXTEND(parser, string)) goto error;
-                *(string.pointer ++) = ' ';
+                JOIN_OCTET(string, ' ');
             }
 
@@ -2891 +2899 @@
         /* Is it a leading whitespace? */
 
-        leading_blank = IS_BLANK(parser->buffer);
+        leading_blank = IS_BLANK(parser->input);
 
         /* Consume the current line. */
 
-        while (!IS_BREAKZ(parser->buffer)) {
+        while (!IS_BREAKZ(parser->input)) {
             if (!READ(parser, string)) goto error;
             if (!CACHE(parser, 1)) goto error;
@@ -2923 +2931 @@
     /* Create a token. */
 
-    SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
+    SCALAR_TOKEN_INIT(*token, string.buffer, string.pointer,
             literal ? YAML_LITERAL_SCALAR_STYLE : YAML_FOLDED_SCALAR_STYLE,
             start_mark, end_mark);
@@ -2963 +2971 @@
 
         while ((!*indent || (int)parser->mark.column < *indent)
-                && IS_SPACE(parser->buffer)) {
+                && IS_SPACE(parser->input)) {
             SKIP(parser);
             if (!CACHE(parser, 1)) return 0;
@@ -2974 +2982 @@
 
         if ((!*indent || (int)parser->mark.column < *indent)
-                && IS_TAB(parser->buffer)) {
-            return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
-                    start_mark, "found a tab character where an intendation space is expected");
+                && IS_TAB(parser->input)) {
+            return SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                    "while scanning a block scalar", start_mark,
+                    "found a tab character where an intendation space is expected",
+                    parser->mark);
         }
 
         /* Have we found a non-empty line? */
 
-        if (!IS_BREAK(parser->buffer)) break;
+        if (!IS_BREAK(parser->input)) break;
 
         /* Consume the line break. */
@@ -3019 +3029 @@
     int leading_blanks;
 
-    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
-    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
-    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
-    if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;
+    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY))
+        goto error;
+    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY))
+        goto error;
+    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY))
+        goto error;
+    if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY))
+        goto error;
 
     /* Eat the left quote. */
@@ -3039 +3053 @@
 
         if (parser->mark.column == 0 &&
-            ((CHECK_AT(parser->buffer, '-', 0) &&
-              CHECK_AT(parser->buffer, '-', 1) &&
-              CHECK_AT(parser->buffer, '-', 2)) ||
-             (CHECK_AT(parser->buffer, '.', 0) &&
-              CHECK_AT(parser->buffer, '.', 1) &&
-              CHECK_AT(parser->buffer, '.', 2))) &&
-            IS_BLANKZ_AT(parser->buffer, 3))
+            ((CHECK_AT(parser->input, '-', 0) &&
+              CHECK_AT(parser->input, '-', 1) &&
+              CHECK_AT(parser->input, '-', 2)) ||
+             (CHECK_AT(parser->input, '.', 0) &&
+              CHECK_AT(parser->input, '.', 1) &&
+              CHECK_AT(parser->input, '.', 2))) &&
+            IS_BLANKZ_AT(parser->input, 3))
         {
-            yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
-                    start_mark, "found unexpected document indicator");
+            SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                    "while scanning a quoted scalar", start_mark,
+                    "found unexpected document indicator", parser->mark);
             goto error;
         }
@@ -3054 +3069 @@
         /* Check for EOF. */
 
-        if (IS_Z(parser->buffer)) {
-            yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
-                    start_mark, "found unexpected end of stream");
+        if (IS_Z(parser->input)) {
+            SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                    "while scanning a quoted scalar", start_mark,
+                    "found unexpected end of stream", parser->mark);
             goto error;
         }
@@ -3066 +3082 @@
         leading_blanks = 0;
 
-        while (!IS_BLANKZ(parser->buffer))
+        while (!IS_BLANKZ(parser->input))
         {
             /* Check for an escaped single quote. */
 
-            if (single && CHECK_AT(parser->buffer, '\'', 0)
-                    && CHECK_AT(parser->buffer, '\'', 1))
+            if (single && CHECK_AT(parser->input, '\'', 0)
+                    && CHECK_AT(parser->input, '\'', 1))
             {
                 if (!STRING_EXTEND(parser, string)) goto error;
-                *(string.pointer++) = '\'';
+                JOIN_OCTET(string, '\'');
                 SKIP(parser);
                 SKIP(parser);
@@ -3081 +3097 @@
             /* Check for the right quote. */
 
-            else if (CHECK(parser->buffer, single ? '\'' : '"'))
+            else if (CHECK(parser->input, single ? '\'' : '"'))
             {
                 break;
@@ -3088 +3104 @@
             /* Check for an escaped line break. */
 
-            else if (!single && CHECK(parser->buffer, '\\')
-                    && IS_BREAK_AT(parser->buffer, 1))
+            else if (!single && CHECK(parser->input, '\\')
+                    && IS_BREAK_AT(parser->input, 1))
             {
                 if (!CACHE(parser, 3)) goto error;
@@ -3100 +3116 @@
             /* Check for an escape sequence. */
 
-            else if (!single && CHECK(parser->buffer, '\\'))
+            else if (!single && CHECK(parser->input, '\\'))
             {
                 size_t code_length = 0;
@@ -3108 +3124 @@
                 /* Check the escape character. */
 
-                switch (parser->buffer.pointer[1])
+                switch (OCTET_AT(parser->input, 1))
                 {
                     case '0':
-                        *(string.pointer++) = '\0';
+                        JOIN_OCTET(string, '\0');
                         break;
 
                     case 'a':
-                        *(string.pointer++) = '\x07';
+                        JOIN_OCTET(string, '\x07');
                         break;
 
                     case 'b':
-                        *(string.pointer++) = '\x08';
+                        JOIN_OCTET(string, '\x08');
                         break;
 
                     case 't':
                     case '\t':
-                        *(string.pointer++) = '\x09';
+                        JOIN_OCTET(string, '\x09');
                         break;
 
                     case 'n':
-                        *(string.pointer++) = '\x0A';
+                        JOIN_OCTET(string, '\x0A');
                         break;
 
                     case 'v':
-                        *(string.pointer++) = '\x0B';
+                        JOIN_OCTET(string, '\x0B');
                         break;
 
                     case 'f':
-                        *(string.pointer++) = '\x0C';
+                        JOIN_OCTET(string, '\x0C');
                         break;
 
                     case 'r':
-                        *(string.pointer++) = '\x0D';
+                        JOIN_OCTET(string, '\x0D');
                         break;
 
                     case 'e':
-                        *(string.pointer++) = '\x1B';
+                        JOIN_OCTET(string, '\x1B');
                         break;
 
                     case ' ':
-                        *(string.pointer++) = '\x20';
+                        JOIN_OCTET(string, '\x20');
                         break;
 
                     case '"':
-                        *(string.pointer++) = '"';
+                        JOIN_OCTET(string, '"');
                         break;
 
                     case '\'':
-                        *(string.pointer++) = '\'';
+                        JOIN_OCTET(string, '\'');
                         break;
 
                     case '\\':
-                        *(string.pointer++) = '\\';
+                        JOIN_OCTET(string, '\\');
                         break;
 
                     case 'N':   /* NEL (#x85) */
-                        *(string.pointer++) = '\xC2';
-                        *(string.pointer++) = '\x85';
+                        JOIN_OCTET(string, '\xC2');
+                        JOIN_OCTET(string, '\x85');
                         break;
 
                     case '_':   /* #xA0 */
-                        *(string.pointer++) = '\xC2';
-                        *(string.pointer++) = '\xA0';
+                        JOIN_OCTET(string, '\xC2');
+                        JOIN_OCTET(string, '\xA0');
                         break;
 
                     case 'L':   /* LS (#x2028) */
-                        *(string.pointer++) = '\xE2';
-                        *(string.pointer++) = '\x80';
-                        *(string.pointer++) = '\xA8';
+                        JOIN_OCTET(string, '\xE2');
+                        JOIN_OCTET(string, '\x80');
+                        JOIN_OCTET(string, '\xA8');
                         break;
 
                     case 'P':   /* PS (#x2029) */
-                        *(string.pointer++) = '\xE2';
-                        *(string.pointer++) = '\x80';
-                        *(string.pointer++) = '\xA9';
+                        JOIN_OCTET(string, '\xE2');
+                        JOIN_OCTET(string, '\x80');
+                        JOIN_OCTET(string, '\xA9');
                         break;
 
@@ -3198 +3214 @@
 
                     default:
-                        yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
-                                start_mark, "found unknown escape character");
+                        SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                                "while parsing a quoted scalar", start_mark,
+                                "found unknown escape character", parser->mark);
                         goto error;
                 }
@@ -3211 +3228 @@
                 {
                     unsigned int value = 0;
-                    size_t k;
+                    size_t idx;
 
                     /* Scan the character value. */
@@ -3217 +3234 @@
                     if (!CACHE(parser, code_length)) goto error;
 
-                    for (k = 0; k < code_length; k ++) {
-                        if (!IS_HEX_AT(parser->buffer, k)) {
-                            yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
-                                    start_mark, "did not find expected hexdecimal number");
+                    for (idx = 0; idx < code_length; idx ++) {
+                        if (!IS_HEX_AT(parser->input, idx)) {
+                            SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                                    "while parsing a quoted scalar", start_mark,
+                                    "did not find expected hexdecimal number",
+                                    parser->mark);
                             goto error;
                         }
-                        value = (value << 4) + AS_HEX_AT(parser->buffer, k);
+                        value = (value << 4) + AS_HEX_AT(parser->input, idx);
                     }
 
@@ -3229 +3248 @@
 
                     if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) {
-                        yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
-                                start_mark, "found invalid Unicode character escape code");
+                        SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                                "while parsing a quoted scalar", start_mark,
+                                "found invalid Unicode character escape code",
+                                parser->mark);
                         goto error;
                     }
 
                     if (value <= 0x7F) {
-                        *(string.pointer++) = value;
+                        JOIN_OCTET(string, value);
                     }
                     else if (value <= 0x7FF) {
-                        *(string.pointer++) = 0xC0 + (value >> 6);
-                        *(string.pointer++) = 0x80 + (value & 0x3F);
+                        JOIN_OCTET(string, 0xC0 + (value >> 6));
+                        JOIN_OCTET(string, 0x80 + (value & 0x3F));
                     }
                     else if (value <= 0xFFFF) {
-                        *(string.pointer++) = 0xE0 + (value >> 12);
-                        *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F);
-                        *(string.pointer++) = 0x80 + (value & 0x3F);
+                        JOIN_OCTET(string, 0xE0 + (value >> 12));
+                        JOIN_OCTET(string, 0x80 + ((value >> 6) & 0x3F));
+                        JOIN_OCTET(string, 0x80 + (value & 0x3F));
                     }
                     else {
-                        *(string.pointer++) = 0xF0 + (value >> 18);
-                        *(string.pointer++) = 0x80 + ((value >> 12) & 0x3F);
-                        *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F);
-                        *(string.pointer++) = 0x80 + (value & 0x3F);
+                        JOIN_OCTET(string, 0xF0 + (value >> 18));
+                        JOIN_OCTET(string, 0x80 + ((value >> 12) & 0x3F));
+                        JOIN_OCTET(string, 0x80 + ((value >> 6) & 0x3F));
+                        JOIN_OCTET(string, 0x80 + (value & 0x3F));
                     }
 
                     /* Advance the pointer. */
 
-                    for (k = 0; k < code_length; k ++) {
+                    for (idx = 0; idx < code_length; idx ++) {
                         SKIP(parser);
                     }
@@ -3273 +3294 @@
         /* Check if we are at the end of the scalar. */
 
-        if (CHECK(parser->buffer, single ? '\'' : '"'))
+        if (CHECK(parser->input, single ? '\'' : '"'))
             break;
 
@@ -3280 +3301 @@
         if (!CACHE(parser, 1)) goto error;
 
-        while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))
+        while (IS_BLANK(parser->input) || IS_BREAK(parser->input))
         {
-            if (IS_BLANK(parser->buffer))
+            if (IS_BLANK(parser->input))
             {
                 /* Consume a space or a tab character. */
@@ -3319 +3340 @@
             /* Do we need to fold line breaks? */
 
-            if (leading_break.start[0] == '\n') {
-                if (trailing_breaks.start[0] == '\0') {
+            if (leading_break.buffer[0] == '\n') {
+                if (trailing_breaks.buffer[0] == '\0') {
                     if (!STRING_EXTEND(parser, string)) goto error;
-                    *(string.pointer++) = ' ';
+                    JOIN_OCTET(string, ' ');
                 }
                 else {
@@ -3352 +3373 @@
     /* Create a token. */
 
-    SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
+    SCALAR_TOKEN_INIT(*token, string.buffer, string.pointer,
             single ? YAML_SINGLE_QUOTED_SCALAR_STYLE : YAML_DOUBLE_QUOTED_SCALAR_STYLE,
             start_mark, end_mark);
@@ -3387 +3408 @@
     int indent = parser->indent+1;
 
-    if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
-    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
-    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
-    if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;
+    if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY))
+        goto error;
+    if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY))
+        goto error;
+    if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY))
+        goto error;
+    if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY))
+        goto error;
 
     start_mark = end_mark = parser->mark;
@@ -3403 +3428 @@
 
         if (parser->mark.column == 0 &&
-            ((CHECK_AT(parser->buffer, '-', 0) &&
-              CHECK_AT(parser->buffer, '-', 1) &&
-              CHECK_AT(parser->buffer, '-', 2)) ||
-             (CHECK_AT(parser->buffer, '.', 0) &&
-              CHECK_AT(parser->buffer, '.', 1) &&
-              CHECK_AT(parser->buffer, '.', 2))) &&
-            IS_BLANKZ_AT(parser->buffer, 3)) break;
+            ((CHECK_AT(parser->input, '-', 0) &&
+              CHECK_AT(parser->input, '-', 1) &&
+              CHECK_AT(parser->input, '-', 2)) ||
+             (CHECK_AT(parser->input, '.', 0) &&
+              CHECK_AT(parser->input, '.', 1) &&
+              CHECK_AT(parser->input, '.', 2))) &&
+            IS_BLANKZ_AT(parser->input, 3)) break;
 
         /* Check for a comment. */
 
-        if (CHECK(parser->buffer, '#'))
+        if (CHECK(parser->input, '#'))
             break;
 
         /* Consume non-blank characters. */
 
-        while (!IS_BLANKZ(parser->buffer))
+        while (!IS_BLANKZ(parser->input))
         {
             /* Check for 'x:x' in the flow context. TODO: Fix the test "spec-08-13". */
 
             if (parser->flow_level
-                    && CHECK(parser->buffer, ':')
-                    && !IS_BLANKZ_AT(parser->buffer, 1)) {
-                yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
-                        start_mark, "found unexpected ':'");
+                    && CHECK(parser->input, ':')
+                    && !IS_BLANKZ_AT(parser->input, 1)) {
+                SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                        "while scanning a plain scalar", start_mark,
+                        "found unexpected ':'", parser->mark);
                 goto error;
             }
@@ -3432 +3458 @@
             /* Check for indicators that may end a plain scalar. */
 
-            if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))
+            if ((CHECK(parser->input, ':') && IS_BLANKZ_AT(parser->input, 1))
                     || (parser->flow_level &&
-                        (CHECK(parser->buffer, ',') || CHECK(parser->buffer, ':')
-                         || CHECK(parser->buffer, '?') || CHECK(parser->buffer, '[')
-                         || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')
-                         || CHECK(parser->buffer, '}'))))
+                        (CHECK(parser->input, ',') || CHECK(parser->input, ':')
+                         || CHECK(parser->input, '?') || CHECK(parser->input, '[')
+                         || CHECK(parser->input, ']') || CHECK(parser->input, '{')
+                         || CHECK(parser->input, '}'))))
                 break;
 
             /* Check if we need to join whitespaces and breaks. */
 
-            if (leading_blanks || whitespaces.start != whitespaces.pointer)
+            if (leading_blanks || whitespaces.pointer > 0)
             {
                 if (leading_blanks)
@@ -3448 +3474 @@
                     /* Do we need to fold line breaks? */
 
-                    if (leading_break.start[0] == '\n') {
-                        if (trailing_breaks.start[0] == '\0') {
+                    if (leading_break.buffer[0] == '\n') {
+                        if (trailing_breaks.buffer[0] == '\0') {
                             if (!STRING_EXTEND(parser, string)) goto error;
-                            *(string.pointer++) = ' ';
+                            JOIN_OCTET(string, ' ');
                         }
                         else {
@@ -3486 +3512 @@
         /* Is it the end? */
 
-        if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))
+        if (!(IS_BLANK(parser->input) || IS_BREAK(parser->input)))
             break;
 
@@ -3493 +3519 @@
         if (!CACHE(parser, 1)) goto error;
 
-        while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))
+        while (IS_BLANK(parser->input) || IS_BREAK(parser->input))
         {
-            if (IS_BLANK(parser->buffer))
+            if (IS_BLANK(parser->input))
             {
                 /* Check for tab character that abuse intendation. */
 
                 if (leading_blanks && (int)parser->mark.column < indent
-                        && IS_TAB(parser->buffer)) {
-                    yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
-                            start_mark, "found a tab character that violate intendation");
+                        && IS_TAB(parser->input)) {
+                    SCANNER_ERROR_WITH_CONTEXT_INIT(parser,
+                            "while scanning a plain scalar", start_mark,
+                            "found a tab character that violate intendation",
+                            parser->mark);
                     goto error;
                 }
@@ -3543 +3571 @@
     /* Create a token. */
 
-    SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
+    SCALAR_TOKEN_INIT(*token, string.buffer, string.pointer,
             YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark);
 
-    /* Note that we change the 'simple_key_allowed' flag. */
+    /* Note that we change the 'is_simple_key_allowed' flag. */
 
     if (leading_blanks) {
-        parser->simple_key_allowed = 1;
+        parser->is_simple_key_allowed = 1;
     }
 

libyaml/trunk/src/writer.c

@@ -6 +6 @@
  */
 
-static int
-yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem);
-
 YAML_DECLARE(int)
 yaml_emitter_flush(yaml_emitter_t *emitter);
-
-/*
- * Set the writer error and return 0.
- */
-
-static int
-yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem)
-{
-    emitter->error = YAML_WRITER_ERROR;
-    emitter->problem = problem;
-
-    return 0;
-}
 
 /*
@@ -35 +19 @@
 
     assert(emitter);    /* Non-NULL emitter object is expected. */
-    assert(emitter->write_handler); /* Write handler must be set. */
+    assert(emitter->writer);    /* Write handler must be set. */
     assert(emitter->encoding);  /* Output encoding must be set. */
-
-    emitter->buffer.last = emitter->buffer.pointer;
-    emitter->buffer.pointer = emitter->buffer.start;
 
     /* Check if the buffer is empty. */
 
-    if (emitter->buffer.start == emitter->buffer.last) {
+    if (!emitter->output.pointer) {
         return 1;
     }
+
+    /* Switch the pointer to the beginning of the buffer. */
+
+    emitter->output.capacity = emitter->output.pointer;
+    emitter->output.pointer = 0;
 
     /* If the output encoding is UTF-8, we don't need to recode the buffer. */
@@ -51 +37 @@
     if (emitter->encoding == YAML_UTF8_ENCODING)
     {
-        if (emitter->write_handler(emitter->write_handler_data,
-                    emitter->buffer.start,
-                    emitter->buffer.last - emitter->buffer.start)) {
-            emitter->buffer.last = emitter->buffer.start;
-            emitter->buffer.pointer = emitter->buffer.start;
+        if (emitter->writer(emitter->writer_data,
+                    emitter->output.buffer, emitter->output.capacity)) {
+            emitter->offset += emitter->output.capacity;
+            emitter->output.capacity = OUTPUT_BUFFER_CAPACITY;
             return 1;
         }
         else {
-            return yaml_emitter_set_writer_error(emitter, "Write error");
+            return WRITER_ERROR_INIT(emitter, "Write error", emitter->offset);
         }
     }
@@ -68 +53 @@
     high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
 
-    while (emitter->buffer.pointer != emitter->buffer.last)
+    while (emitter->output.pointer != emitter->output.capacity)
     {
         unsigned char octet;
         unsigned int width;
         unsigned int value;
-        size_t k;
+        size_t idx;
 
         /* 
@@ -82 +67 @@
         /* Read the next UTF-8 character. */
 
-        octet = emitter->buffer.pointer[0];
+        octet = OCTET(emitter->output);
 
         width = (octet & 0x80) == 0x00 ? 1 :
@@ -94 +79 @@
                 (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
 
-        for (k = 1; k < width; k ++) {
-            octet = emitter->buffer.pointer[k];
+        for (idx = 1; idx < width; idx ++) {
+            octet = OCTET_AT(emitter->output, idx);
             value = (value << 6) + (octet & 0x3F);
         }
 
-        emitter->buffer.pointer += width;
+        emitter->output.pointer += width;
 
         /* Write the character. */
@@ -105 +90 @@
         if (value < 0x10000)
         {
-            emitter->raw_buffer.last[high] = value >> 8;
-            emitter->raw_buffer.last[low] = value & 0xFF;
+            OCTET_AT(emitter->raw_output, high) = value >> 8;
+            OCTET_AT(emitter->raw_output, low) = value & 0xFF;
 
-            emitter->raw_buffer.last += 2;
+            emitter->raw_output.pointer += 2;
         }
         else
@@ -115 +100 @@
 
             value -= 0x10000;
-            emitter->raw_buffer.last[high] = 0xD8 + (value >> 18);
-            emitter->raw_buffer.last[low] = (value >> 10) & 0xFF;
-            emitter->raw_buffer.last[high+2] = 0xDC + ((value >> 8) & 0xFF);
-            emitter->raw_buffer.last[low+2] = value & 0xFF;
+            OCTET_AT(emitter->raw_output, high) = 0xD8 + (value >> 18);
+            OCTET_AT(emitter->raw_output, low) = (value >> 10) & 0xFF;
+            OCTET_AT(emitter->raw_output, high+2) = 0xDC + ((value >> 8) & 0xFF);
+            OCTET_AT(emitter->raw_output, low+2) = value & 0xFF;
 
-            emitter->raw_buffer.last += 4;
+            emitter->raw_output.pointer += 4;
         }
     }
@@ -126 +111 @@
     /* Write the raw buffer. */
 
-    if (emitter->write_handler(emitter->write_handler_data,
-                emitter->raw_buffer.start,
-                emitter->raw_buffer.last - emitter->raw_buffer.start)) {
-        emitter->buffer.last = emitter->buffer.start;
-        emitter->buffer.pointer = emitter->buffer.start;
-        emitter->raw_buffer.last = emitter->raw_buffer.start;
-        emitter->raw_buffer.pointer = emitter->raw_buffer.start;
+    if (emitter->writer(emitter->writer_data,
+                emitter->raw_output.buffer, emitter->raw_output.pointer)) {
+        emitter->output.pointer = 0;
+        emitter->output.capacity = OUTPUT_BUFFER_CAPACITY;
+        emitter->offset += emitter->raw_output.pointer;
+        emitter->raw_output.pointer = 0;
         return 1;
     }
     else {
-        return yaml_emitter_set_writer_error(emitter, "Write error");
+        return WRITER_ERROR_INIT(emitter, "Write error", emitter->offset);
     }
 }

libyaml/trunk/src/yaml_private.h

@@ -72 +72 @@
     (memset(&(error), 0, sizeof(error)),                                        \
      (error).type = (error_type),                                               \
-     (error).type.dumping.problem = (error_problem),                            \
+     (error).data.dumping.problem = (error_problem),                            \
      0)
 
@@ -105 +105 @@
     WRITING_ERROR_INIT((self)->error,YAML_WRITER_ERROR,problem,offset)
 
-#define EMITTER_ERROR_INIT(self,context,problem)                                \
+#define EMITTER_ERROR_INIT(self,problem)                                        \
     DUMPING_ERROR_INIT((self)->error,YAML_EMITTER_ERROR,problem)
 
@@ -148 +148 @@
 #define INITIAL_QUEUE_CAPACITY  16
 #define INITIAL_STRING_CAPACITY 16
-
-/*
- * Input/output buffer management.
- */
-
-#define STORAGE_INIT(self,storage,storage_capacity)                             \
-    (((storage).buffer = yaml_malloc(storage_capacity)) ?                       \
-        ((storage).pointer = (storage).length = 0,                              \
-         (buffer).capacity = (storage_capacity)                                 \
-         1) :                                                                   \
-        ((self)->error.type = YAML_MEMORY_ERROR,                                \
-         0))
-
-#define STORAGE_DEL(self,storage)                                               \
-    (yaml_free((storage).buffer),                                               \
-     (storage).pointer = (storage).length = (storage).capacity = 0)
 
 /*
@@ -183 +167 @@
         yaml_char_t *adj_buffer, size_t adj_pointer, size_t adj_capacity);
 
-#define NULL_STRING { NULL, NULL, NULL }
+#define NULL_STRING { NULL, 0, 0 }
 
 #define STRING(string,capacity)   { (string), 0, (capacity) }
@@ -460 +444 @@
 
 #define MOVE(string)    ((string).pointer += WIDTH((string)))
+
+/*
+ * Write a single octet and bump the pointer.
+ */
+
+#define JOIN_OCTET(string,octet)                                                \
+    ((string).buffer[(string).pointer++] = (octet))
 
 /*
@@ -864 +855 @@
         yaml_char_t *buffer;
         size_t pointer;
-        size_t length;
         size_t capacity;
     } input;
@@ -875 +865 @@
         unsigned char *buffer;
         size_t pointer;
-        size_t length;
         size_t capacity;
     } raw_input;
@@ -1069 +1058 @@
         yaml_char_t *buffer;
         size_t pointer;
-        size_t length;
         size_t capacity;
     } output;
@@ -1077 +1065 @@
         yaml_char_t *buffer;
         size_t pointer;
-        size_t length;
         size_t capacity;
     } raw_output;
+
+    /* The offset of the current position (in bytes). */
+    size_t offset;
 
     /* The stream encoding. */
@@ -1151 +1141 @@
     int column;
     /* If the last character was a whitespace? */
-    int whitespace;
+    int is_whitespace;
     /* If the last character was an indentation character (' ', '-', '?', ':')? */
-    int indention;
+    int is_indention;
 
     /* Anchor analysis. */

libyaml/trunk/tests/run-scanner.c

@@ -22 +22 @@
     {
         FILE *file;
-        yaml_parser_t parser;
+        yaml_parser_t *parser;
         yaml_token_t token;
         int done = 0;
@@ -34 +34 @@
         assert(file);
 
-        assert(yaml_parser_initialize(&parser));
+        assert((parser = yaml_parser_new()));
 
-        yaml_parser_set_input_file(&parser, file);
+        yaml_parser_set_file_reader(parser, file);
 
         while (!done)
         {
-            if (!yaml_parser_scan(&parser, &token)) {
+            if (!yaml_parser_scan(parser, &token)) {
                 error = 1;
                 break;
@@ -47 +47 @@
             done = (token.type == YAML_STREAM_END_TOKEN);
 
-            yaml_token_delete(&token);
+            yaml_token_destroy(&token);
 
             count ++;
         }
 
-        yaml_parser_delete(&parser);
+        yaml_parser_delete(parser);
 
         assert(!fclose(file));