Changeset 263 for libyaml/trunk/src/scanner.c

Timestamp:

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

Author:

xi

Message:

Completed the first phase of API refactoring.

Files:

• libyaml/trunk/src/scanner.c (modified) (131 diffs)

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;
     }