Fix additional for loop declarations for gnu89 support

This builds on the for loop changes merged from #68, making the same
changes to the unit test suite.

Fixes #67

Author: ludocode

src/mpack/mpack-reader.c

@@ -1097,11 +1097,12 @@ static void mpack_print_element(mpack_reader_t* reader, mpack_print_t* print, si
     // We read some bytes from bin and ext so we can print its prefix in hex.
     char buffer[MPACK_PRINT_BYTE_COUNT];
     size_t count = 0;
+    size_t i, j;
 
     switch (val.type) {
         case mpack_type_str:
             mpack_print_append_cstr(print, "\"");
-            for (size_t i = 0; i < val.v.l; ++i) {
+            for (i = 0; i < val.v.l; ++i) {
                 char c;
                 mpack_read_bytes(reader, &c, 1);
                 if (mpack_reader_error(reader) != mpack_ok)
@@ -1119,8 +1120,8 @@ static void mpack_print_element(mpack_reader_t* reader, mpack_print_t* print, si
 
         case mpack_type_array:
             mpack_print_append_cstr(print, "[\n");
-            for (size_t i = 0; i < val.v.n; ++i) {
-                for (size_t j = 0; j < depth + 1; ++j)
+            for (i = 0; i < val.v.n; ++i) {
+                for (j = 0; j < depth + 1; ++j)
                     mpack_print_append_cstr(print, "    ");
                 mpack_print_element(reader, print, depth + 1);
                 if (mpack_reader_error(reader) != mpack_ok)
@@ -1129,16 +1130,16 @@ static void mpack_print_element(mpack_reader_t* reader, mpack_print_t* print, si
                     mpack_print_append_cstr(print, ",");
                 mpack_print_append_cstr(print, "\n");
             }
-            for (size_t i = 0; i < depth; ++i)
+            for (i = 0; i < depth; ++i)
                 mpack_print_append_cstr(print, "    ");
             mpack_print_append_cstr(print, "]");
             mpack_done_array(reader);
             return;
 
         case mpack_type_map:
             mpack_print_append_cstr(print, "{\n");
-            for (size_t i = 0; i < val.v.n; ++i) {
-                for (size_t j = 0; j < depth + 1; ++j)
+            for (i = 0; i < val.v.n; ++i) {
+                for (j = 0; j < depth + 1; ++j)
                     mpack_print_append_cstr(print, "    ");
                 mpack_print_element(reader, print, depth + 1);
                 if (mpack_reader_error(reader) != mpack_ok)
@@ -1151,7 +1152,7 @@ static void mpack_print_element(mpack_reader_t* reader, mpack_print_t* print, si
                     mpack_print_append_cstr(print, ",");
                 mpack_print_append_cstr(print, "\n");
             }
-            for (size_t i = 0; i < depth; ++i)
+            for (i = 0; i < depth; ++i)
                 mpack_print_append_cstr(print, "    ");
             mpack_print_append_cstr(print, "}");
             mpack_done_map(reader);
@@ -1182,7 +1183,8 @@ static void mpack_print_element(mpack_reader_t* reader, mpack_print_t* print, si
 }
 
 static void mpack_print_and_destroy(mpack_reader_t* reader, mpack_print_t* print, size_t depth) {
-    for (size_t i = 0; i < depth; ++i)
+    size_t i;
+    for (i = 0; i < depth; ++i)
         mpack_print_append_cstr(print, "    ");
     mpack_print_element(reader, print, depth);
 

test/test-buffer.c

@@ -246,7 +246,8 @@ static void test_write_buffer_values(mpack_writer_t* writer) {
 
 #if MPACK_EXPECT
 static void test_expect_buffer(void) {
-    for (size_t i = 0; i < sizeof(test_buffer_sizes) / sizeof(test_buffer_sizes[0]); ++i) {
+    size_t i;
+    for (i = 0; i < sizeof(test_buffer_sizes) / sizeof(test_buffer_sizes[0]); ++i) {
 
         // initialize the reader with our buffer reader function
         mpack_reader_t reader;
@@ -268,7 +269,8 @@ static void test_expect_buffer(void) {
 
 #if MPACK_WRITER
 static void test_write_buffer(void) {
-    for (size_t i = 0; i < sizeof(test_buffer_sizes) / sizeof(test_buffer_sizes[0]); ++i) {
+    size_t i;
+    for (i = 0; i < sizeof(test_buffer_sizes) / sizeof(test_buffer_sizes[0]); ++i) {
         size_t size = test_buffer_sizes[i];
         size_t output_size = 0xffff;
         char* output = (char*)malloc(output_size);
@@ -300,7 +302,8 @@ static void test_write_buffer(void) {
 
 #if MPACK_READER
 static void test_inplace_buffer(void) {
-    for (size_t i = 0; i < sizeof(test_buffer_sizes) / sizeof(test_buffer_sizes[0]); ++i) {
+    size_t i;
+    for (i = 0; i < sizeof(test_buffer_sizes) / sizeof(test_buffer_sizes[0]); ++i) {
 
         // initialize the reader with our buffer reader function
         mpack_reader_t reader;
@@ -321,7 +324,8 @@ static void test_inplace_buffer(void) {
         static const char* ref = "abcdefghijklmn";
         const char* val;
         char r[15];
-        for (size_t j = 0; j < 15; ++j) {
+        size_t j;
+        for (j = 0; j < 15; ++j) {
             mpack_tag_t peek = mpack_peek_tag(&reader);
             tag = mpack_read_tag(&reader);
             TEST_TRUE(mpack_tag_equal(peek, tag), "peeked tag does not match read tag");

test/test-builder.c

@@ -107,7 +107,8 @@ static void test_builder_deep(void) {
     size_t pos = 0;
     int depth = 2;//50;
 
-    for (int i = 0; i < depth; ++i) {
+    int i;
+    for (i = 0; i < depth; ++i) {
         //mpack_build_map(&writer);
         mpack_start_map(&writer, 2);
         expected[pos++] = '\x82';
@@ -128,7 +129,7 @@ static void test_builder_deep(void) {
     mpack_write_bool(&writer, true);
     expected[pos++] = '\xc3';
 
-    for (int i = 0; i < depth; ++i) {
+    for (i = 0; i < depth; ++i) {
         mpack_complete_array(&writer);
         mpack_write_int(&writer, 1);
         expected[pos++] = '\x01';
@@ -172,12 +173,14 @@ static void test_builder_large(void) {
     size_t pos = 0;
     int depth = 6;
 
-    for (int i = 0; i < depth; ++i) {
+    int i;
+    for (i = 0; i < depth; ++i) {
         mpack_build_map(&writer);
         expected[pos++] = '\xde';
         expected[pos++] = '\x00';
         expected[pos++] = '\x32';
-        for (size_t j = 0; j < 99; ++j) {
+        size_t j;
+        for (j = 0; j < 99; ++j) {
             mpack_write_int(&writer, -1);
             expected[pos++] = '\xff';
         }
@@ -186,7 +189,7 @@ static void test_builder_large(void) {
     mpack_write_int(&writer, -1);
     expected[pos++] = '\xff';
 
-    for (int i = 0; i < depth; ++i) {
+    for (i = 0; i < depth; ++i) {
         mpack_complete_map(&writer);
     }
 
@@ -219,7 +222,8 @@ static void test_builder_content(void) {
     mpack_write_bin(&writer, rid, sizeof(rid));
     expected[pos++] = '\xc4';
     expected[pos++] = '\x10';
-    for (size_t i = 0; i < 16; ++i)
+    size_t i;
+    for (i = 0; i < 16; ++i)
         expected[pos++] = '\x00';
 
     mpack_write_cstr(&writer, "type");
@@ -284,7 +288,7 @@ static void test_builder_content(void) {
     mpack_write_bin(&writer, rid, sizeof(rid));
     expected[pos++] = '\xc4';
     expected[pos++] = '\x10';
-    for (size_t i = 0; i < 16; ++i)
+    for (i = 0; i < 16; ++i)
         expected[pos++] = '\x00';
 
     mpack_write_cstr(&writer, "pass");
@@ -307,14 +311,14 @@ static void test_builder_content(void) {
 
     /*
     printf("actual %zi expected %zi\n", used, pos);
-    for (size_t i = 0; i < used; ++i) {
+    for (i = 0; i < used; ++i) {
         printf("%02hhx ", buf[i]);
         if (((i+1) % 16)==0)
             printf("\n");
     }
     printf("\n");
     printf("\n");
-    for (size_t i = 0; i < pos; ++i) {
+    for (i = 0; i < pos; ++i) {
         printf("%02hhx ", expected[i]);
         if (((i+1) % 16)==0)
             printf("\n");
@@ -355,7 +359,8 @@ static void test_builder_strings_length(uint32_t length) {
     memset(str, 'a', length);
     size_t depth = 2;
 
-    for (size_t i = 0; i < depth; ++i) {
+    size_t i;
+    for (i = 0; i < depth; ++i) {
         mpack_build_array(&writer);
         expected[pos++] = '\x93';
         mpack_write_str(&writer, str, length);
@@ -365,7 +370,7 @@ static void test_builder_strings_length(uint32_t length) {
     mpack_write_str(&writer, str, length);
     test_builder_add_expected_str(expected, &pos, str, length);
 
-    for (size_t i = 0; i < depth; ++i) {
+    for (i = 0; i < depth; ++i) {
         mpack_write_str(&writer, str, length);
         test_builder_add_expected_str(expected, &pos, str, length);
         mpack_complete_array(&writer);
@@ -376,14 +381,14 @@ static void test_builder_strings_length(uint32_t length) {
 
     /*
     printf("actual %zi expected %zi\n", used, pos);
-    for (size_t i = 0; i < used; ++i) {
+    for (i = 0; i < used; ++i) {
         printf("%02hhx ", buf[i]);
         if (((i+1) % 16)==0)
             printf("\n");
     }
     printf("\n");
     printf("\n");
-    for (size_t i = 0; i < pos; ++i) {
+    for (i = 0; i < pos; ++i) {
         printf("%02hhx ", expected[i]);
         if (((i+1) % 16)==0)
             printf("\n");

test/test-expect.c

@@ -1216,7 +1216,8 @@ static void test_expect_streaming() {
         "hello\x93\xc3\xa6""world!\xc2\xce\xff\xff\xff\xff";
 
     size_t sizes[] = {1, 2, 3, 5, 7, 11};
-    for (size_t i = 0; i < sizeof(sizes) / sizeof(*sizes); ++i) {
+    size_t i;
+    for (i = 0; i < sizeof(sizes) / sizeof(*sizes); ++i) {
 
         test_expect_stream_t context = {data, sizeof(data) - 1, sizes[i]};
         mpack_reader_t reader;

test/test-file.c

@@ -95,7 +95,8 @@ static void test_file_write_bytes(mpack_writer_t* writer, mpack_tag_t tag) {
 
 static void test_file_write_elements(mpack_writer_t* writer, mpack_tag_t tag) {
     mpack_write_tag(writer, tag);
-    for (size_t i = 0; i < tag.v.n; ++i) {
+    size_t i;
+    for (i = 0; i < tag.v.n; ++i) {
         if (tag.type == mpack_type_map)
             mpack_write_nil(writer);
         mpack_write_nil(writer);
@@ -160,10 +161,11 @@ static void test_file_write_contents(mpack_writer_t* writer) {
     mpack_finish_array(writer);
 
     // test deep nesting
-    for (int i = 0; i < nesting_depth; ++i)
+    int i;
+    for (i = 0; i < nesting_depth; ++i)
         mpack_start_array(writer, 1);
     mpack_write_nil(writer);
-    for (int i = 0; i < nesting_depth; ++i)
+    for (i = 0; i < nesting_depth; ++i)
         mpack_finish_array(writer);
 
     mpack_finish_array(writer);
@@ -188,7 +190,8 @@ static void test_file_write_failures(void) {
     int count = UINT16_MAX / 20;
     mpack_writer_init_filename(&writer, "/dev/full");
     mpack_start_array(&writer, (uint32_t)count);
-    for (int i = 0; i < count; ++i)
+    int i;
+    for (i = 0; i < count; ++i)
         mpack_write_cstr(&writer, quick_brown_fox);
     mpack_finish_array(&writer);
     TEST_WRITER_DESTROY_ERROR(&writer, mpack_error_io);
@@ -257,10 +260,11 @@ static bool test_file_write_failure(void) {
     mpack_finish_array(&writer);
 
     // test deep nesting
-    for (int i = 0; i < nesting_depth; ++i)
+    int i;
+    for (i = 0; i < nesting_depth; ++i)
         mpack_start_array(&writer, 1);
     mpack_write_nil(&writer);
-    for (int i = 0; i < nesting_depth; ++i)
+    for (i = 0; i < nesting_depth; ++i)
         mpack_finish_array(&writer);
 
     mpack_finish_array(&writer);
@@ -390,7 +394,8 @@ static void test_file_expect_bytes(mpack_reader_t* reader, mpack_tag_t tag) {
 
 static void test_file_expect_elements(mpack_reader_t* reader, mpack_tag_t tag) {
     mpack_expect_tag(reader, tag);
-    for (size_t i = 0; i < tag.v.n; ++i) {
+    size_t i;
+    for (i = 0; i < tag.v.n; ++i) {
         if (tag.type == mpack_type_map)
             mpack_expect_nil(reader);
         mpack_expect_nil(reader);
@@ -457,10 +462,11 @@ static void test_file_read_contents(mpack_reader_t* reader) {
     test_file_expect_elements(reader, mpack_tag_map(UINT16_MAX + 1));
     mpack_done_array(reader);
 
-    for (int i = 0; i < nesting_depth; ++i)
+    int i;
+    for (i = 0; i < nesting_depth; ++i)
         mpack_expect_array_match(reader, 1);
     mpack_expect_nil(reader);
-    for (int i = 0; i < nesting_depth; ++i)
+    for (i = 0; i < nesting_depth; ++i)
         mpack_done_array(reader);
 
     mpack_done_array(reader);
@@ -529,7 +535,8 @@ static void test_file_read_streaming(void) {
     // than read by a single call to the fill function.
 
     size_t sizes[] = {1, 2, 3, 5, 7, 11};
-    for (size_t i = 0; i < sizeof(sizes) / sizeof(*sizes); ++i) {
+    size_t i;
+    for (i = 0; i < sizeof(sizes) / sizeof(*sizes); ++i) {
 
         FILE* file = fopen(test_filename, "rb");
         TEST_TRUE(file != NULL, "failed to open file! filename %s", test_filename);
@@ -657,7 +664,8 @@ static void test_file_node_bytes(mpack_node_t node, mpack_tag_t tag) {
 
 static void test_file_node_elements(mpack_node_t node, mpack_tag_t tag) {
     TEST_TRUE(mpack_tag_equal(tag, mpack_node_tag(node)));
-    for (size_t i = 0; i < tag.v.n; ++i) {
+    size_t i;
+    for (i = 0; i < tag.v.n; ++i) {
         if (tag.type == mpack_type_map) {
             mpack_node_nil(mpack_node_map_key_at(node, i));
             mpack_node_nil(mpack_node_map_value_at(node, i));
@@ -728,7 +736,8 @@ static void test_file_node_contents(mpack_node_t root) {
     test_file_node_elements(mpack_node_array_at(node, 4), mpack_tag_map(UINT16_MAX + 1));
 
     node = mpack_node_array_at(root, 6);
-    for (int i = 0; i < nesting_depth; ++i)
+    int i;
+    for (i = 0; i < nesting_depth; ++i)
         node = mpack_node_array_at(node, 0);
     TEST_TRUE(mpack_ok == mpack_node_error(node));
     mpack_node_nil(node);
@@ -825,7 +834,8 @@ static void test_file_node_stream() {
 
     size_t steps[] = {11, 23, 32, 127, 369, 4096, SIZE_MAX};
 
-    for (size_t i = 0; i < sizeof(steps) / sizeof(steps[0]); ++i) {
+    size_t i;
+    for (i = 0; i < sizeof(steps) / sizeof(steps[0]); ++i) {
         stream.pos = 0;
         stream.step = steps[i];
 
@@ -839,7 +849,8 @@ static void test_file_node_stream() {
                 mpack_error_to_string(mpack_tree_error(&tree)));
 
         // We try parsing the same tree a dozen times repeatedly with this step size.
-        for (int j = 0; j < 12; ++j) {
+        int j;
+        for (j = 0; j < 12; ++j) {
             mpack_tree_parse(&tree);
             TEST_TRUE(mpack_tree_error(&tree) == mpack_ok, "tree parsing failed: %s",
                     mpack_error_to_string(mpack_tree_error(&tree)));
@@ -921,7 +932,8 @@ static bool test_file_node_failure(void) {
     }
 
     node = mpack_node_array_at(root, 1);
-    for (int i = 0; i < nesting_depth; ++i)
+    int i;
+    for (i = 0; i < nesting_depth; ++i)
         node = mpack_node_array_at(node, 0);
     TEST_TRUE(mpack_ok == mpack_node_error(node));
     mpack_node_nil(node);

test/test-node.c

@@ -1060,7 +1060,8 @@ static void test_node_read_deep_stack(void) {
     char buf[4096];
 
     uint8_t* p = (uint8_t*)buf;
-    for (int i = 0; i < depth; ++i) {
+    int i;
+    for (i = 0; i < depth; ++i) {
         *p++ = 0x81; // one pair map
         *p++ = 0x04; // key four
         *p++ = 0x91; // value one element array
@@ -1073,7 +1074,7 @@ static void test_node_read_deep_stack(void) {
 
     #ifdef MPACK_MALLOC
     mpack_node_t node = mpack_tree_root(&tree);
-    for (int i = 0; i < depth; ++i) {
+    for (i = 0; i < depth; ++i) {
         TEST_TRUE(mpack_tree_error(&tree) == mpack_ok, "error at depth %i", i);
         TEST_TRUE(mpack_node_map_count(node) == 1, "error at depth %i", i);
         TEST_TRUE(mpack_node_u8(mpack_node_map_key_at(node, 0)) == 4, "error at depth %i", i);
@@ -1177,7 +1178,8 @@ static bool test_node_multiple_allocs(bool stream, size_t stream_read_size) {
     TEST_TRUE(mpack_tree_error(&tree) == mpack_ok);
 
     TEST_TRUE(10 == mpack_node_array_length(mpack_tree_root(&tree)));
-    for (size_t i = 0; i < 10; ++i)
+    size_t i;
+    for (i = 0; i < 10; ++i)
         TEST_TRUE(i + 1 == mpack_node_uint(mpack_node_array_at(mpack_tree_root(&tree), i)));
     TEST_TRUE(mpack_tree_error(&tree) == mpack_ok);