Update upstream source from tag 'upstream/0.2.2'

[libyaml.git] / src / parser.c

diff --git a/src/parser.c b/src/parser.c
index 020d5d6898a0af388388f038359702c03c88f47c..1198c73704a108ebb0ce3ccd5e9d249d81c55123 100644 (file)
--- a/src/parser.c
+++ b/src/parser.c
@@ -172,12 +172,14 @@ yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event)
     assert(parser);     /* Non-NULL parser object is expected. */
     assert(event);      /* Non-NULL event object is expected. */
 
+    /* Erase the event object. */
+
+    memset(event, 0, sizeof(yaml_event_t));
+
     /* No events after the end of the stream or error. */
 
     if (parser->stream_end_produced || parser->error ||
             parser->state == YAML_PARSE_END_STATE) {
-        memset(event, 0, sizeof(yaml_event_t));
-
         return 1;
     }
 
@@ -317,7 +319,7 @@ yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event)
 
     if (token->type != YAML_STREAM_START_TOKEN) {
         return yaml_parser_set_parser_error(parser,
-                "did not found expected <stream-start>", token->start_mark);
+                "did not find expected <stream-start>", token->start_mark);
     }
 
     parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
@@ -350,6 +352,17 @@ yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,
     token = PEEK_TOKEN(parser);
     if (!token) return 0;
 
+    /* Parse extra document end indicators. */
+
+    if (!implicit)
+    {
+        while (token->type == YAML_DOCUMENT_END_TOKEN) {
+            SKIP_TOKEN(parser);
+            token = PEEK_TOKEN(parser);
+            if (!token) return 0;
+        }
+    }
+
     /* Parse an implicit document. */
 
     if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN &&
@@ -380,7 +393,7 @@ yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,
         if (!token) goto error;
         if (token->type != YAML_DOCUMENT_START_TOKEN) {
             yaml_parser_set_parser_error(parser,
-                    "did not found expected <document start>", token->start_mark);
+                    "did not find expected <document start>", token->start_mark);
             goto error;
         }
         if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
@@ -465,11 +478,9 @@ yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event)
 
     start_mark = end_mark = token->start_mark;
 
-    while (token->type == YAML_DOCUMENT_END_TOKEN) {
+    if (token->type == YAML_DOCUMENT_END_TOKEN) {
         end_mark = token->end_mark;
         SKIP_TOKEN(parser);
-        token = PEEK_TOKEN(parser);
-        if (!token) return 0;
         implicit = 0;
     }
 
@@ -594,7 +605,7 @@ yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
                     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);
+                        tag = YAML_MALLOC(prefix_len+suffix_len+1);
                         if (!tag) {
                             parser->error = YAML_MEMORY_ERROR;
                             goto error;
@@ -674,7 +685,7 @@ yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
                 return 1;
             }
             else if (anchor || tag) {
-                yaml_char_t *value = yaml_malloc(1);
+                yaml_char_t *value = YAML_MALLOC(1);
                 if (!value) {
                     parser->error = YAML_MEMORY_ERROR;
                     goto error;
@@ -690,7 +701,7 @@ yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
                 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);
+                        "did not find expected node content", token->start_mark);
                 goto error;
             }
         }
@@ -749,7 +760,7 @@ yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
     else if (token->type == YAML_BLOCK_END_TOKEN)
     {
         parser->state = POP(parser, parser->states);
-        POP(parser, parser->marks);
+        (void)POP(parser, parser->marks);
         SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
         SKIP_TOKEN(parser);
         return 1;
@@ -759,7 +770,7 @@ yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
     {
         return yaml_parser_set_parser_error_context(parser,
                 "while parsing a block collection", POP(parser, parser->marks),
-                "did not found expected '-' indicator", token->start_mark);
+                "did not find expected '-' indicator", token->start_mark);
     }
 }
 
@@ -858,7 +869,7 @@ yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
     else if (token->type == YAML_BLOCK_END_TOKEN)
     {
         parser->state = POP(parser, parser->states);
-        POP(parser, parser->marks);
+        (void)POP(parser, parser->marks);
         MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
         SKIP_TOKEN(parser);
         return 1;
@@ -868,7 +879,7 @@ yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
     {
         return yaml_parser_set_parser_error_context(parser,
                 "while parsing a block mapping", POP(parser, parser->marks),
-                "did not found expected key", token->start_mark);
+                "did not find expected key", token->start_mark);
     }
 }
 
@@ -961,7 +972,7 @@ yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
             else {
                 return yaml_parser_set_parser_error_context(parser,
                         "while parsing a flow sequence", POP(parser, parser->marks),
-                        "did not found expected ',' or ']'", token->start_mark);
+                        "did not find expected ',' or ']'", token->start_mark);
             }
         }
 
@@ -983,7 +994,7 @@ yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
     }
 
     parser->state = POP(parser, parser->states);
-    POP(parser, parser->marks);
+    (void)POP(parser, parser->marks);
     SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
     SKIP_TOKEN(parser);
     return 1;
@@ -1112,7 +1123,7 @@ yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
             else {
                 return yaml_parser_set_parser_error_context(parser,
                         "while parsing a flow mapping", POP(parser, parser->marks),
-                        "did not found expected ',' or '}'", token->start_mark);
+                        "did not find expected ',' or '}'", token->start_mark);
             }
         }
 
@@ -1143,7 +1154,7 @@ yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
     }
 
     parser->state = POP(parser, parser->states);
-    POP(parser, parser->marks);
+    (void)POP(parser, parser->marks);
     MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
     SKIP_TOKEN(parser);
     return 1;
@@ -1197,7 +1208,7 @@ yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event,
 {
     yaml_char_t *value;
 
-    value = yaml_malloc(1);
+    value = YAML_MALLOC(1);
     if (!value) {
         parser->error = YAML_MEMORY_ERROR;
         return 0;
@@ -1234,7 +1245,7 @@ yaml_parser_process_directives(yaml_parser_t *parser,
     } tag_directives = { NULL, NULL, NULL };
     yaml_token_t *token;
 
-    if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE))
+    if (!STACK_INIT(parser, tag_directives, yaml_tag_directive_t*))
         goto error;
 
     token = PEEK_TOKEN(parser);
@@ -1250,12 +1261,12 @@ yaml_parser_process_directives(yaml_parser_t *parser,
                 goto error;
             }
             if (token->data.version_directive.major != 1
-                    && token->data.version_directive.minor != 1) {
+                    || token->data.version_directive.minor != 1) {
                 yaml_parser_set_parser_error(parser,
                         "found incompatible YAML document", token->start_mark);
                 goto error;
             }
-            version_directive = yaml_malloc(sizeof(yaml_version_directive_t));
+            version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t);
             if (!version_directive) {
                 parser->error = YAML_MEMORY_ERROR;
                 goto error;
@@ -1265,10 +1276,10 @@ yaml_parser_process_directives(yaml_parser_t *parser,
         }
 
         else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) {
-            yaml_tag_directive_t value = {
-                token->data.tag_directive.handle,
-                token->data.tag_directive.prefix
-            };
+            yaml_tag_directive_t value;
+            value.handle = token->data.tag_directive.handle;
+            value.prefix = token->data.tag_directive.prefix;
+
             if (!yaml_parser_append_tag_directive(parser, value, 0,
                         token->start_mark))
                 goto error;
@@ -1280,7 +1291,7 @@ yaml_parser_process_directives(yaml_parser_t *parser,
         token = PEEK_TOKEN(parser);
         if (!token) goto error;
     }
-    
+
     for (default_tag_directive = default_tag_directives;
             default_tag_directive->handle; default_tag_directive++) {
         if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1,
@@ -1305,6 +1316,8 @@ yaml_parser_process_directives(yaml_parser_t *parser,
         STACK_DEL(parser, tag_directives);
     }
 
+    if (!version_directive_ref)
+        yaml_free(version_directive);
     return 1;
 
 error:
@@ -1318,6 +1331,10 @@ error:
     return 0;
 }
 
+/*
+ * Append a tag directive to the directives stack.
+ */
+
 static int
 yaml_parser_append_tag_directive(yaml_parser_t *parser,
         yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark)
@@ -1335,8 +1352,8 @@ yaml_parser_append_tag_directive(yaml_parser_t *parser,
         }
     }
 
-    copy.handle = (yaml_char_t *)yaml_strdup((char *)value.handle);
-    copy.prefix = (yaml_char_t *)yaml_strdup((char *)value.prefix);
+    copy.handle = yaml_strdup(value.handle);
+    copy.prefix = yaml_strdup(value.prefix);
     if (!copy.handle || !copy.prefix) {
         parser->error = YAML_MEMORY_ERROR;
         goto error;