Fix some leaks, segfaults and warnings.

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

6 files changed, 90 insertions, 50 deletions

diff --git a/src/api.c b/src/api.c
index 0dd3c42..23f4ff2 100644
--- a/src/api.c
+++ b/src/api.c
@@ -368,6 +368,9 @@ yaml_token_delete(yaml_token_t *token)
         case YAML_SCALAR_TOKEN:
             yaml_free(token->data.scalar.value);
             break;
+
+        default:
+            break;
     }
 
     memset(token, 0, sizeof(yaml_token_t));
@@ -416,6 +419,9 @@ yaml_event_delete(yaml_event_t *event)
             yaml_free(event->data.mapping_start.anchor);
             yaml_free(event->data.mapping_start.tag);
             break;
+
+        default:
+            break;
     }
 
     memset(event, 0, sizeof(yaml_event_t));
diff --git a/src/parser.c b/src/parser.c
index fe9e171..2b81b0c 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -363,6 +363,8 @@ yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event)
         default:
             assert(1);      /* Invalid state. */
     }
+
+    return 0;
 }
 
 /*
@@ -1358,12 +1360,16 @@ yaml_parser_process_directives(yaml_parser_t *parser,
     if (tag_directives_start_ref) {
         if (STACK_EMPTY(parser, tag_directives)) {
             *tag_directives_start_ref = *tag_directives_end_ref = NULL;
+            STACK_DEL(parser, tag_directives);
         }
         else {
             *tag_directives_start_ref = tag_directives.start;
-            *tag_directives_end_ref = tag_directives.end;
+            *tag_directives_end_ref = tag_directives.top;
         }
     }
+    else {
+        STACK_DEL(parser, tag_directives);
+    }
 
     return 1;
 
@@ -1384,7 +1390,6 @@ yaml_parser_append_tag_directive(yaml_parser_t *parser,
 {
     yaml_tag_directive_t *tag_directive;
     yaml_tag_directive_t copy = { NULL, NULL };
-    int length;
 
     for (tag_directive = parser->tag_directives.start;
             tag_directive != parser->tag_directives.top; tag_directive ++) {
diff --git a/src/reader.c b/src/reader.c
index 99a51db..ea189c2 100644
--- a/src/reader.c
+++ b/src/reader.c
@@ -186,10 +186,10 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
 
         while (parser->raw_buffer.pointer != parser->raw_buffer.last)
         {
-            unsigned int value, value2;
+            unsigned int value = 0, value2 = 0;
             int incomplete = 0;
             unsigned char octet;
-            unsigned int width;
+            unsigned int width = 0;
             int k, low, high;
             int raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer;
 
@@ -366,7 +366,7 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
 
                         /* Get the next character. */
 
-                        unsigned int value2 = parser->raw_buffer.pointer[low+2]
+                        value2 = parser->raw_buffer.pointer[low+2]
                             + (parser->raw_buffer.pointer[high+2] << 8);
 
                         /* Check for a low surrogate area. */
@@ -386,6 +386,9 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
                     }
 
                     break;
+
+                default:
+                    assert(1);      /* Impossible. */
             }
 
             /* Check if the raw buffer contains enough bytes to form a character. */
diff --git a/src/scanner.c b/src/scanner.c
index 90a8979..a9b78ff 100644
--- a/src/scanner.c
+++ b/src/scanner.c
@@ -3601,7 +3601,7 @@ yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token)
     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;
 
-    start_mark = parser->mark;
+    start_mark = end_mark = parser->mark;
 
     /* Consume the content of the plain scalar. */
 
diff --git a/tests/run-parser.c b/tests/run-parser.c
index 16f4ce1..8c1a5db 100644
--- a/tests/run-parser.c
+++ b/tests/run-parser.c
@@ -7,39 +7,52 @@
 int
 main(int argc, char *argv[])
 {
-    FILE *file;
-    yaml_parser_t parser;
-    yaml_event_t event;
-    int done = 0;
-    int count = 0;
-
-    if (argc != 2) {
-        printf("Usage: %s file.yaml\n", argv[0]);
+    int number;
+
+    if (argc < 2) {
+        printf("Usage: %s file1.yaml ...\n", argv[0]);
         return 0;
     }
-    file = fopen(argv[1], "rb");
-    assert(file);
 
-    assert(yaml_parser_initialize(&parser));
+    for (number = 1; number < argc; number ++)
+    {
+        FILE *file;
+        yaml_parser_t parser;
+        yaml_event_t event;
+        int done = 0;
+        int count = 0;
+        int error = 0;
 
-    yaml_parser_set_input_file(&parser, file);
+        printf("[%d] Parsing '%s': ", number, argv[number]);
+        fflush(stdout);
 
-    while (!done)
-    {
-        assert(yaml_parser_parse(&parser, &event));
+        file = fopen(argv[number], "rb");
+        assert(file);
 
-        done = (event.type == YAML_STREAM_END_EVENT);
+        assert(yaml_parser_initialize(&parser));
 
-        yaml_event_delete(&event);
+        yaml_parser_set_input_file(&parser, file);
 
-        count ++;
-    }
+        while (!done)
+        {
+            if (!yaml_parser_parse(&parser, &event)) {
+                error = 1;
+                break;
+            }
 
-    yaml_parser_delete(&parser);
+            done = (event.type == YAML_STREAM_END_EVENT);
 
-    fclose(file);
+            yaml_event_delete(&event);
 
-    printf("Parsing the file '%s': %d events\n", argv[1], count);
+            count ++;
+        }
+
+        yaml_parser_delete(&parser);
+
+        assert(!fclose(file));
+
+        printf("%s (%d events)\n", (error ? "FAILURE" : "SUCCESS"), count);
+    }
 
     return 0;
 }
diff --git a/tests/run-scanner.c b/tests/run-scanner.c
index e3a67f2..2c8d33e 100644
--- a/tests/run-scanner.c
+++ b/tests/run-scanner.c
@@ -7,39 +7,52 @@
 int
 main(int argc, char *argv[])
 {
-    FILE *file;
-    yaml_parser_t parser;
-    yaml_token_t token;
-    int done = 0;
-    int count = 0;
-
-    if (argc != 2) {
-        printf("Usage: %s file.yaml\n", argv[0]);
+    int number;
+
+    if (argc < 2) {
+        printf("Usage: %s file1.yaml ...\n", argv[0]);
         return 0;
     }
-    file = fopen(argv[1], "rb");
-    assert(file);
 
-    assert(yaml_parser_initialize(&parser));
+    for (number = 1; number < argc; number ++)
+    {
+        FILE *file;
+        yaml_parser_t parser;
+        yaml_token_t token;
+        int done = 0;
+        int count = 0;
+        int error = 0;
 
-    yaml_parser_set_input_file(&parser, file);
+        printf("[%d] Scanning '%s': ", number, argv[number]);
+        fflush(stdout);
 
-    while (!done)
-    {
-        assert(yaml_parser_scan(&parser, &token));
+        file = fopen(argv[number], "rb");
+        assert(file);
 
-        done = (token.type == YAML_STREAM_END_TOKEN);
+        assert(yaml_parser_initialize(&parser));
 
-        yaml_token_delete(&token);
+        yaml_parser_set_input_file(&parser, file);
 
-        count ++;
-    }
+        while (!done)
+        {
+            if (!yaml_parser_scan(&parser, &token)) {
+                error = 1;
+                break;
+            }
 
-    yaml_parser_delete(&parser);
+            done = (token.type == YAML_STREAM_END_TOKEN);
 
-    fclose(file);
+            yaml_token_delete(&token);
 
-    printf("Parsing the file '%s': %d tokens\n", argv[1], count);
+            count ++;
+        }
+
+        yaml_parser_delete(&parser);
+
+        assert(!fclose(file));
+
+        printf("%s (%d tokens)\n", (error ? "FAILURE" : "SUCCESS"), count);
+    }
 
     return 0;
 }