static analysis

ChangeLog

 
 	[ 20140201 ]
 	* Rewrote Memory Unit Test using greatest
+	* Used C++ static analysis tool cppcheck and tried to fix
+	  its warnings
 
 	[ 20140131 ]
 	* All unit tests buildable again and no more warnings

Makefile

 
 #################################################################
 
+check:
+	cppcheck -Iinclude $(GL_DEFS) $(AUDIO_DEFS) --enable=information .
+
+fullCheck:
+	cppcheck -Iinclude $(GL_DEFS) $(AUDIO_DEFS) --enable=all --inconclusive --std=posix .
+
+#################################################################
+
 clean: clean-small clean-dep clean-doc
 
 clean-small: clean-build clean-test clean-obj 

src/MatMath.cpp

     {
         // One intersection
         mu = -b/(2*a) ;
-        intersectionA[1] = posA[0] + mu*(posB[0]-posA[0]);
-        intersectionA[2] = posA[1] + mu*(posB[1]-posA[1]);
-        intersectionA[3] = posA[2] + mu*(posB[2]-posA[2]);
+        intersectionA[0] = posA[0] + mu*(posB[0]-posA[0]);
+        intersectionA[1] = posA[1] + mu*(posB[1]-posA[1]);
+        intersectionA[2] = posA[2] + mu*(posB[2]-posA[2]);
 
         return 1;
     }
 
         // First intersection
         mu = (-b + sqrtf( square(b) - 4.0f*a*c)) / (2.0f*a);
-        intersectionA[1] = posA[0] + mu*(posB[0]-posA[0]);
-        intersectionA[2] = posA[1] + mu*(posB[1]-posA[1]);
-        intersectionA[3] = posA[2] + mu*(posB[2]-posA[2]);
+        intersectionA[0] = posA[0] + mu*(posB[0]-posA[0]);
+        intersectionA[1] = posA[1] + mu*(posB[1]-posA[1]);
+        intersectionA[2] = posA[2] + mu*(posB[2]-posA[2]);
 
         // Second intersection
         mu = (-b - sqrtf(square(b) - 4.0f*a*c)) / (2.0f*a);

src/Particle.cpp

 void Particle::Reset()
 {
     // Mongoose 2002.01.01, Ah, how old is that code?
-#ifdef OBSOLOETE
+#ifdef OBSOLETE
     _active = true;
     _life = 1.0;
     _blend = (float)(rand() % 100) / 1000.0 + 0.003;

src/Texture.cpp

         {
             delete [] image;
         }
+        delete [] swap_row;
 
         printf("glScreenShot> ERROR: Couldn't allocate image!\n");
         return;
     {
         printf("glScreenShot> ERROR: Couldn't write screenshot.\n");
         perror("glScreenShot> ERROR: ");
+        delete [] image;
+        delete [] swap_row;
         return;
     }
 
     {
         perror("glScreenShot> Disk write failed.\n");
         fclose(f);
+        delete [] image;
         return;
     }
 
     tempin = new float[original_width * original_height * components * sizeof(float)];
     tempout = new float[width * height * components * sizeof(float)];
 
-    if (!tempout || !tempin)
+    if (!tempout || !tempin || !timage)
     {
         if (tempout)
             delete [] tempout;
         if (tempin)
             delete [] tempin;
 
+        if (timage)
+            delete [] timage;
+
         printf("Oh shit out of memory!\n");
         return NULL;
     }

src/TombRaider.cpp

     sprite_seq_t *r_mesh;
     tr2_item_t *item;
 
-
+    r_mesh = Mesh();
     item = Item();
     sprite_textures = Sprite();
     sprite_sequence = SpriteSequence();

src/memory_test.cpp

 
 #ifdef DEBUG_MEMORY_RBTREE
         printf(" :%s%s)",
-                (!tree->parent) ? " (root, " : " ("),
-            (tree->color == RB_BLACK) ? "black" : "red");
+                ((!tree->parent) ? " (root, " : " ("),
+            ((tree->color == RB_BLACK) ? "black" : "red"));
 #endif
     }
 

test/greatest.h

 /* Handle command-line arguments, etc. */
 #define GREATEST_MAIN_BEGIN()                                           \
     do {                                                                \
-        int i = 0;                                                      \
+        int _i = 0;                                                      \
         memset(&greatest_info, 0, sizeof(greatest_info));               \
         if (greatest_info.width == 0) {                                 \
             greatest_info.width = GREATEST_DEFAULT_WIDTH;               \
         }                                                               \
-        for (i = 1; i < argc; i++) {                                    \
-            if (0 == strcmp("-t", argv[i])) {                           \
-                if (argc <= i + 1) {                                    \
+        for (_i = 1; _i < argc; _i++) {                                    \
+            if (0 == strcmp("-t", argv[_i])) {                           \
+                if (argc <= _i + 1) {                                    \
                     greatest_usage(argv[0]);                            \
                     exit(EXIT_FAILURE);                                 \
                 }                                                       \
-                greatest_info.test_filter = argv[i+1];                  \
-                i++;                                                    \
-            } else if (0 == strcmp("-s", argv[i])) {                    \
-                if (argc <= i + 1) {                                    \
+                greatest_info.test_filter = argv[_i+1];                  \
+                _i++;                                                    \
+            } else if (0 == strcmp("-s", argv[_i])) {                    \
+                if (argc <= _i + 1) {                                    \
                     greatest_usage(argv[0]);                            \
                     exit(EXIT_FAILURE);                                 \
                 }                                                       \
-                greatest_info.suite_filter = argv[i+1];                 \
-                i++;                                                    \
-            } else if (0 == strcmp("-f", argv[i])) {                    \
+                greatest_info.suite_filter = argv[_i+1];                 \
+                _i++;                                                    \
+            } else if (0 == strcmp("-f", argv[_i])) {                    \
                 greatest_info.flags |= GREATEST_FLAG_FIRST_FAIL;        \
-            } else if (0 == strcmp("-v", argv[i])) {                    \
+            } else if (0 == strcmp("-v", argv[_i])) {                    \
                 greatest_info.flags |= GREATEST_FLAG_VERBOSE;           \
-            } else if (0 == strcmp("-l", argv[i])) {                    \
+            } else if (0 == strcmp("-l", argv[_i])) {                    \
                 greatest_info.flags |= GREATEST_FLAG_LIST_ONLY;         \
-            } else if (0 == strcmp("-h", argv[i])) {                    \
+            } else if (0 == strcmp("-h", argv[_i])) {                    \
                 greatest_usage(argv[0]);                                \
                 exit(EXIT_SUCCESS);                                     \
             } else {                                                    \
                 fprintf(GREATEST_STDOUT,                                \
-                    "Unknown argument '%s'\n", argv[i]);                \
+                    "Unknown argument '%s'\n", argv[_i]);                \
                 greatest_usage(argv[0]);                                \
                 exit(EXIT_FAILURE);                                     \
             }                                                           \

test/memory_test.cpp

 extern rbtree_t *MEMORY_INFO;
 bool check_red_black_tree(rbtree_t *current, bool valid, bool strict);
 
+int *i, *j, *k;
+float *l, *m, *n;
+
+void integerTeardown(void *) {
+    free(i);
+    free(j);
+    free(k);
+}
+
+void floatTeardown(void *) {
+    free(l);
+    free(m);
+    free(n);
+}
+
 TEST singleInteger() {
-    int *i = new int;
+    i = new int;
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), sizeof(int));
 
     delete i;
+    i = NULL;
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), 0);
     PASS();
 }
 
 TEST arrayInteger() {
-    int *i = new int[3];
+    i = new int[3];
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), 3 * sizeof(int));
 
     delete [] i;
+    i = NULL;
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), 0);
     PASS();
 }
 
 TEST arrayCombinedInteger() {
-    int *i = new int[3];
-    int *j = new int;
-    int *k = new int[3];
+    i = new int[3];
+    j = new int;
+    k = new int[3];
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), 7 * sizeof(int));
 
     delete [] i;
     delete j;
     delete [] k;
+    i = NULL;
+    j = NULL;
+    k = NULL;
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), 0);
     PASS();
 }
 
 SUITE(integerSuite) {
+    SET_TEARDOWN(integerTeardown, NULL);
     RUN_TEST(singleInteger);
     RUN_TEST(arrayInteger);
     RUN_TEST(arrayCombinedInteger);
 }
 
 TEST singleFloat() {
-    float *i = new float;
+    l = new float;
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), sizeof(float));
 
-    delete i;
+    delete l;
+    l = NULL;
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), 0);
     PASS();
 }
 
 TEST arrayFloat() {
-    float *i = new float[3];
+    l = new float[3];
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), 3 * sizeof(float));
 
-    delete [] i;
+    delete [] l;
+    l = NULL;
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), 0);
     PASS();
 }
 
 TEST arrayCombinedFloat() {
-    float *i = new float[3];
-    float *j = new float;
-    float *k = new float[3];
+    l = new float[3];
+    m = new float;
+    n = new float[3];
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), 7 * sizeof(float));
 
-    delete [] i;
-    delete j;
-    delete [] k;
+    delete [] l;
+    delete m;
+    delete [] n;
+    l = NULL;
+    m = NULL;
+    n = NULL;
     ASSERTm("No valid red-black tree!", check_red_black_tree(MEMORY_INFO, true, true));
     ASSERT_EQm("Memory-Tracking faulty!", memory_used(MEMORY_USED_BY_PROGRAM), 0);
     PASS();
 }
 
 SUITE(floatSuite) {
+    SET_TEARDOWN(floatTeardown, NULL);
     RUN_TEST(singleFloat);
     RUN_TEST(arrayFloat);
     RUN_TEST(arrayCombinedFloat);