Fix static-code findings,

code/Obj/ObjFileMtlImporter.cpp

@@ -89,9 +89,12 @@ ObjFileMtlImporter::ObjFileMtlImporter(std::vector<char> &buffer,
         m_DataIt(buffer.begin()),
         m_DataItEnd(buffer.end()),
         m_pModel(pModel),
-        m_uiLine(0) {
+        m_uiLine(0),
-    ai_assert(NULL != m_pModel);
+        m_buffer() {
-    if (NULL == m_pModel->m_pDefaultMaterial) {
+    ai_assert(nullptr != m_pModel);
+    m_buffer.resize(BUFFERSIZE);
+    std::fill(m_buffer.begin(), m_buffer.end(), '\0');
+    if (nullptr == m_pModel->m_pDefaultMaterial) {
         m_pModel->m_pDefaultMaterial = new ObjFile::Material;
         m_pModel->m_pDefaultMaterial->MaterialName.Set("default");
     }
@@ -104,18 +107,6 @@ ObjFileMtlImporter::~ObjFileMtlImporter() {
     // empty
 }
 
-// -------------------------------------------------------------------
-//  Private copy constructor
-ObjFileMtlImporter::ObjFileMtlImporter(const ObjFileMtlImporter &) {
-    // empty
-}
-
-// -------------------------------------------------------------------
-//  Private copy constructor
-ObjFileMtlImporter &ObjFileMtlImporter::operator=(const ObjFileMtlImporter &) {
-    return *this;
-}
-
 // -------------------------------------------------------------------
 //  Loads the material description
 void ObjFileMtlImporter::load() {
@@ -227,15 +218,15 @@ void ObjFileMtlImporter::getColorRGBA(aiColor3D *pColor) {
 // -------------------------------------------------------------------
 //  Loads the kind of illumination model.
 void ObjFileMtlImporter::getIlluminationModel(int &illum_model) {
-    m_DataIt = CopyNextWord<DataArrayIt>(m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE);
+    m_DataIt = CopyNextWord<DataArrayIt>(m_DataIt, m_DataItEnd, &m_buffer[0], BUFFERSIZE);
-    illum_model = atoi(m_buffer);
+    illum_model = atoi(&m_buffer[0]);
 }
 
 // -------------------------------------------------------------------
 //  Loads a single float value.
 void ObjFileMtlImporter::getFloatValue(ai_real &value) {
-    m_DataIt = CopyNextWord<DataArrayIt>(m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE);
+    m_DataIt = CopyNextWord<DataArrayIt>(m_DataIt, m_DataItEnd, &m_buffer[0], BUFFERSIZE);
-    value = (ai_real)fast_atof(m_buffer);
+    value = (ai_real)fast_atof(&m_buffer[0]);
 }
 
 // -------------------------------------------------------------------

code/Obj/ObjFileMtlImporter.h

@@ -65,19 +65,18 @@ public:
     typedef std::vector<char>::iterator DataArrayIt;
     typedef std::vector<char>::const_iterator ConstDataArrayIt;
 
-public:
+    //! \brief  The class default constructor
-    //! \brief  Default constructor
     ObjFileMtlImporter(std::vector<char> &buffer, const std::string &strAbsPath,
             ObjFile::Model *pModel);
 
-    //! \brief  DEstructor
+    //! \brief  The class destructor
     ~ObjFileMtlImporter();
 
+    ObjFileMtlImporter(const ObjFileMtlImporter &rOther) = delete;
+    ObjFileMtlImporter &operator=(const ObjFileMtlImporter &rOther) = delete;
+
 private:
     /// Copy constructor, empty.
-    ObjFileMtlImporter(const ObjFileMtlImporter &rOther);
-    /// \brief  Assignment operator, returns only a reference of this instance.
-    ObjFileMtlImporter &operator=(const ObjFileMtlImporter &rOther);
     /// Load the whole material description
     void load();
     /// Get color data.
@@ -104,7 +103,7 @@ private:
     //! Current line in file
     unsigned int m_uiLine;
     //! Helper buffer
-    char m_buffer[BUFFERSIZE];
+    std::vector<char> m_buffer;
 };
 
 // ------------------------------------------------------------------------------------------------

code/Ply/PlyLoader.cpp

@@ -5,7 +5,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -87,7 +86,9 @@ inline const T &GetProperty(const std::vector<T> &props, int idx) {
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 PLYImporter::PLYImporter() :
-        mBuffer(nullptr), pcDOM(nullptr), mGeneratedMesh(nullptr) {
+        mBuffer(nullptr),
+        pcDOM(nullptr),
+        mGeneratedMesh(nullptr) {
     // empty
 }
 

code/Ply/PlyLoader.h

@@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -46,9 +45,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_PLYLOADER_H_INCLUDED
 #define AI_PLYLOADER_H_INCLUDED
 
+#include "PlyParser.h"
 #include <assimp/BaseImporter.h>
 #include <assimp/types.h>
-#include "PlyParser.h"
 #include <vector>
 
 struct aiNode;
@@ -62,14 +61,11 @@ using namespace PLY;
 // ---------------------------------------------------------------------------
 /** Importer class to load the stanford PLY file format
 */
-class PLYImporter : public BaseImporter
+class PLYImporter : public BaseImporter {
-{
 public:
     PLYImporter();
     ~PLYImporter();
 
-public:
-
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.
@@ -88,7 +84,6 @@ public:
     void LoadFace(const PLY::Element *pcElement, const PLY::ElementInstance *instElement, unsigned int pos);
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details
@@ -102,7 +97,6 @@ protected:
     void InternReadFile(const std::string &pFile, aiScene *pScene,
             IOSystem *pIOHandler);
 
-protected:
     // -------------------------------------------------------------------
     /** Extract a material list from the DOM
     */

code/PostProcessing/FindInvalidDataProcess.cpp

@@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -44,8 +42,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Defines a post processing step to search an importer's output
     for data that is obviously invalid  */
 
-
-
 #ifndef ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS
 
 // internal headers
@@ -59,9 +55,8 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-FindInvalidDataProcess::FindInvalidDataProcess()
+FindInvalidDataProcess::FindInvalidDataProcess() :
-: configEpsilon(0.0)
+        configEpsilon(0.0), mIgnoreTexCoods(false) {
-, mIgnoreTexCoods( false ){
     // nothing to do here
 }
 
@@ -125,7 +120,7 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) {
         int result = ProcessMesh(pScene->mMeshes[a]);
         if (0 == result) {
             out = true;
-
+        }
         if (2 == result) {
             // remove this mesh
             delete pScene->mMeshes[a];
@@ -134,7 +129,7 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) {
             meshMapping[a] = UINT_MAX;
             continue;
         }
-        }
+
         pScene->mMeshes[real] = pScene->mMeshes[a];
         meshMapping[a] = real++;
     }
@@ -144,7 +139,6 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) {
         ProcessAnimation(pScene->mAnimations[animIdx]);
     }
 
-
     if (out) {
         if (real != pScene->mNumMeshes) {
             if (!real) {
@@ -166,17 +160,14 @@ void FindInvalidDataProcess::Execute( aiScene* pScene) {
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline
+inline const char *ValidateArrayContents(const T * /*arr*/, unsigned int /*size*/,
-const char* ValidateArrayContents(const T* /*arr*/, unsigned int /*size*/,
+        const std::vector<bool> & /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/) {
-        const std::vector<bool>& /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/)
-{
     return nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
 template <>
-inline
+inline const char *ValidateArrayContents<aiVector3D>(const aiVector3D *arr, unsigned int size,
-const char* ValidateArrayContents<aiVector3D>(const aiVector3D* arr, unsigned int size,
         const std::vector<bool> &dirtyMask, bool mayBeIdentical, bool mayBeZero) {
     bool b = false;
     unsigned int cnt = 0;
@@ -204,8 +195,7 @@ const char* ValidateArrayContents<aiVector3D>(const aiVector3D* arr, unsigned in
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline 
+inline bool ProcessArray(T *&in, unsigned int num, const char *name,
-bool ProcessArray(T*& in, unsigned int num,const char* name,
         const std::vector<bool> &dirtyMask, bool mayBeIdentical = false, bool mayBeZero = true) {
     const char *err = ValidateArrayContents(in, num, dirtyMask, mayBeIdentical, mayBeZero);
     if (err) {
@@ -229,8 +219,7 @@ AI_FORCE_INLINE bool EpsilonCompare(ai_real n, ai_real s, ai_real epsilon) {
 // ------------------------------------------------------------------------------------------------
 template <>
 bool EpsilonCompare<aiVectorKey>(const aiVectorKey &n, const aiVectorKey &s, ai_real epsilon) {
-    return
+    return EpsilonCompare(n.mValue.x, s.mValue.x, epsilon) &&
-        EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) &&
            EpsilonCompare(n.mValue.y, s.mValue.y, epsilon) &&
            EpsilonCompare(n.mValue.z, s.mValue.z, epsilon);
 }
@@ -238,8 +227,7 @@ bool EpsilonCompare<aiVectorKey>(const aiVectorKey& n, const aiVectorKey& s, ai_
 // ------------------------------------------------------------------------------------------------
 template <>
 bool EpsilonCompare<aiQuatKey>(const aiQuatKey &n, const aiQuatKey &s, ai_real epsilon) {
-    return
+    return EpsilonCompare(n.mValue.x, s.mValue.x, epsilon) &&
-        EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) &&
            EpsilonCompare(n.mValue.y, s.mValue.y, epsilon) &&
            EpsilonCompare(n.mValue.z, s.mValue.z, epsilon) &&
            EpsilonCompare(n.mValue.w, s.mValue.w, epsilon);
@@ -247,8 +235,7 @@ bool EpsilonCompare<aiQuatKey>(const aiQuatKey& n, const aiQuatKey& s, ai_real e
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-inline
+inline bool AllIdentical(T *in, unsigned int num, ai_real epsilon) {
-bool AllIdentical(T* in, unsigned int num, ai_real epsilon) {
     if (num <= 1) {
         return true;
     }
@@ -328,8 +315,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
 
 // ------------------------------------------------------------------------------------------------
 // Search a mesh for invalid contents
-int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
+int FindInvalidDataProcess::ProcessMesh(aiMesh *pMesh) {
-{
     bool ret = false;
     std::vector<bool> dirtyMask(pMesh->mNumVertices, pMesh->mNumFaces != 0);
 
@@ -375,11 +361,9 @@ int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
     if (pMesh->mNormals || pMesh->mTangents) {
 
         if (aiPrimitiveType_POINT & pMesh->mPrimitiveTypes ||
-            aiPrimitiveType_LINE  & pMesh->mPrimitiveTypes)
+                aiPrimitiveType_LINE & pMesh->mPrimitiveTypes) {
-        {
             if (aiPrimitiveType_TRIANGLE & pMesh->mPrimitiveTypes ||
-                aiPrimitiveType_POLYGON  & pMesh->mPrimitiveTypes)
+                    aiPrimitiveType_POLYGON & pMesh->mPrimitiveTypes) {
-            {
                 // We need to update the lookup-table
                 for (unsigned int m = 0; m < pMesh->mNumFaces; ++m) {
                     const aiFace &f = pMesh->mFaces[m];
@@ -406,13 +390,15 @@ int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
 
         // Process mesh tangents
         if (pMesh->mTangents && ProcessArray(pMesh->mTangents, pMesh->mNumVertices, "tangents", dirtyMask)) {
-            delete[] pMesh->mBitangents; pMesh->mBitangents = NULL;
+            delete[] pMesh->mBitangents;
+            pMesh->mBitangents = NULL;
             ret = true;
         }
 
         // Process mesh bitangents
         if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents, pMesh->mNumVertices, "bitangents", dirtyMask)) {
-            delete[] pMesh->mTangents; pMesh->mTangents = NULL;
+            delete[] pMesh->mTangents;
+            pMesh->mTangents = NULL;
             ret = true;
         }
     }

code/PostProcessing/FindInvalidDataProcess.h

@@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -48,8 +47,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "Common/BaseProcess.h"
 
-#include <assimp/types.h>
 #include <assimp/anim.h>
+#include <assimp/types.h>
 
 struct aiMesh;
 

include/assimp/types.h

@@ -51,22 +51,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #    endif
 
 // Some runtime headers
-#include <sys/types.h>
-#include <stddef.h>
-#include <string.h>
 #    include <limits.h>
+#    include <stddef.h>
 #    include <stdint.h>
+#    include <string.h>
+#    include <sys/types.h>
 
 // Our compile configuration
 #    include <assimp/defs.h>
 
 // Some types moved to separate header due to size of operators
-#include <assimp/vector3.h>
-#include <assimp/vector2.h>
 #    include <assimp/color4.h>
 #    include <assimp/matrix3x3.h>
 #    include <assimp/matrix4x4.h>
 #    include <assimp/quaternion.h>
+#    include <assimp/vector2.h>
+#    include <assimp/vector3.h>
 
 typedef int32_t ai_int32;
 typedef uint32_t ai_uint32;
@@ -129,10 +129,11 @@ extern "C" {
 struct aiPlane {
 #    ifdef __cplusplus
     aiPlane() AI_NO_EXCEPT : a(0.f), b(0.f), c(0.f), d(0.f) {}
-    aiPlane (ai_real _a, ai_real _b, ai_real _c, ai_real _d)
+    aiPlane(ai_real _a, ai_real _b, ai_real _c, ai_real _d) :
-        : a(_a), b(_b), c(_c), d(_d) {}
+            a(_a), b(_b), c(_c), d(_d) {}
 
-    aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {}
+    aiPlane(const aiPlane &o) :
+            a(o.a), b(o.b), c(o.c), d(o.d) {}
 
 #    endif // !__cplusplus
 
@@ -146,10 +147,11 @@ struct aiPlane {
 struct aiRay {
 #    ifdef __cplusplus
     aiRay() AI_NO_EXCEPT {}
-    aiRay (const aiVector3D& _pos, const aiVector3D& _dir)
+    aiRay(const aiVector3D &_pos, const aiVector3D &_dir) :
-        : pos(_pos), dir(_dir) {}
+            pos(_pos), dir(_dir) {}
 
-    aiRay (const aiRay& o) : pos (o.pos), dir (o.dir) {}
+    aiRay(const aiRay &o) :
+            pos(o.pos), dir(o.dir) {}
 
 #    endif // !__cplusplus
 
@@ -160,13 +162,15 @@ struct aiRay {
 // ----------------------------------------------------------------------------------
 /** Represents a color in Red-Green-Blue space.
 */
-struct aiColor3D
+struct aiColor3D {
-{
 #    ifdef __cplusplus
     aiColor3D() AI_NO_EXCEPT : r(0.0f), g(0.0f), b(0.0f) {}
-    aiColor3D (ai_real _r, ai_real _g, ai_real _b) : r(_r), g(_g), b(_b) {}
+    aiColor3D(ai_real _r, ai_real _g, ai_real _b) :
-    explicit aiColor3D (ai_real _r) : r(_r), g(_r), b(_r) {}
+            r(_r), g(_g), b(_b) {}
-    aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
+    explicit aiColor3D(ai_real _r) :
+            r(_r), g(_r), b(_r) {}
+    aiColor3D(const aiColor3D &o) :
+            r(o.r), g(o.g), b(o.b) {}
 
     aiColor3D &operator=(const aiColor3D &o) {
         r = o.r;
@@ -177,13 +181,11 @@ struct aiColor3D
 
     /** Component-wise comparison */
     // TODO: add epsilon?
-    bool operator == (const aiColor3D& other) const
+    bool operator==(const aiColor3D &other) const { return r == other.r && g == other.g && b == other.b; }
-        {return r == other.r && g == other.g && b == other.b;}
 
     /** Component-wise inverse comparison */
     // TODO: add epsilon?
-    bool operator != (const aiColor3D& other) const
+    bool operator!=(const aiColor3D &other) const { return r != other.r || g != other.g || b != other.b; }
-        {return r != other.r || g != other.g || b != other.b;}
 
     /** Component-wise comparison */
     // TODO: add epsilon?
@@ -261,8 +263,7 @@ struct aiColor3D
  *  (binary) length of such a string is limited to MAXLEN characters (including the
  *  the terminating zero).
 */
-struct aiString
+struct aiString {
-{
 #    ifdef __cplusplus
     /** Default constructor, the string is set to have zero length */
     aiString() AI_NO_EXCEPT
@@ -276,9 +277,8 @@ struct aiString
     }
 
     /** Copy constructor */
-    aiString(const aiString& rOther)
+    aiString(const aiString &rOther) :
-    : length(rOther.length)
+            length(rOther.length) {
-    {
         // Crop the string to the maximum length
         length = length >= MAXLEN ? MAXLEN - 1 : length;
         memcpy(data, rOther.data, length);
@@ -287,8 +287,7 @@ struct aiString
 
     /** Constructor from std::string */
     explicit aiString(const std::string &pString) :
-        length( (ai_uint32) pString.length())
+            length((ai_uint32)pString.length()) {
-    {
         length = length >= MAXLEN ? MAXLEN - 1 : length;
         memcpy(data, pString.c_str(), length);
         data[length] = '\0';
@@ -315,20 +314,19 @@ struct aiString
         data[len] = 0;
     }
 
-
     /** Assignment operator */
     aiString &operator=(const aiString &rOther) {
         if (this == &rOther) {
             return *this;
         }
 
-        length = rOther.length;;
+        length = rOther.length;
+        ;
         memcpy(data, rOther.data, length);
         data[length] = '\0';
         return *this;
     }
 
-
     /** Assign a const char* to the string */
     aiString &operator=(const char *sz) {
         Set(sz);
@@ -392,13 +390,11 @@ struct aiString
     char data[MAXLEN];
 }; // !struct aiString
 
-
 // ----------------------------------------------------------------------------------
 /** Standard return type for some library functions.
  * Rarely used, and if, mostly in the C API.
  */
-typedef enum aiReturn
+typedef enum aiReturn {
-{
     /** Indicates that a function was successful */
     aiReturn_SUCCESS = 0x0,
 
@@ -427,8 +423,7 @@ typedef enum aiReturn
 /** Seek origins (for the virtual file system API).
  *  Much cooler than using SEEK_SET, SEEK_CUR or SEEK_END.
  */
-enum aiOrigin
+enum aiOrigin {
-{
     /** Beginning of the file */
     aiOrigin_SET = 0x0,
 
@@ -451,8 +446,7 @@ enum aiOrigin
  *  Logging to these streams can be enabled with a single call to
  *   #LogStream::createDefaultStream.
  */
-enum aiDefaultLogStream
+enum aiDefaultLogStream {
-{
     /** Stream the log to a file */
     aiDefaultLogStream_FILE = 0x1,
 
@@ -485,21 +479,19 @@ enum aiDefaultLogStream
  *  animations) of an import. All sizes are in bytes.
  *  @see Importer::GetMemoryRequirements()
 */
-struct aiMemoryInfo
+struct aiMemoryInfo {
-{
 #    ifdef __cplusplus
 
     /** Default constructor */
     aiMemoryInfo() AI_NO_EXCEPT
-        : textures   (0)
+            : textures(0),
-        , materials  (0)
+              materials(0),
-        , meshes     (0)
+              meshes(0),
-        , nodes      (0)
+              nodes(0),
-        , animations (0)
+              animations(0),
-        , cameras    (0)
+              cameras(0),
-        , lights     (0)
+              lights(0),
-        , total      (0)
+              total(0) {}
-    {}
 
 #    endif
 
@@ -533,11 +525,11 @@ struct aiMemoryInfo
 #    endif //!  __cplusplus
 
 // Include implementation files
-#include "vector2.inl"
-#include "vector3.inl"
 #    include "color4.inl"
-#include "quaternion.inl"
 #    include "matrix3x3.inl"
 #    include "matrix4x4.inl"
+#    include "quaternion.inl"
+#    include "vector2.inl"
+#    include "vector3.inl"
 
 #endif // AI_TYPES_H_INC