Reenabled some warnings

ChangeLog

 	* The menu map list can now be stepped per folder with the
 	  right and left arrows.
 	* Methods wrapping printf-style functions now get compiler warnings
+	* Reenabled some warnings and fixed them
 
 	[ 20140216 ]
 	* Removed the FastCard option. Not necessary on todays hardware?!

Makefile

 ###############################################################
 CC=gcc
 WARNINGS=-Weverything -Wno-padded -Wno-packed
-WARNINGS+=-Wno-documentation-unknown-command
-WARNINGS+=-Wno-covered-switch-default -Wno-global-constructors
-WARNINGS+=-Wno-exit-time-destructors -Wno-c++98-compat-pedantic
-WARNINGS+=-Wno-disabled-macro-expansion -Wno-missing-variable-declarations
-WARNINGS+=-Wno-missing-prototypes -Wno-pedantic
+WARNINGS+=-Wno-global-constructors -Wno-exit-time-destructors
+WARNINGS+=-Wno-documentation-unknown-command -Wno-c++98-compat-pedantic
+WARNINGS+=-Wno-missing-prototypes -Wno-missing-variable-declarations
+WARNINGS+=-Wno-disabled-macro-expansion
 
 WARNINGS+=-Wno-shorten-64-to-32 -Wno-sign-conversion
 

include/TombRaider1.h

         RaptorState_JumpBite  = 4,
         RaptorState_Bellowing = 6,
         RaptorState_RunBellow = 7,
-        RaptorState_Biting    = 8,
+        RaptorState_Biting    = 8
     };
 
     /*!
         WingedNatlaState_Dying1    = 5, //!< "Dying" the first time
         WingedNatlaState_Spinning  = 7, //!< Spinning around in air
         WingedNatlaState_Standing2 = 8,
-        WingedNatlaState_Dying2    = 9, //!< Dying for real
+        WingedNatlaState_Dying2    = 9  //!< Dying for real
     };
 
     /*!
     enum MotorboatStates {
         MotorboatState_StationaryInitial = 1,
         MotorboatState_Moving            = 2,
-        MotorboatState_StationaryFinal   = 3,
+        MotorboatState_StationaryFinal   = 3
     };
 
     /*!

src/Camera.cpp

             if (--mTranslateDelta < 0.0f)
                 mTranslateDelta = 1.0f;
             break;
-        default:
-            ;
     }
 }
 

src/Mesh.cpp

                 // Bind WHITE texture for solid colors
                 glBindTexture(GL_TEXTURE_2D, 0);
                 break;
-            default:
             case MeshModeTexture:
             case MeshModeMultiTexture:
                 // Bind texture id for textures
                 glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
+                break;
         }
 
         glBegin(GL_QUADS);
                 // Bind WHITE texture for solid colors
                 glBindTexture(GL_TEXTURE_2D, 0);
                 break;
-            default:
             case MeshModeTexture:
             case MeshModeMultiTexture:
                 // Bind texture id for textures
                 glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
+                break;
         }
 
         glBegin(GL_TRIANGLES);
 #else
             case MeshModeMultiTexture:
 #endif
-            default:
             case MeshModeTexture:
                 // Bind texture id for textures
                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
                 glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
+                break;
         }
 
         glBegin(GL_QUADS);
 #else
             case MeshModeMultiTexture:
 #endif
-            default:
             case MeshModeTexture:
                 // Bind texture id for textures
                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
                 glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
+                break;
         }
 
         glBegin(GL_TRIANGLES);

src/Network.cpp

 
             if (!f.data.send)
             {
-                const struct timespec tmp = {.tv_sec = 0, .tv_nsec = 20000};
+                struct timespec tmp;
+                tmp.tv_sec = 0;
+                tmp.tv_nsec = 20000;
                 nanosleep(&tmp, NULL);
                 continue;
             }

src/OpenRaider.cpp

                 case worldMoveType_noClipping:
                     eventAnimTest(TR_ANIAMTION_SWIM_R);
                     break;
-                default:
                 case worldMoveType_walk:
                 case worldMoveType_walkNoSwim:
                     eventAnimTest(TR_ANIAMTION_TURN_L); // TURN left always for now
+                    break;
             }
 
             LARA->moving = true;
                 case worldMoveType_noClipping:
                     eventAnimTest(TR_ANIAMTION_SWIM_L);
                     break;
-                default:
                 case worldMoveType_walk:
                 case worldMoveType_walkNoSwim:
                     eventAnimTest(TR_ANIAMTION_TURN_L);
+                    break;
             }
 
             LARA->moving = true;
                     case worldMoveType_noClipping:
                         eventAnimTest(TR_ANIAMTION_SWIM);
                         break;
-                    default:
                     case worldMoveType_walk:
                     case worldMoveType_walkNoSwim:
                         eventAnimTest(TR_ANIAMTION_RUN);
+                        break;
                 }
             }
             else if (LARA)
                     case worldMoveType_noClipping:
                         eventAnimTest(TR_ANIAMTION_SWIM_IDLE);
                         break;
-                    default:
                     case worldMoveType_walk:
                     case worldMoveType_walkNoSwim:
                         eventAnimTest(TR_ANIAMTION_HIT_WALL_FRONT);
+                        break;
                 }
             }
             else
                     case worldMoveType_noClipping:
                         eventAnimTest(TR_ANIAMTION_SWIM);
                         break;
-                    default:
                     case worldMoveType_walk:
                     case worldMoveType_walkNoSwim:
                         eventAnimTest(TR_ANIAMTION_RUN);
+                        break;
                 }
             }
             break;
                     case worldMoveType_noClipping:
                         eventAnimTest(TR_ANIAMTION_SWIM);
                         break;
-                    default:
                     case worldMoveType_walk:
                     case worldMoveType_walkNoSwim:
                         eventAnimTest(TR_ANIAMTION_RUN);
+                        break;
                 }
             }
             else if (!LARA)
                     case worldMoveType_noClipping:
                         eventAnimTest(TR_ANIAMTION_SWIM);
                         break;
-                    default:
                     case worldMoveType_walk:
                     case worldMoveType_walkNoSwim:
                         eventAnimTest(TR_ANIAMTION_RUN);
+                        break;
                 }
             }
             else if (!LARA)
 
                 m_tombraider.loadSFX(altSfx);
                 break;
-            default:
             case TR_VERSION_1:
             case TR_VERSION_4:
             case TR_VERSION_5:
             case TR_VERSION_UNKNOWN:
-                ;
+                break;
         }
     }
 
                     case worldMoveType_noClipping:
                         eventAnimTest(TR_ANIAMTION_SWIM_IDLE);
                         break;
-                    default:
                     case worldMoveType_walk:
                     case worldMoveType_walkNoSwim:
                         eventAnimTest(TR_ANIAMTION_STAND);
+                        break;
                 }
 
                 LARA->moving = false;
                                 break;
                         }
                         break;
-                    default:
                     case TR_VERSION_2:
                     case TR_VERSION_3:
                     case TR_VERSION_5:
                     case TR_VERSION_UNKNOWN:
-                        ;
+                        break;
                 }
         }
     }
                 // Only TR4 lara has 2 layer bone tags/meshes per bone frame
                 r_model->tr4Overlay = true;
                 break;
-            default:
             case TR_VERSION_1:
             case TR_VERSION_2:
             case TR_VERSION_5:
                 sModel->setAnimation(TR_ANIAMTION_RUN);
                 sModel->setIdleAnimation(TR_ANIAMTION_STAND);
                 r_model->tr4Overlay = false;
+                break;
         }
 
         r_model->ponytailId = 0;
                     print(true, "Found known ponytail\n");
                 }
                 break; // ?
-            default:
             case TR_VERSION_1:
             case TR_VERSION_2:
             case TR_VERSION_3:
                     m_render.setFlags(Render::fRenderPonytail);
                     print(true, "Found ponytail?\n");
                 }
+                break;
         }
     }
     else

src/Render.cpp

             case worldMoveType_swim:
                 camOffsetH = 64.0f;
                 break;
-            default:
             case worldMoveType_walk:
             case worldMoveType_walkNoSwim:
                 camOffsetH = 512.0f;
+                break;
         }
 
         curPos[0] = LARA->pos[0];

src/TombRaider.cpp

         case TR_VERSION_3:
         case TR_VERSION_5:
         case TR_VERSION_UNKNOWN:
-        default:
             //! \fixme (Endian) Read bit32 / int32_t
             Fread(&mNumSampleIndices, 4, 1, f);
             printDebug("Load", "mNumSampleIndices = %i", mNumSampleIndices);
         case TR_VERSION_4:
         case TR_VERSION_5:
         case TR_VERSION_UNKNOWN:
-        default:
             color[0] = (float)(_palette16[index] & 0xff) / 256.0f;
             color[1] = (float)((_palette16[index] >> 8) & 0xff) / 256.0f;
             color[2] = (float)((_palette16[index] >> 16) & 0xff) / 256.0f;
             color[3] = 1.0;
+            break;
     }
 }
 
         case TR_VERSION_4:
         case TR_VERSION_5:
         case TR_VERSION_UNKNOWN:
-        default:
             getColor((mMeshes[meshIndex].coloured_rectangles[faceIndex].texture>>8) & 0xff, color);
+            break;
     }
 }
 
         case TR_VERSION_4:
         case TR_VERSION_5:
         case TR_VERSION_UNKNOWN:
-        default:
             getColor((mMeshes[meshIndex].coloured_triangles[faceIndex].texture>>8) & 0xff,
                     color);
+            break;
     }
 }
 
                 case TR_VERSION_2:
                 case TR_VERSION_5:
                 case TR_VERSION_UNKNOWN:
-                default:
                     colorValue = (1.0f - (colorValue / 8192.0f));
                     break;
             }
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
 
         case TR_VERSION_1:
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_1:
         case TR_VERSION_2:
         case TR_VERSION_2:
         case TR_VERSION_3:
         case TR_VERSION_4:
-        default:
             return _rooms[roomIndex].num_lights;
     }
 
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             return -1;
         case TR_VERSION_5:
             count = NumStaticMeshes();
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             return mRoomsTR5[roomIndex].numStaticMeshes;
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             *adjoiningRoom = mRoomsTR5[roomIndex].doors[index].adjoining_room;
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             return mRoomsTR5[roomIndex].numDoors;
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             for (i = 0, count = 0; i < mRoomsTR5[roomIndex].numLayers; ++i)
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             for (i = 0, count = 0; i < mRoomsTR5[roomIndex].numLayers; ++i)
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             *floorDataIndex = mRoomsTR5[roomIndex].sectors[index].fd_index;
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             // width of sector list
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             return 0; // No room sprites in TRC
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             for (i = 0, count = 0; i < mRoomsTR5[roomIndex].numLayers; ++i)
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             for (i = 0, count = 0; i < mRoomsTR5[index].numLayers; ++i)
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             for (i = 0, count = 0; i < mRoomsTR5[roomIndex].numLayers; ++i)
         case TR_VERSION_3:
         case TR_VERSION_4:
         case TR_VERSION_UNKNOWN:
-        default:
             vertex = &_rooms[index].room_data.vertices[i].vertex;
 
             xyz[0] = vertex->x;
                 case TR_VERSION_2:
                 case TR_VERSION_5: // Not really...
                 case TR_VERSION_UNKNOWN:
-                default:
                     color_value = _rooms[index].room_data.vertices[i].lighting1;
                     color_value = (1.1f - (color_value / 8192.0f));
 
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             *vertexCount = count;
                     case TR_VERSION_2:
                     case TR_VERSION_5:
                     case TR_VERSION_UNKNOWN:
-                    default:
                         color_value = _rooms[roomIndex].room_data.vertices[i].lighting1;
                         color_value = (1.1f - (color_value / 8192.0f));
                 }
                     case TR_VERSION_2:
                     case TR_VERSION_5:
                     case TR_VERSION_UNKNOWN:
-                    default:
                         rgba[0] = color_value;
                         rgba[1] = color_value;
                         rgba[2] = color_value;
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             for (i = 0, count = 0; i < mRoomsTR5[roomIndex].numLayers; ++i)
         case TR_VERSION_1:
         case TR_VERSION_5:
         case TR_VERSION_UNKNOWN:
-        default:
             return -1;
     }
 
             getRiffDataTR4(index, bytes, data);
             break;
         case TR_VERSION_UNKNOWN:
-        default:
-            ;
+            break;
     }
 }
 
             count = mNumTR4Samples;
             break;
         case TR_VERSION_UNKNOWN:
-        default:
             count = 0;
+            break;
     }
 
     return count;
     switch (getEngine())
     {
         case TR_VERSION_UNKNOWN:
-        default:
             break;
         case TR_VERSION_5:
             if (index < _num_rooms &&
             case TR_VERSION_2:
             case TR_VERSION_5:
             case TR_VERSION_UNKNOWN:
-            default:
-                ;
+                break;
         }
     }
 

src/World.cpp

         case worldMoveType_noClipping:
         case worldMoveType_fly:
         case worldMoveType_swim:
-        default:
             pitch = e->angles[2];
             break;
     }

test/GLString.cpp

 
 void init_text() {
     int i;
-    const char *errorText = "TEXT->glPrintf> ERROR code %i\n";
 
     // Mongoose 2002.01.01, Texture setup
     gTexture.reset();
     TEXT->Init(4);
     i = TEXT->glPrintf(50, 50, "OpenRaider GLString");
     if (i) {
-        printf(errorText, i);
+        printf("TEXT->glPrintf> ERROR code %i\n", i);
     }
     i = TEXT->glPrintf(50, 100, "Unit Test by Mongoose");
     if (i) {
-        printf(errorText, i);
+        printf("TEXT->glPrintf> ERROR code %i\n", i);
     }
     TEXT->Scale(1.2f);
     i = TEXT->glPrintf(50, 150, "ported to SDL2 & TTF");
     if (i) {
-        printf(errorText, i);
+        printf("TEXT->glPrintf> ERROR code %i\n", i);
     }
     i = TEXT->glPrintf(50, 200, "by xythobuz");
     if (i) {
-        printf(errorText, i);
+        printf("TEXT->glPrintf> ERROR code %i\n", i);
     }
     TEXT->setActive(0, true);
     TEXT->setActive(1, true);

test/TombRaider.cpp

                 tr->getColor(meshes[index].coloured_triangles[i].texture
                         & 0xff, rgba);
                 break;
-            default:
             case TR_VERSION_UNKNOWN:
             case TR_VERSION_2:
             case TR_VERSION_3:
             case TR_VERSION_5:
                 tr->getColor((meshes[index].coloured_triangles[i].texture>>8)
                         & 0xff, rgba);
+                break;
         }
 
         s = rgba[0];
                 tr->getColor(meshes[index].coloured_rectangles[i].texture
                         & 0xff, rgba);
                 break;
-            default:
             case TR_VERSION_UNKNOWN:
             case TR_VERSION_2:
             case TR_VERSION_3:
             case TR_VERSION_5:
                 tr->getColor((meshes[index].coloured_rectangles[i].texture>>8)
                         & 0xff, rgba);
+                break;
         }
 
         s = rgba[0];