Implement half of the parsers.

git-svn-id: http://svn.pyyaml.org/libyaml/trunk@202 18f92427-320e-0410-9341-c67f048884a3

3 files changed, 772 insertions, 6 deletions

diff --git a/include/yaml.h b/include/yaml.h
index 0a2bab0..f195bf4 100644
--- a/include/yaml.h
+++ b/include/yaml.h
@@ -666,7 +666,7 @@ yaml_scalar_event_new(yaml_char_t *anchor, yaml_char_t *tag,
  */
 
 YAML_DECLARE(yaml_event_t *)
-yaml_sequence_start_new(yaml_char_t *anchor, yaml_char_t *tag,
+yaml_sequence_start_event_new(yaml_char_t *anchor, yaml_char_t *tag,
         int implicit, yaml_sequence_style_t style,
         yaml_mark_t start_mark, yaml_mark_t end_mark);
 
@@ -680,7 +680,7 @@ yaml_sequence_start_new(yaml_char_t *anchor, yaml_char_t *tag,
  */
 
 YAML_DECLARE(yaml_event_t *)
-yaml_sequence_end_new(yaml_mark_t start_mark, yaml_mark_t end_mark);
+yaml_sequence_end_event_new(yaml_mark_t start_mark, yaml_mark_t end_mark);
 
 /**
  * Create a new @c YAML_MAPPING_START_EVENT event.
@@ -696,7 +696,7 @@ yaml_sequence_end_new(yaml_mark_t start_mark, yaml_mark_t end_mark);
  */
 
 YAML_DECLARE(yaml_event_t *)
-yaml_mapping_start_new(yaml_char_t *anchor, yaml_char_t *tag,
+yaml_mapping_start_event_new(yaml_char_t *anchor, yaml_char_t *tag,
         int implicit, yaml_mapping_style_t style,
         yaml_mark_t start_mark, yaml_mark_t end_mark);
 
@@ -710,7 +710,7 @@ yaml_mapping_start_new(yaml_char_t *anchor, yaml_char_t *tag,
  */
 
 YAML_DECLARE(yaml_event_t *)
-yaml_mapping_end_new(yaml_mark_t start_mark, yaml_mark_t end_mark);
+yaml_mapping_end_event_new(yaml_mark_t start_mark, yaml_mark_t end_mark);
 
 /**
  * Destroy an event object.
diff --git a/src/api.c b/src/api.c
index 51a1b31..81d515b 100644
--- a/src/api.c
+++ b/src/api.c
@@ -625,7 +625,7 @@ yaml_scalar_event_new(yaml_char_t *anchor, yaml_char_t *tag,
  */
 
 YAML_DECLARE(yaml_event_t *)
-yaml_sequence_start_new(yaml_char_t *anchor, yaml_char_t *tag,
+yaml_sequence_start_event_new(yaml_char_t *anchor, yaml_char_t *tag,
         int implicit, yaml_sequence_style_t style,
         yaml_mark_t start_mark, yaml_mark_t end_mark)
 {
@@ -657,7 +657,7 @@ yaml_sequence_end_event_new(yaml_mark_t start_mark, yaml_mark_t end_mark)
  */
 
 YAML_DECLARE(yaml_event_t *)
-yaml_mapping_start_new(yaml_char_t *anchor, yaml_char_t *tag,
+yaml_mapping_start_event_new(yaml_char_t *anchor, yaml_char_t *tag,
         int implicit, yaml_mapping_style_t style,
         yaml_mark_t start_mark, yaml_mark_t end_mark)
 {
diff --git a/src/parser.c b/src/parser.c
index 6928193..03a9ebb 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -58,6 +58,33 @@ YAML_DECLARE(yaml_event_t *)
 yaml_parser_peek_event(yaml_parser_t *parser);
 
 /*
+ * 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);
+
+/*
+ * Buffers and lists.
+ */
+
+static int
+yaml_parser_resize_list(yaml_parser_t *parser, void **buffer, size_t *size,
+        size_t item_size);
+
+static int
+yaml_parser_append_state(yaml_parser_t *parser, yaml_parser_state_t state);
+
+static int
+yaml_parser_append_mark(yaml_parser_t *parser, yaml_mark_t mark);
+
+/*
  * State functions.
  */
 
@@ -111,6 +138,16 @@ static yaml_event_t *
 yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, int empty);
 
 /*
+ * Utility functions.
+ */
+
+static yaml_event_t *
+yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_mark_t mark);
+
+static int
+yaml_parser_process_directives(yaml_parser_t *parser);
+
+/*
  * Get the next event and advance the parser.
  */
 
@@ -153,6 +190,69 @@ yaml_parser_peek_event(yaml_parser_t *parser)
 }
 
 /*
+ * 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;
+}
+
+/*
+ * Push a state to the state stack.
+ */
+
+static int
+yaml_parser_append_state(yaml_parser_t *parser, yaml_parser_state_t state)
+{
+    if (parser->states_length == parser->states_size-1) {
+        if (!yaml_parser_resize_list(parser, (void **)&parser->states,
+                    &parser->states_size, sizeof(yaml_parser_state_t)))
+            return 0;
+    }
+
+    parser->states[parser->states_length++] = state;
+    return 1;
+}
+
+/*
+ * Push a mark to the mark stack.
+ */
+
+static int
+yaml_parser_append_mark(yaml_parser_t *parser, yaml_mark_t mark)
+{
+    if (parser->marks_length == parser->marks_size-1) {
+        if (!yaml_parser_resize_list(parser, (void **)&parser->marks,
+                    &parser->marks_size, sizeof(yaml_mark_t)))
+            return 0;
+    }
+
+    parser->marks[parser->marks_length++] = mark;
+    return 1;
+}
+
+/*
  * State dispatcher.
  */
 
@@ -235,3 +335,669 @@ yaml_parser_state_machine(yaml_parser_t *parser)
     assert(1);
 }
 
+/*
+ * Parse the production:
+ * stream   ::= STREAM-START implicit_document? explicit_document* STREAM-END
+ *              ************
+ */
+
+static yaml_event_t *
+yaml_parser_parse_stream_start(yaml_parser_t *parser)
+{
+    yaml_token_t *token;
+    yaml_event_t *event;
+
+    token = yaml_parser_get_token(parser);
+    if (!token) return NULL;
+
+    assert(token->type == YAML_STREAM_START_TOKEN);
+
+    event = yaml_stream_start_event_new(token->data.stream_start.encoding,
+            token->start_mark, token->start_mark);
+    yaml_token_delete(token);
+    if (!event) {
+        parser->error = YAML_MEMORY_ERROR;
+        return NULL;
+    }
+
+    parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
+
+    return event;
+}
+
+/*
+ * Parse the productions:
+ * implicit_document    ::= block_node DOCUMENT-END*
+ *                          *
+ * explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+ *                          *************************
+ */
+
+static yaml_event_t *
+yaml_parser_parse_document_start(yaml_parser_t *parser, int implicit)
+{
+    yaml_token_t *token;
+    yaml_event_t *event;
+
+    token = yaml_parser_peek_token(parser);
+    if (!token) return NULL;
+
+    /* Parse an implicit document. */
+
+    if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN &&
+            token->type != YAML_TAG_DIRECTIVE_TOKEN &&
+            token->type != YAML_DOCUMENT_START_TOKEN &&
+            token->type != YAML_STREAM_END_TOKEN)
+    {
+        if (!yaml_parser_process_directives(parser)) return NULL;
+        if (!yaml_parser_append_state(parser, YAML_PARSE_DOCUMENT_END_STATE))
+            return NULL;
+        parser->state = YAML_PARSE_BLOCK_NODE_STATE;
+        event = yaml_document_start_event_new(
+                parser->version_directive, parser->tag_directives, 1,
+                token->start_mark, token->start_mark);
+        if (!event) return NULL;
+        return event;
+    }
+
+    /* Parse an explicit document. */
+
+    else if (token->type != YAML_STREAM_END_TOKEN)
+    {
+        yaml_mark_t start_mark, end_mark;
+        start_mark = token->start_mark;
+        if (!yaml_parser_process_directives(parser)) return NULL;
+        token = yaml_parser_peek_token(parser);
+        if (!token) return NULL;
+        if (token->type != YAML_DOCUMENT_START_TOKEN) {
+            yaml_parser_set_parser_error(parser,
+                    "did not found expected <document start>", token->start_mark);
+            return NULL;
+        }
+        token = yaml_parser_get_token(parser);
+        end_mark = token->end_mark;
+        yaml_token_delete(token);
+        if (!yaml_parser_append_state(parser, YAML_PARSE_DOCUMENT_END_STATE))
+            return NULL;
+        parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE;
+        event = yaml_document_start_event_new(
+                parser->version_directive, parser->tag_directives, 0,
+                start_mark, end_mark);
+        if (!event) return NULL;
+        return event;
+    }
+
+    /* Parse the stream end. */
+
+    else
+    {
+        token = yaml_parser_get_token(parser);
+        parser->state = YAML_PARSE_END_STATE;
+        event = yaml_stream_end_event_new(token->start_mark, token->end_mark);
+        yaml_token_delete(token);
+        return event;
+    }
+}
+
+/*
+ * Parse the productions:
+ * explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+ *                                                    ***********
+ */
+
+static yaml_event_t *
+yaml_parser_parse_document_content(yaml_parser_t *parser)
+{
+    yaml_token_t *token;
+
+    token = yaml_parser_peek_token(parser);
+    if (!token) return NULL;
+
+    if (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
+            token->type == YAML_TAG_DIRECTIVE_TOKEN ||
+            token->type == YAML_DOCUMENT_START_TOKEN ||
+            token->type == YAML_DOCUMENT_END_TOKEN ||
+            token->type == YAML_STREAM_END_TOKEN) {
+        parser->state = parser->states[--parser->states_length];
+        return yaml_parser_process_empty_scalar(parser, token->start_mark);
+    }
+    else {
+        return yaml_parser_parse_node(parser, 1, 0);
+    }
+}
+
+/*
+ * Parse the productions:
+ * implicit_document    ::= block_node DOCUMENT-END*
+ *                                     *************
+ * explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+ *                                                                *************
+ */
+
+static yaml_event_t *
+yaml_parser_parse_document_end(yaml_parser_t *parser)
+{
+    yaml_token_t *token;
+    yaml_event_t *event;
+    yaml_mark_t start_mark, end_mark;
+    int implicit = 1;
+
+    token = yaml_parser_peek_token(parser);
+    if (!token) return NULL;
+
+    start_mark = end_mark = token->start_mark;
+
+    while (token->type == YAML_DOCUMENT_END_TOKEN) {
+        end_mark = token->end_mark;
+        yaml_token_delete(yaml_parser_get_token(parser));
+        token = yaml_parser_peek_token(parser);
+        if (!token) return NULL;
+        implicit = 0;
+    }
+
+    event = yaml_document_end_event_new(implicit, start_mark, end_mark);
+    if (!event) {
+        parser->error = YAML_MEMORY_ERROR;
+        return NULL;
+    }
+    return event;
+}
+
+/*
+ * Parse the productions:
+ * block_node_or_indentless_sequence    ::=
+ *                          ALIAS
+ *                          *****
+ *                          | properties (block_content | indentless_block_sequence)?
+ *                            **********  *
+ *                          | block_content | indentless_block_sequence
+ *                            *
+ * block_node           ::= ALIAS
+ *                          *****
+ *                          | properties block_content?
+ *                            ********** *
+ *                          | block_content
+ *                            *
+ * flow_node            ::= ALIAS
+ *                          *****
+ *                          | properties flow_content?
+ *                            ********** *
+ *                          | flow_content
+ *                            *
+ * properties           ::= TAG ANCHOR? | ANCHOR TAG?
+ *                          *************************
+ * block_content        ::= block_collection | flow_collection | SCALAR
+ *                                                               ******
+ * flow_content         ::= flow_collection | SCALAR
+ *                                            ******
+ */
+
+static yaml_event_t *
+yaml_parser_parse_node(yaml_parser_t *parser,
+        int block, int indentless_sequence)
+{
+    yaml_token_t *token;
+    yaml_event_t *event;
+    yaml_char_t *anchor = NULL;
+    yaml_char_t *tag_handle = NULL;
+    yaml_char_t *tag_suffix = NULL;
+    yaml_char_t *tag = NULL;
+    yaml_mark_t start_mark, end_mark, tag_mark;
+    int implicit;
+
+    token = yaml_parser_peek_token(parser);
+    if (!token) return NULL;
+
+    if (token->type == YAML_ALIAS_TOKEN)
+    {
+        token = yaml_parser_get_token(parser);
+        event = yaml_alias_event_new(token->data.alias.value,
+                token->start_mark, token->end_mark);
+        if (!event) {
+            yaml_token_delete(token);
+            parser->error = YAML_MEMORY_ERROR;
+            return NULL;
+        }
+        yaml_free(token);
+        return event;
+    }
+
+    else
+    {
+        start_mark = end_mark = token->start_mark;
+
+        if (token->type == YAML_ANCHOR_TOKEN)
+        {
+            token = yaml_parser_get_token(parser);
+            anchor = token->data.anchor.value;
+            start_mark = token->start_mark;
+            end_mark = token->end_mark;
+            yaml_free(token);
+            token = yaml_parser_peek_token(parser);
+            if (!token) goto error;
+            if (token->type == YAML_TAG_TOKEN)
+            {
+                token = yaml_parser_get_token(parser);
+                tag_handle = token->data.tag.handle;
+                tag_suffix = token->data.tag.suffix;
+                tag_mark = token->start_mark;
+                end_mark = token->end_mark;
+                yaml_free(token);
+                token = yaml_parser_peek_token(parser);
+                if (!token) goto error;
+            }
+        }
+        else if (token->type == YAML_TAG_TOKEN)
+        {
+            token = yaml_parser_get_token(parser);
+            tag_handle = token->data.tag.handle;
+            tag_suffix = token->data.tag.suffix;
+            start_mark = tag_mark = token->start_mark;
+            end_mark = token->end_mark;
+            yaml_free(token);
+            token = yaml_parser_peek_token(parser);
+            if (!token) goto error;
+            if (token->type == YAML_ANCHOR_TOKEN)
+            {
+                token = yaml_parser_get_token(parser);
+                anchor = token->data.anchor.value;
+                end_mark = token->end_mark;
+                yaml_free(token);
+                token = yaml_parser_peek_token(parser);
+                if (!token) goto error;
+            }
+        }
+
+        if (tag_handle) {
+            if (!*tag_handle) {
+                tag = tag_suffix;
+                yaml_free(tag_handle);
+                tag_handle = tag_suffix = NULL;
+            }
+            else {
+                yaml_tag_directive_t **tag_directive = parser->tag_directives;
+                for (tag_directive = parser->tag_directives;
+                        *tag_directive; tag_directive++) {
+                    if (strcmp((char *)(*tag_directive)->handle, (char *)tag_handle) == 0) {
+                        size_t prefix_len = strlen((char *)(*tag_directive)->prefix);
+                        size_t suffix_len = strlen((char *)tag_suffix);
+                        tag = yaml_malloc(prefix_len+suffix_len+1);
+                        if (!tag) {
+                            parser->error = YAML_MEMORY_ERROR;
+                            goto error;
+                        }
+                        memcpy(tag, (*tag_directive)->handle, prefix_len);
+                        memcpy(tag+prefix_len, tag_suffix, suffix_len);
+                        tag[prefix_len+suffix_len] = '\0';
+                        yaml_free(tag_handle);
+                        yaml_free(tag_suffix);
+                        tag_handle = tag_suffix = NULL;
+                        break;
+                    }
+                }
+                if (*tag_directive) {
+                    yaml_parser_set_parser_error_context(parser,
+                            "while parsing a node", start_mark,
+                            "found undefined tag handle", tag_mark);
+                    goto error;
+                }
+            }
+        }
+
+        implicit = (!tag || !*tag);
+        if (indentless_sequence && token->type == YAML_BLOCK_ENTRY_TOKEN) {
+            end_mark = token->end_mark;
+            parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
+            event = yaml_sequence_start_event_new(anchor, tag, implicit,
+                    YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
+            if (!event) goto error;
+        }
+        else {
+            if (token->type == YAML_SCALAR_TOKEN) {
+                int plain_implicit = 0;
+                int quoted_implicit = 0;
+                token = yaml_parser_get_token(parser);
+                end_mark = token->end_mark;
+                if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag)
+                        || strcmp((char *)tag, "!") == 0) {
+                    plain_implicit = 1;
+                }
+                else if (!tag) {
+                    quoted_implicit = 1;
+                }
+                parser->state = parser->states[--parser->states_length];
+                event = yaml_scalar_event_new(anchor, tag,
+                        token->data.scalar.value, token->data.scalar.length,
+                        plain_implicit, quoted_implicit,
+                        token->data.scalar.style, start_mark, end_mark);
+                if (!event) {
+                    parser->error = YAML_MEMORY_ERROR;
+                    yaml_token_delete(token);
+                    goto error;
+                }
+                yaml_free(token);
+            }
+            else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) {
+                end_mark = token->end_mark;
+                parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
+                event = yaml_sequence_start_event_new(anchor, tag, implicit,
+                        YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark);
+                if (!event) {
+                    parser->error = YAML_MEMORY_ERROR;
+                    goto error;
+                }
+            }
+            else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) {
+                end_mark = token->end_mark;
+                parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;
+                event = yaml_mapping_start_event_new(anchor, tag, implicit,
+                        YAML_FLOW_MAPPING_STYLE, start_mark, end_mark);
+                if (!event) {
+                    parser->error = YAML_MEMORY_ERROR;
+                    goto error;
+                }
+            }
+            else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) {
+                end_mark = token->end_mark;
+                parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;
+                event = yaml_sequence_start_event_new(anchor, tag, implicit,
+                        YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
+                if (!event) {
+                    parser->error = YAML_MEMORY_ERROR;
+                    goto error;
+                }
+            }
+            else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) {
+                end_mark = token->end_mark;
+                parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;
+                event = yaml_mapping_start_event_new(anchor, tag, implicit,
+                        YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark);
+                if (!event) {
+                    parser->error = YAML_MEMORY_ERROR;
+                    goto error;
+                }
+            }
+            else if (anchor || tag) {
+                yaml_char_t *value = yaml_malloc(1);
+                if (!value) {
+                    parser->error = YAML_MEMORY_ERROR;
+                    goto error;
+                }
+                value[0] = '\0';
+                event = yaml_scalar_event_new(anchor, tag, value, 0,
+                        implicit, 0, YAML_PLAIN_SCALAR_STYLE,
+                        start_mark, end_mark);
+                if (!event) {
+                    yaml_free(value);
+                    parser->error = YAML_MEMORY_ERROR;
+                    goto error;
+                }
+            }
+            else {
+                yaml_parser_set_parser_error_context(parser,
+                        (block ? "while parsing a block node"
+                         : "while parsing a flow node"), start_mark,
+                        "did not found expected node content", token->start_mark);
+                goto error;
+            }
+            return event;
+        }
+    }
+
+error:
+    yaml_free(anchor);
+    yaml_free(tag_handle);
+    yaml_free(tag_suffix);
+    yaml_free(tag);
+
+    return NULL;
+}
+
+/*
+ * Parse the productions:
+ * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+ *                    ********************  *********** *             *********
+ */
+
+static yaml_event_t *
+yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser, int first)
+{
+    yaml_token_t *token;
+    yaml_event_t *event;
+
+    if (first) {
+        token = yaml_parser_get_token(parser);
+        if (!yaml_parser_append_mark(parser, token->start_mark)) {
+            yaml_token_delete(token);
+            return NULL;
+        }
+        yaml_token_delete(token);
+    }
+
+    token = yaml_parser_get_token(parser);
+    if (!token) return NULL;
+
+    if (token->type == YAML_BLOCK_ENTRY_TOKEN)
+    {
+        yaml_mark_t mark = token->end_mark;
+        yaml_token_delete(token);
+        token = yaml_parser_peek_token(parser);
+        if (!token) return NULL;
+        if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
+                token->type != YAML_BLOCK_END_TOKEN) {
+            if (!yaml_parser_append_state(parser,
+                        YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE))
+                return NULL;
+            return yaml_parser_parse_node(parser, 1, 0);
+        }
+        else {
+            parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
+            return yaml_parser_process_empty_scalar(parser, mark);
+        }
+    }
+
+    else if (token->type == YAML_BLOCK_END_TOKEN)
+    {
+        parser->state = parser->states[--parser->states_length];
+        event = yaml_sequence_end_event_new(token->start_mark, token->end_mark);
+        yaml_token_delete(token);
+        if (!event) {
+            parser->error = YAML_MEMORY_ERROR;
+            return NULL;
+        }
+        return event;
+    }
+
+    else
+    {
+        yaml_parser_set_parser_error_context(parser,
+                "while parsing a block collection", parser->marks[parser->marks_length-1],
+                "did not found expected '-' indicator", token->start_mark);
+        yaml_token_delete(token);
+        return NULL;
+    }
+}
+
+/*
+ * Parse the productions:
+ * indentless_sequence  ::= (BLOCK-ENTRY block_node?)+
+ *                           *********** *
+ */
+
+static yaml_event_t *
+yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser)
+{
+    yaml_token_t *token;
+    yaml_event_t *event;
+
+    token = yaml_parser_peek_token(parser);
+    if (!token) return NULL;
+
+    if (token->type == YAML_BLOCK_ENTRY_TOKEN)
+    {
+        yaml_mark_t mark = token->end_mark;
+        yaml_token_delete(yaml_parser_get_token(parser));
+        token = yaml_parser_peek_token(parser);
+        if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
+                token->type != YAML_BLOCK_END_TOKEN) {
+            if (!yaml_parser_append_state(parser,
+                        YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE))
+                return NULL;
+            return yaml_parser_parse_node(parser, 1, 0);
+        }
+        else {
+            parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
+            return yaml_parser_process_empty_scalar(parser, mark);
+        }
+    }
+
+    else
+    {
+        parser->state = parser->states[--parser->states_length];
+        event = yaml_sequence_end_event_new(token->start_mark, token->start_mark);
+        if (!event) {
+            parser->error = YAML_MEMORY_ERROR;
+            return NULL;
+        }
+        return event;
+    }
+}
+
+/*
+ * Parse the productions:
+ * block_mapping        ::= BLOCK-MAPPING_START
+ *                          *******************
+ *                          ((KEY block_node_or_indentless_sequence?)?
+ *                            *** *
+ *                          (VALUE block_node_or_indentless_sequence?)?)*
+ *
+ *                          BLOCK-END
+ *                          *********
+ */
+
+static yaml_event_t *
+yaml_parser_parse_block_mapping_key(yaml_parser_t *parser, int first)
+{
+    yaml_token_t *token;
+    yaml_event_t *event;
+
+    if (first) {
+        token = yaml_parser_get_token(parser);
+        if (!yaml_parser_append_mark(parser, token->start_mark)) {
+            yaml_token_delete(token);
+            return NULL;
+        }
+        yaml_token_delete(token);
+    }
+
+    token = yaml_parser_get_token(parser);
+    if (!token) return NULL;
+
+    if (token->type == YAML_KEY_TOKEN)
+    {
+        yaml_mark_t mark = token->end_mark;
+        yaml_token_delete(token);
+        token = yaml_parser_peek_token(parser);
+        if (!token) return NULL;
+        if (token->type != YAML_KEY_TOKEN &&
+                token->type != YAML_VALUE_TOKEN &&
+                token->type != YAML_BLOCK_END_TOKEN) {
+            if (!yaml_parser_append_state(parser,
+                        YAML_PARSE_BLOCK_MAPPING_VALUE_STATE))
+                return NULL;
+            return yaml_parser_parse_node(parser, 1, 1);
+        }
+        else {
+            parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
+            return yaml_parser_process_empty_scalar(parser, mark);
+        }
+    }
+
+    else if (token->type == YAML_BLOCK_END_TOKEN)
+    {
+        parser->state = parser->states[--parser->states_length];
+        event = yaml_sequence_end_event_new(token->start_mark, token->end_mark);
+        yaml_token_delete(token);
+        if (!event) {
+            parser->error = YAML_MEMORY_ERROR;
+            return NULL;
+        }
+        return event;
+    }
+
+    else
+    {
+        yaml_parser_set_parser_error_context(parser,
+                "while parsing a block mapping", parser->marks[parser->marks_length-1],
+                "did not found expected key", token->start_mark);
+        yaml_token_delete(token);
+        return NULL;
+    }
+}
+
+/*
+ * Parse the productions:
+ * block_mapping        ::= BLOCK-MAPPING_START
+ *
+ *                          ((KEY block_node_or_indentless_sequence?)?
+ *
+ *                          (VALUE block_node_or_indentless_sequence?)?)*
+ *                           ***** *
+ *                          BLOCK-END
+ *
+ */
+
+static yaml_event_t *
+yaml_parser_parse_block_mapping_value(yaml_parser_t *parser)
+{
+    yaml_token_t *token;
+    yaml_event_t *event;
+
+    token = yaml_parser_peek_token(parser);
+    if (!token) return NULL;
+
+    if (token->type == YAML_VALUE_TOKEN)
+    {
+        yaml_mark_t mark = token->end_mark;
+        yaml_token_delete(yaml_parser_get_token(parser));
+        token = yaml_parser_peek_token(parser);
+        if (!token) return NULL;
+        if (token->type != YAML_KEY_TOKEN &&
+                token->type != YAML_VALUE_TOKEN &&
+                token->type != YAML_BLOCK_END_TOKEN) {
+            if (!yaml_parser_append_state(parser,
+                        YAML_PARSE_BLOCK_MAPPING_KEY_STATE))
+                return NULL;
+            return yaml_parser_parse_node(parser, 1, 1);
+        }
+        else {
+            parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
+            return yaml_parser_process_empty_scalar(parser, mark);
+        }
+    }
+
+    else
+    {
+        parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
+        return yaml_parser_process_empty_scalar(parser, token->start_mark);
+    }
+}
+
+static yaml_event_t *
+yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser, int first);
+
+static yaml_event_t *
+yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser);
+
+static yaml_event_t *
+yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser);
+
+static yaml_event_t *
+yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser);
+
+static yaml_event_t *
+yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser, int first);
+
+static yaml_event_t *
+yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, int empty);
+