Fixed more cppcheck warnings

Makefile

 
 #################################################################
 
+CHECK_INC=-Iinclude
+#CHECK_INC+=$(GL_DEFS) $(AUDIO_DEFS)
+#ifeq ($(UNAME),Darwin)
+#SDK_ROOT=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.9.sdk
+#CHECK_INC+=-I$(SDK_ROOT)/usr/include
+#CHECK_INC+=-I$(SDK_ROOT)/usr/include/malloc
+#CHECK_INC+=-I$(SDK_ROOT)/usr/include/machine
+#CHECK_INC+=-I$(SDK_ROOT)/usr/include/c++/4.2.1
+#CHECK_INC+=-I$(SDK_ROOT)/usr/include/c++/4.2.1/tr1
+#CHECK_INC+=-I$(SDK_ROOT)/usr/include/c++/4.2.1/backward
+#endif
+
 check:
-	cppcheck -Iinclude $(GL_DEFS) $(AUDIO_DEFS) --enable=information .
+	cppcheck --quiet $(CHECK_INC) --force \
+		--enable=information,warning,performance,portability .
 
-fullCheck:
-	cppcheck -Iinclude $(GL_DEFS) $(AUDIO_DEFS) --enable=all --inconclusive --std=posix .
+checkFull:
+	cppcheck --quiet $(CHECK_INC) --enable=all --std=posix --force .
 
 #################################################################
 
 clean: clean-small clean-dep clean-doc
 
-clean-small: clean-build clean-test clean-obj 
+clean-small: clean-build clean-test clean-obj
 	@-rm -rf bin/OpenRaider.app
 	@-rm -rf bin/OpenRaider.dmg
 	@-rm -rf bin/OpenRaider.zip

include/List.h

      * \brief Print this ListNode
      */
     void Print() {
-        printf("(%i, %p)",  _id, _data);
+        printf("(%u, %p)",  _id, _data);
     }
 
 private:
             return SearchId(i);
         } else {
 #ifdef DEBUG_INDEX_EMPTY_LIST
-            printf("List[%i] = NULL\n", i);
+            printf("List[%u] = NULL\n", i);
 #endif
         }
         return 0;
      */
     void Print(void (*print_func)(T)) {
         ListNode<T> *current = _head;
-        printf(" [%i] {\n", _num_items);
+        printf(" [%u] {\n", _num_items);
         while (current) {
             printf("#%i, ", current->Id());
             if (print_func)
      */
     void Print() {
         ListNode<T> *current = _head;
-        printf("List %i {\n", _num_items);
+        printf("List %u {\n", _num_items);
         while (current) {
             //current->Print();
             printf("%i", current->Id());

include/Map.h

             return;
         }
 
-        printf(" [%i] {\n", _num_items);
+        printf(" [%u] {\n", _num_items);
 
         while (current) {
             printf("(");

include/Quaternion.h

      * Mongoose - Created
      ------------------------------------------------------*/
 
-    Quaternion operator =(const Quaternion &q);
+    Quaternion &operator =(const Quaternion &q);
     /*------------------------------------------------------
      * Pre  :
      * Post : Asigns Q to this quaternion

include/Tree.h

      * \sa Tree::Remove()
      */
     bool RemoveByData(Data data) {
-        bool error;
+        bool error = true;
         if (_root)
             Remove(_root->SearchByData(data, &error));
         return error;
      * \sa Tree::Remove()
      */
     bool RemoveByKey(Key key) {
-        bool error;
+        bool error = true;
         if (_root) {
 #ifdef OBSOLETE
             // Mongoose 2002.02.18, To remove duplicates
-            erorr = false;
+            error = false;
             while (!error) {
 #endif
                 Remove(_root->SearchByKey(key, &error));
      * \sa TreeNode::PrintInorderSpecial()
      */
     void PrintSpecial(void (*print_func_k)(Key), void (*print_func_d)(Data)) {
-        printf("Tree: %i elements {\n", _num_elements);
+        printf("Tree: %u elements {\n", _num_elements);
         if (_root && print_func_k && print_func_d) {
             printf("Root: ");
             _root->PrintNodeSpecial(print_func_k, print_func_d);
             prev = GetSuccessor(tree);
         }
 
+        if (!prev)
+            return; // Probably a good idea, as there's a check if(prev) later
+
         if (prev->GetLeft())
         {
             cur = prev->GetLeft();

include/Vector.h

         mReserve = 0;
         mStart = 0;
         mEnd = 0;
+        mIndex = 0;
         copy(vector);
     }
 
         }
         mStart = vector.begin();
         mEnd = vector.end();
+        mError = vector.Error();
+        mIndex = vector.getCurrentIndex();
         for (i = vector.begin(); i < vector.end(); ++i) {
             mData[i] = vector[i];
         }

include/Vector3d.h

      * Mongoose - Created
      ------------------------------------------------------*/
 
-    void operator =(const Vector3d &v);
+    Vector3d &operator =(const Vector3d &v);
     /*------------------------------------------------------
      * Pre  :
      * Post : this = v, values are assigned   =)
      * Mongoose - Created
      ------------------------------------------------------*/
 
-    void operator +=(const Vector3d &v);
+    Vector3d &operator +=(const Vector3d &v);
     /*------------------------------------------------------
      * Pre  :
      * Post : this += v, values are sumed, assigned   =)
      * Mongoose - Created
      ------------------------------------------------------*/
 
-    void operator -=(const Vector3d &v);
+    Vector3d &operator -=(const Vector3d &v);
     /*------------------------------------------------------
      * Pre  :
      * Post : this -= v, values are diffed, assigned   =)
      * Mongoose - Created
      ------------------------------------------------------*/
 
-    void operator *=(vec_t s);
+    Vector3d &operator *=(vec_t s);
     /*------------------------------------------------------
      * Pre  :
      * Post : this *= s, values are scaled, assigned   =)

src/Emitter.cpp

 vec_t Emitter::mFrustum[6][4];
 
 int Emitter::compareParticleDist(const void *voidA, const void *voidB) {
-    Particle *a = (Particle *)voidA, *b = (Particle *)voidB;
+    Particle *a = const_cast<Particle *>(static_cast<const Particle *>(voidA));
+    Particle *b = const_cast<Particle *>(static_cast<const Particle *>(voidB));
     float x, y, z, distA, distB;
 
     if (!a || !b)

src/MatMath.cpp

     //  vec3_t normal, a, b;
     Vector3d a, b, normal, pA, pB;
     vec_t d, denominator, mu;
-    double theta;
 
 
     pA = Vector3d(p1);
 #else // assume convex polygons here for sure
     //mtkVectorSubtract(intersect, polygon[0], a);
     //theta = mtkVectorDotProduct(a, normal);
-    theta = Vector3d::dot(b - Vector3d(polygon[0]), normal); // b = intersect
+    double theta = Vector3d::dot(b - Vector3d(polygon[0]), normal); // b = intersect
 
     if (theta >= 90.0) // Yeah I know
         return 0;

src/Network.cpp

 
 void Network::setBindHost(char *s)
 {
-    if (!s && !s[0])
+    if (!s || !s[0])
         return;
 
     strncpy(mBindHost, s, BIND_HOST_STR_SZ);
 
 void Network::setRemoteHost(char *s)
 {
-    if (!s && !s[0])
+    if (!s || !s[0])
         return;
 
     strncpy(mRemoteHost, s, REMOTE_HOST_STR_SZ);
     memset(&s_in, 0, sizeof(s_in));
     s_in.sin_family = AF_INET;
 #ifdef LOCAL_BCAST
-    struct hostent *hostptr;
-
-    if ((hostptr = gethostbyname(hostid)) == NULL)
-    {
-        fprintf(stderr, "Server: recv_udp, Invalid host name '%s'\n", hostid);
+    // Replace deprecated gethostbyname() with getaddrinfo()
+    //struct hostent *hostptr;
+    //if ((hostptr = gethostbyname(hostid)) == NULL)
+    //{
+    //    fprintf(stderr, "Server: recv_udp, Invalid host name '%s'\n", hostid);
+    //    return -1;
+    //}
+    //memcpy((void *)(&s_in.sin_addr), hostptr->h_addr, hostptr->h_length);
+    struct addrinfo *result, *res;
+    bool found = false;
+    int error = getaddrinfo(hostid, NULL, NULL, &result);
+    if (error != 0) {
+        fprintf(stderr, "Server: %s\n", gai_strerror(error));
+        return -1;
+    }
+    for (res = result; res != NULL; res = res->ai_next) {
+        if (res->ss_family == AF_INET) {
+            found = true;
+            memcpy((void *)&s_in, res->ai_addr, res->ai_addrlen);
+            break; // Found something suitable
+        }
+    }
+    freeaddrinfo(result);
+    if (!found) {
+        fprintf(stderr, "Server: Can't bind to %s\n", hostid);
         return -1;
     }
-
-    memcpy((void *)(&s_in.sin_addr), hostptr->h_addr, hostptr->h_length);
 #else
     s_in.sin_addr.s_addr = htonl(INADDR_ANY);
 #endif
         if (mDebug)
         {
             printf("=====================================================\n");
-            printf("Packet %i\n", packetsRecieved);
+            printf("Packet %u\n", packetsRecieved);
             printf("Server: Recieved packet from %u\n",
                     f.uid);
         }
                     gClients[i].frameExpected = 0;
                     ++gNumClients;
 
-                    printf("Server: %u made connection, as client %i\n",
+                    printf("Server: %u made connection, as client %u\n",
                             gClients[i].uid, i);
                     break;
                 }
     unsigned int fsize, last_frame_sent = 0;
     int socket_fd, cc, done;
     struct sockaddr_in dest;
-    struct hostent *hostptr;
+    struct addrinfo *addr;
     network_frame_t f;
     struct timeval timeout;
-    fd_set  readfds;
+    fd_set readfds;
     unsigned int packetsSent = 0;
     unsigned int seq = 0;
     char timedOut = 1;
         exit(0);
     }
 
-    if ((hostptr = gethostbyname(mRemoteHost)) == NULL)
-    {
-        fprintf(stderr, "Client: send_udp: invalid host name, %s\n",
-                mRemoteHost);
+    //if ((hostptr = gethostbyname(mRemoteHost)) == NULL)
+    //{
+    //    fprintf(stderr, "Client: send_udp: invalid host name, %s\n",
+    //            mRemoteHost);
+    //    exit(0);
+    //}
+
+    int error = getaddrinfo(mRemoteHost, NULL, NULL, &addr);
+    if (error != 0) {
+        fprintf(stderr, "Client: %s\n", gai_strerror(error));
         exit(0);
     }
 
     int port = getPort();
     dest.sin_port = htons(port);
 #ifdef LOCAL_BCAST
-    memcpy(hostptr->h_addr, (char *) &dest.sin_addr, hostptr->h_length);
+    //memcpy(hostptr->h_addr, (char *) &dest.sin_addr, hostptr->h_length);
+    bool found = false;
+    for (struct addrinfo *res = addr; res != NULL; res = res->ai_next) {
+        if (res->ss_family == AF_INET) {
+            found = true;
+            memcpy((void *)&dest.sin_addr, res->ai_addr.sin_addr, sizeof(res->ai_addr.sin_addr));
+            break; // Found something suitable
+        }
+    }
+    freeaddrinfo(addr);
+    if (!found) {
+        fprintf(stderr, "Client: Can't connect to %s\n", hostid);
+        return;
+    }
 #else
     if (inet_pton(AF_INET, mRemoteHost, &dest.sin_addr) < 0)
     {
         if (mDebug)
         {
             printf("=====================================================\n");
-            printf("Packet %i\n", packetsSent);
+            printf("Packet %u\n", packetsSent);
         }
 
         // 1. Get packet to send over wire

src/OpenRaider.cpp

 {
     if (LARA)
     {
-        SkeletalModel *mdl = (SkeletalModel *)LARA->tmpHook;
+        SkeletalModel *mdl = static_cast<SkeletalModel *>(LARA->tmpHook);
 
         if (mdl)
         {
         p->pitch = LARA->angles[1];
         p->view_model = LARA->modelId;
 
-        SkeletalModel *mdl = (SkeletalModel *)LARA->tmpHook;
+        SkeletalModel *mdl = static_cast<SkeletalModel *>(LARA->tmpHook);
 
         if (mdl)
         {
         gPiggyBack.data.pitch = LARA->angles[2];
         gPiggyBack.data.view_model = LARA->modelId;
 
-        SkeletalModel *mdl = (SkeletalModel *)LARA->tmpHook;
+        SkeletalModel *mdl = static_cast<SkeletalModel *>(LARA->tmpHook);
 
         if (mdl)
         {
         case '[':
             if (LARA)
             {
-                SkeletalModel *mdl = (SkeletalModel *)LARA->tmpHook;
+                SkeletalModel *mdl = static_cast<SkeletalModel *>(LARA->tmpHook);
 
                 if (mdl)
                 {
         case ']':
             if (LARA)
             {
-                SkeletalModel *mdl = (SkeletalModel *)LARA->tmpHook;
+                SkeletalModel *mdl = static_cast<SkeletalModel *>(LARA->tmpHook);
 
                 if (mdl)
                 {
         default:
             if (LARA)
             {
-                mdl = (SkeletalModel *)LARA->tmpHook;
+                mdl = static_cast<SkeletalModel *>(LARA->tmpHook);
 
                 if (mdl)
                 {
     {
         if (LARA)
         {
-            SkeletalModel *smdl = (SkeletalModel *)LARA->tmpHook;
+            SkeletalModel *smdl = static_cast<SkeletalModel *>(LARA->tmpHook);
             skeletal_model_t *mdl = gWorld.getModel(atoi(cmd));
 
             if (smdl)
     {
         if (atoi(cmd))
         {
-            m_render.clearFlags(Render::fUsePortals);
+            m_render.setFlags(Render::fUsePortals);
         }
         else
         {

src/Quaternion.cpp

 }
 
 
-Quaternion Quaternion::operator =(const Quaternion &q)
+Quaternion &Quaternion::operator =(const Quaternion &q)
 {
     mW  = q.mW;
     mX = q.mX;
     mY = q.mY;
     mZ = q.mZ;
-
-    return (*this);
+    return *this;
 }
 
 

src/Render.cpp

 
 int compareRoomDist(const void *voidA, const void *voidB)
 {
-    RenderRoom *a = (RenderRoom *)voidA, *b = (RenderRoom *)voidB;
+    const RenderRoom *a = static_cast<const RenderRoom *>(voidA);
+    const RenderRoom *b = static_cast<const RenderRoom *>(voidB);
 
 
     if (!a || !b || !a->room || !b->room)
         unsigned int snowTex1, unsigned int snowTex2)
 {
 #ifdef USING_EMITTER
+    if (mEmitter)
+        delete mEmitter; // Public, so avoid possible leak
+
     // Mongoose 2002.01.01, Screwing around with particle emitter test
     //   note this is backwards b/c load screen is rendered upsidedown
     //mEmitter = new Emitter(/*name*/"snow", size);
             // Mongoose 2002.12.24, Some entities have no animation  =p
             if (e->tmpHook)
             {
-                SkeletalModel *mdl = (SkeletalModel *)e->tmpHook;
+                SkeletalModel *mdl = static_cast<SkeletalModel *>(e->tmpHook);
 
                 if (mdl->model->animation.empty())
                     continue;
             glPushMatrix();
             glTranslatef(e->pos[0], e->pos[1], e->pos[2]);
             glRotatef(e->angles[1], 0, 1, 0);
-            drawModel((SkeletalModel *)e->tmpHook);
+            drawModel(static_cast<SkeletalModel *>(e->tmpHook));
             glPopMatrix();
         }
     }
     // Draw lara or other player model ( move to entity rendering method )
     if (mFlags & Render::fViewModel && LARA && LARA->tmpHook)
     {
-        SkeletalModel *mdl = (SkeletalModel *)LARA->tmpHook;
+        SkeletalModel *mdl = static_cast<SkeletalModel *>(LARA->tmpHook);
         int frame = mdl->getAnimation();
 
-
-        // Mongoose 2002.03.22, Test 'idle' aniamtions
-        if (!LARA->moving)
+        if (mdl)
         {
-            frame = mdl->getIdleAnimation();
 
-            // Mongoose 2002.08.15, Stop flickering of idle lara here
-            if (frame == 11)
+            // Mongoose 2002.03.22, Test 'idle' aniamtions
+            if (!LARA->moving)
             {
-                mdl->setFrame(0);
+                frame = mdl->getIdleAnimation();
+
+                // Mongoose 2002.08.15, Stop flickering of idle lara here
+                if (frame == 11)
+                {
+                    mdl->setFrame(0);
+                }
             }
-        }
 
-        if (mdl)
-        {
             animation_frame_t *animation = mdl->model->animation[frame];
 
             if (animation && mdl->getFrame() > (int)animation->frame.size()-1)
         glRotated(mCamera->getYaw(), 0, 1, 0);
 #endif
 
-        drawModel((SkeletalModel *)LARA->tmpHook);
+        drawModel(static_cast<SkeletalModel *>(LARA->tmpHook));
         glPopMatrix();
     }
 
     bone_frame_t *boneframe2 = 0x0;
     bone_tag_t *tag;
     bone_tag_t *tag2;
-    unsigned int i;
     int bframe, aframe;
     skeletal_model_t *mdl;
 
 #ifdef EXPERIMENTAL_NON_ITEM_RENDER
                 drawModel(mModels[mdl->ponytail], 0, 0);
 #else
-                for (i = 0; i < mdl->ponytailNumMeshes; ++i)
+                for (unsigned int i = 0; i < mdl->ponytailNumMeshes; ++i)
                 {
                     glPushMatrix();
 
                     }
                 }
 
-                for (i = 0; i < mdl->ponytailNumMeshes; ++i)
+                for (unsigned int i = 0; i < mdl->ponytailNumMeshes; ++i)
                 {
                     glPopMatrix();
                 }

src/TombRaider.cpp

         _sound_sources =
             (tr2_sound_source_t*) new unsigned char[_num_sound_sources*40];
 
-        if (mEngineVersion == TR_VERSION_4)
-        {
-            // Mongoose 2002.04.04, was 40 sized reads before extra_camera
-            Fread(_sound_sources, sizeof(tr2_sound_source_t),
-                    _num_sound_sources, f);
-        }
-        else
-        {
-            Fread(_sound_sources, sizeof(tr2_sound_source_t),
-                    _num_sound_sources, f);
-        }
+        Fread(_sound_sources, sizeof(tr2_sound_source_t),
+                _num_sound_sources, f);
         //! \fixme endian
     }
 
     }
     else
     {
-        if (mEngineVersion == TR_VERSION_4)
-        {
-            Fread(mSoundMap, sizeof(short), 370, f);
-        }
-        else
-        {
-            Fread(mSoundMap, sizeof(short), 370, f);
-        }
+        Fread(mSoundMap, sizeof(short), 370, f);
     }
     //! \fixme endian
 

src/Vector3d.cpp

 }
 
 
-void Vector3d::operator =(const Vector3d &v)
+Vector3d &Vector3d::operator =(const Vector3d &v)
 {
     mVec[0] = v.mVec[0];
     mVec[1] = v.mVec[1];
     mVec[2] = v.mVec[2];
+    return *this;
 }
 
 
-void Vector3d::operator +=(const Vector3d &v)
+Vector3d &Vector3d::operator +=(const Vector3d &v)
 {
     mVec[0] += v.mVec[0];
     mVec[1] += v.mVec[1];
     mVec[2] += v.mVec[2];
+    return *this;
 }
 
 
-void Vector3d::operator -=(const Vector3d &v)
+Vector3d &Vector3d::operator -=(const Vector3d &v)
 {
     mVec[0] -= v.mVec[0];
     mVec[1] -= v.mVec[1];
     mVec[2] -= v.mVec[2];
+    return *this;
 }
 
 
-void Vector3d::operator *=(vec_t s)
+Vector3d &Vector3d::operator *=(vec_t s)
 {
     mVec[0] *= s;
     mVec[1] *= s;
     mVec[2] *= s;
+    return *this;
 }
 
 

test/TombRaider.cpp

             j = moveable[i].starting_mesh;
             n = moveable[i].num_meshes + j;
 
-            fprintf(f, "Lara (%i)\n", i);
+            fprintf(f, "Lara (%u)\n", i);
         }
         else if (moveable[i].object_id == 30)
         {
             {
                 case 8: // Joints, ( interconnecting skin/ploys )
                 case 9:
-                    fprintf(f, "TR4 lara joints (%i)\n", i);
+                    fprintf(f, "TR4 lara joints (%u)\n", i);
                     j = moveable[i].starting_mesh;
                     n = moveable[i].num_meshes + j;
             }
 
         for (k = j; j < n; ++j)
         {
-            fprintf(f, "\tMesh[%i] = %i\n", (j - k), j);
+            fprintf(f, "\tMesh[%i] = %u\n", (j - k), j);
         }
     }
 
 
     if (total)
     {
-        printf("Dumped %ibytes (%.2f MB) of audio samples\n",
+        printf("Dumped %ubytes (%.2f MB) of audio samples\n",
                 total, (float)total/1024000.0);
     }
 }