Changeset 263

Timestamp:

12/27/07 07:05:17 (4 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;