refactoring: renamed the severity "all" to "possible error"

src/check.h

@@ -80,7 +80,7 @@ protected:
     ErrorLogger * const _errorLogger;
 
     /** report an error */
-    void reportError(const Token *tok, const std::string &severity, const std::string &id, const std::string &msg)
+    void reportError(const Token *tok, const Severity::e severity, const std::string &id, const std::string &msg)
     {
         std::list<const Token *> callstack;
         callstack.push_back(tok);
@@ -88,12 +88,12 @@ protected:
     }
 
     /** report an error */
-    void reportError(const std::list<const Token *> &callstack, const std::string &severity, const std::string &id, std::string msg)
+    void reportError(const std::list<const Token *> &callstack, const Severity::e severity, const std::string &id, std::string msg)
     {
         // No errorLogger => just report the message to stdout
         if (_errorLogger == NULL)
         {
-            std::cout << "(" << severity << ") " << msg << std::endl;
+            std::cout << "(" << Severity::stringify(severity) << ") " << msg << std::endl;
             return;
         }
 
@@ -114,7 +114,7 @@ protected:
             locationList.push_back(loc);
         }
 
-        _errorLogger->reportErr(ErrorLogger::ErrorMessage(locationList, severity, msg, id));
+        _errorLogger->reportErr(ErrorLogger::ErrorMessage(locationList, Severity::stringify(severity), msg, id));
     }
 
 private:

src/checkautovariables.cpp

@@ -195,7 +195,7 @@ void CheckAutoVariables::autoVariables()
         {
             if (errorAv(tok->tokAt(1), tok->tokAt(4)))
                 reportError(tok,
-                            "error",
+                            Severity::error,
                             "autoVariables",
                             "Wrong assignement of an auto-variable to an effective parameter of a function");
         }
@@ -203,7 +203,7 @@ void CheckAutoVariables::autoVariables()
         {
             if (errorAv(tok->tokAt(1), tok->tokAt(7)))
                 reportError(tok,
-                            "error",
+                            Severity::error,
                             "autoVariables",
                             "Wrong assignement of an auto-variable to an effective parameter of a function");
         }
@@ -211,7 +211,7 @@ void CheckAutoVariables::autoVariables()
         {
             if (isAutoVar(tok->tokAt(2)))
                 reportError(tok,
-                            "error",
+                            Severity::error,
                             "autoVariables",
                             "Return of the address of an auto-variable");
         }
@@ -285,7 +285,7 @@ void CheckAutoVariables::returnPointerToLocalArray()
 
 void CheckAutoVariables::errorReturnPointerToLocalArray(const Token *tok)
 {
-    reportError(tok, "error", "returnLocalVariable", "Returning pointer to local array variable");
+    reportError(tok, Severity::error, "returnLocalVariable", "Returning pointer to local array variable");
 }
 
 

src/checkautovariables.h

@@ -67,7 +67,7 @@ private:
     void getErrorMessages()
     {
         std::cout << "===auto variables===" << "\n";
-        reportError(0, "error", "autoVariables", "Wrong assignement of an auto-variable to an effective parameter of a function");
+        reportError(0, Severity::error, "autoVariables", "Wrong assignement of an auto-variable to an effective parameter of a function");
         errorReturnPointerToLocalArray(0);
     }
 

src/checkbufferoverrun.cpp

@@ -52,27 +52,27 @@ void CheckBufferOverrunClass::arrayIndexOutOfBounds(const Token *tok)
 
 void CheckBufferOverrunClass::arrayIndexOutOfBounds()
 {
-    reportError(_callStack, "all", "arrayIndexOutOfBounds", "Array index out of bounds");
+    reportError(_callStack, Severity::possibleError, "arrayIndexOutOfBounds", "Array index out of bounds");
 }
 
 void CheckBufferOverrunClass::bufferOverrun(const Token *tok)
 {
-    reportError(tok, "all", "bufferOverrun", "Buffer overrun");
+    reportError(tok, Severity::possibleError, "bufferOverrun", "Buffer overrun");
 }
 
 void CheckBufferOverrunClass::strncatUsage(const Token *tok)
 {
-    reportError(tok, "all", "strncatUsage", "Dangerous usage of strncat. Tip: the 3rd parameter means maximum number of characters to append");
+    reportError(tok, Severity::possibleError, "strncatUsage", "Dangerous usage of strncat. Tip: the 3rd parameter means maximum number of characters to append");
 }
 
 void CheckBufferOverrunClass::outOfBounds(const Token *tok, const std::string &what)
 {
-    reportError(tok, "error", "outOfBounds", what + " is out of bounds");
+    reportError(tok, Severity::error, "outOfBounds", what + " is out of bounds");
 }
 
 void CheckBufferOverrunClass::sizeArgumentAsChar(const Token *tok)
 {
-    reportError(tok, "all", "sizeArgumentAsChar", "The size argument is given as a char constant");
+    reportError(tok, Severity::possibleError, "sizeArgumentAsChar", "The size argument is given as a char constant");
 }
 
 //---------------------------------------------------------------------------

src/checkclass.cpp

@@ -774,42 +774,42 @@ void CheckClass::virtualDestructor()
 
 void CheckClass::noConstructorError(const Token *tok, const std::string &classname)
 {
-    reportError(tok, "style", "noConstructor", "The class '" + classname + "' has no constructor");
+    reportError(tok, Severity::style, "noConstructor", "The class '" + classname + "' has no constructor");
 }
 
 void CheckClass::uninitVarError(const Token *tok, const std::string &classname, const std::string &varname)
 {
-    reportError(tok, "style", "uninitVar", "Member variable not initialized in the constructor '" + classname + "::" + varname + "'");
+    reportError(tok, Severity::style, "uninitVar", "Member variable not initialized in the constructor '" + classname + "::" + varname + "'");
 }
 
 void CheckClass::operatorEqVarError(const Token *tok, const std::string &classname, const std::string &varname)
 {
-    reportError(tok, "all style", "operatorEqVarError", "Member variable '" + classname + "::" + varname + "' is not assigned a value in '" + classname + "::operator=" + "'");
+    reportError(tok, Severity::possibleStyle, "operatorEqVarError", "Member variable '" + classname + "::" + varname + "' is not assigned a value in '" + classname + "::operator=" + "'");
 }
 
 void CheckClass::unusedPrivateFunctionError(const Token *tok, const std::string &classname, const std::string &funcname)
 {
-    reportError(tok, "style", "unusedPrivateFunction", "Unused private function '" + classname + "::" + funcname + "'");
+    reportError(tok, Severity::style, "unusedPrivateFunction", "Unused private function '" + classname + "::" + funcname + "'");
 }
 
 void CheckClass::memsetClassError(const Token *tok, const std::string &memfunc)
 {
-    reportError(tok, "error", "memsetClass", "Using '" + memfunc + "' on class");
+    reportError(tok, Severity::error, "memsetClass", "Using '" + memfunc + "' on class");
 }
 
 void CheckClass::memsetStructError(const Token *tok, const std::string &memfunc, const std::string &classname)
 {
-    reportError(tok, "error", "memsetStruct", "Using '" + memfunc + "' on struct that contains a 'std::" + classname + "'");
+    reportError(tok, Severity::error, "memsetStruct", "Using '" + memfunc + "' on struct that contains a 'std::" + classname + "'");
 }
 
 void CheckClass::operatorEqReturnError(const Token *tok)
 {
-    reportError(tok, "style", "operatorEq", "'operator=' should return something");
+    reportError(tok, Severity::style, "operatorEq", "'operator=' should return something");
 }
 
 void CheckClass::virtualDestructorError(const Token *tok, const std::string &Base, const std::string &Derived)
 {
-    reportError(tok, "error", "virtualDestructor", "Class " + Base + " which is inherited by class " + Derived + " does not have a virtual destructor");
+    reportError(tok, Severity::error, "virtualDestructor", "Class " + Base + " which is inherited by class " + Derived + " does not have a virtual destructor");
 }
 
 

src/checkdangerousfunctions.cpp

@@ -54,15 +54,15 @@ void CheckDangerousFunctionsClass::dangerousFunctions()
 
 void CheckDangerousFunctionsClass::dangerousFunctionmktemp(const Token *tok)
 {
-    reportError(tok, "style", "dangerousFunctionmktemp", "Found 'mktemp'. You should use 'mkstemp' instead");
+    reportError(tok, Severity::style, "dangerousFunctionmktemp", "Found 'mktemp'. You should use 'mkstemp' instead");
 }
 
 void CheckDangerousFunctionsClass::dangerousFunctiongets(const Token *tok)
 {
-    reportError(tok, "style", "dangerousFunctiongets", "Found 'gets'. You should use 'fgets' instead");
+    reportError(tok, Severity::style, "dangerousFunctiongets", "Found 'gets'. You should use 'fgets' instead");
 }
 
 void CheckDangerousFunctionsClass::dangerousFunctionscanf(const Token *tok)
 {
-    reportError(tok, "style", "dangerousFunctionscanf", "Found 'scanf'. You should use 'fgets' instead");
+    reportError(tok, Severity::style, "dangerousFunctionscanf", "Found 'scanf'. You should use 'fgets' instead");
 }

src/checkmemoryleak.cpp

@@ -226,37 +226,37 @@ void CheckMemoryLeak::memoryLeak(const Token *tok, const char varname[], AllocTy
 
 void CheckMemoryLeak::memleakError(const Token *tok, const std::string &varname)
 {
-    error(tok, "error", "memleak", "Memory leak: " + varname);
+    error(tok, Severity::error, "memleak", "Memory leak: " + varname);
 }
 
 void CheckMemoryLeak::memleakallError(const Token *tok, const std::string &varname)
 {
-    error(tok, "all", "memleakall", "Memory leak: " + varname);
+    error(tok, Severity::possibleError, "memleakall", "Memory leak: " + varname);
 }
 
 void CheckMemoryLeak::resourceLeakError(const Token *tok, const std::string &varname)
 {
-    error(tok, "error", "resourceLeak", "Resource leak: " + varname);
+    error(tok, Severity::error, "resourceLeak", "Resource leak: " + varname);
 }
 
 void CheckMemoryLeak::deallocDeallocError(const Token *tok, const std::string &varname)
 {
-    error(tok, "error", "deallocDealloc", "Deallocating a deallocated pointer: " + varname);
+    error(tok, Severity::error, "deallocDealloc", "Deallocating a deallocated pointer: " + varname);
 }
 
 void CheckMemoryLeak::deallocuseError(const Token *tok, const std::string &varname)
 {
-    error(tok, "error", "deallocuse", "Using '" + varname + "' after it is deallocated / released");
+    error(tok, Severity::error, "deallocuse", "Using '" + varname + "' after it is deallocated / released");
 }
 
 void CheckMemoryLeak::mismatchSizeError(const Token *tok, const std::string &sz)
 {
-    error(tok, "error", "mismatchSize", "The given size " + sz + " is mismatching");
+    error(tok, Severity::error, "mismatchSize", "The given size " + sz + " is mismatching");
 }
 
 void CheckMemoryLeak::mismatchAllocDealloc(const std::list<const Token *> &callstack, const std::string &varname)
 {
-    error(callstack, "error", "mismatchAllocDealloc", "Mismatching allocation and deallocation: " + varname);
+    error(callstack, Severity::error, "mismatchAllocDealloc", "Mismatching allocation and deallocation: " + varname);
 }
 
 CheckMemoryLeak::AllocType CheckMemoryLeak::functionReturnType(const Token *tok) const

src/checkmemoryleak.h

@@ -65,8 +65,8 @@ public:
     void mismatchAllocDealloc(const std::list<const Token *> &callstack, const std::string &varname);
 
     // error message
-    virtual void error(const Token *tok, const std::string &severity, const std::string &id, const std::string &msg) = 0;
+    virtual void error(const Token *tok, const Severity::e severity, const std::string &id, const std::string &msg) = 0;
-    virtual void error(const std::list<const Token *> &callstack, const std::string &severity, const std::string &id, const std::string &msg) = 0;
+    virtual void error(const std::list<const Token *> &callstack, const Severity::e severity, const std::string &id, const std::string &msg) = 0;
 
     /** What type of allocated memory does the given function return? */
     AllocType functionReturnType(const Token *tok) const;
@@ -141,12 +141,12 @@ private:
 
     void checkScope(const Token *Tok1, const char varname[], bool classmember, unsigned int sz);
 
-    void error(const Token *tok, const std::string &severity, const std::string &id, const std::string &msg)
+    void error(const Token *tok, const Severity::e severity, const std::string &id, const std::string &msg)
     {
         reportError(tok, severity, id, msg);
     }
 
-    void error(const std::list<const Token *> &callstack, const std::string &severity, const std::string &id, const std::string &msg)
+    void error(const std::list<const Token *> &callstack, const Severity::e severity, const std::string &id, const std::string &msg)
     {
         reportError(callstack, severity, id, msg);
     }
@@ -197,12 +197,12 @@ private:
     void parseClass(const Token *tok1, std::vector<const char *> &classname);
     void variable(const char classname[], const Token *tokVarname);
 
-    void error(const Token *tok, const std::string &severity, const std::string &id, const std::string &msg)
+    void error(const Token *tok, const Severity::e severity, const std::string &id, const std::string &msg)
     {
         reportError(tok, severity, id, msg);
     }
 
-    void error(const std::list<const Token *> &callstack, const std::string &severity, const std::string &id, const std::string &msg)
+    void error(const std::list<const Token *> &callstack, const Severity::e severity, const std::string &id, const std::string &msg)
     {
         reportError(callstack, severity, id, msg);
     }
@@ -251,12 +251,12 @@ public:
 
 private:
 
-    void error(const Token *tok, const std::string &severity, const std::string &id, const std::string &msg)
+    void error(const Token *tok, const Severity::e severity, const std::string &id, const std::string &msg)
     {
         reportError(tok, severity, id, msg);
     }
 
-    void error(const std::list<const Token *> &callstack, const std::string &severity, const std::string &id, const std::string &msg)
+    void error(const std::list<const Token *> &callstack, const Severity::e severity, const std::string &id, const std::string &msg)
     {
         reportError(callstack, severity, id, msg);
     }

src/checkother.cpp

@@ -965,90 +965,90 @@ void CheckOther::checkZeroDivision()
 
 void CheckOther::cstyleCastError(const Token *tok)
 {
-    reportError(tok, "style", "cstyleCast", "C-style pointer casting");
+    reportError(tok, Severity::style, "cstyleCast", "C-style pointer casting");
 }
 
 void CheckOther::redundantIfDelete0Error(const Token *tok)
 {
-    reportError(tok, "style", "redundantIfDelete0", "Redundant condition. It is safe to deallocate a NULL pointer");
+    reportError(tok, Severity::style, "redundantIfDelete0", "Redundant condition. It is safe to deallocate a NULL pointer");
 }
 
 void CheckOther::redundantIfRemoveError(const Token *tok)
 {
-    reportError(tok, "style", "redundantIfRemove", "Redundant condition. The remove function in the STL will not do anything if element doesn't exist");
+    reportError(tok, Severity::style, "redundantIfRemove", "Redundant condition. The remove function in the STL will not do anything if element doesn't exist");
 }
 
 void CheckOther::dangerousUsageStrtolError(const Token *tok)
 {
-    reportError(tok, "error", "dangerousUsageStrtol", "Invalid radix in call to strtol or strtoul. Must be 0 or 2-36");
+    reportError(tok, Severity::error, "dangerousUsageStrtol", "Invalid radix in call to strtol or strtoul. Must be 0 or 2-36");
 }
 
 void CheckOther::ifNoActionError(const Token *tok)
 {
-    reportError(tok, "style", "ifNoAction", "Found redundant if condition - 'if (condition);'");
+    reportError(tok, Severity::style, "ifNoAction", "Found redundant if condition - 'if (condition);'");
 }
 
 void CheckOther::sprintfOverlappingDataError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, "error", "sprintfOverlappingData", "Overlapping data buffer " + varname + "\nWhen using sprintf the same buffer must not be used both for output and input. The behaviour is undefined when that happens.\nFor example: 'sprintf(str,\"<%s>\",str);'");
+    reportError(tok, Severity::error, "sprintfOverlappingData", "Overlapping data buffer " + varname + "\nWhen using sprintf the same buffer must not be used both for output and input. The behaviour is undefined when that happens.\nFor example: 'sprintf(str,\"<%s>\",str);'");
 }
 
 void CheckOther::udivError(const Token *tok)
 {
-    reportError(tok, "error", "udivError", "Unsigned division. The result will be wrong.");
+    reportError(tok, Severity::error, "udivError", "Unsigned division. The result will be wrong.");
 }
 
 void CheckOther::udivWarning(const Token *tok)
 {
-    reportError(tok, "all style", "udivWarning", "Warning: Division with signed and unsigned operators");
+    reportError(tok, Severity::possibleStyle, "udivWarning", "Warning: Division with signed and unsigned operators");
 }
 
 void CheckOther::unusedStructMemberError(const Token *tok, const std::string &structname, const std::string &varname)
 {
-    reportError(tok, "style", "unusedStructMember", "struct or union member '" + structname + "::" + varname + "' is never used");
+    reportError(tok, Severity::style, "unusedStructMember", "struct or union member '" + structname + "::" + varname + "' is never used");
 }
 
 void CheckOther::passedByValueError(const Token *tok, const std::string &parname)
 {
-    reportError(tok, "style", "passedByValue", "Function parameter '" + parname + "' is passed by value. It could be passed by reference instead.");
+    reportError(tok, Severity::style, "passedByValue", "Function parameter '" + parname + "' is passed by value. It could be passed by reference instead.");
 }
 
 void CheckOther::constStatementError(const Token *tok, const std::string &type)
 {
-    reportError(tok, "style", "constStatement", "Redundant code: Found a statement that begins with " + type + " constant");
+    reportError(tok, Severity::style, "constStatement", "Redundant code: Found a statement that begins with " + type + " constant");
 }
 
 void CheckOther::charArrayIndexError(const Token *tok)
 {
-    reportError(tok, "style", "charArrayIndex", "Warning - using char variable as array index");
+    reportError(tok, Severity::style, "charArrayIndex", "Warning - using char variable as array index");
 }
 
 void CheckOther::charBitOpError(const Token *tok)
 {
-    reportError(tok, "style", "charBitOp", "Warning - using char variable in bit operation");
+    reportError(tok, Severity::style, "charBitOp", "Warning - using char variable in bit operation");
 }
 
 void CheckOther::variableScopeError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, "style", "variableScope", "The scope of the variable " + varname + " can be limited");
+    reportError(tok, Severity::style, "variableScope", "The scope of the variable " + varname + " can be limited");
 }
 
 void CheckOther::conditionAlwaysTrueFalse(const Token *tok, const std::string &truefalse)
 {
-    reportError(tok, "style", "conditionAlwaysTrueFalse", "Condition is always " + truefalse);
+    reportError(tok, Severity::style, "conditionAlwaysTrueFalse", "Condition is always " + truefalse);
 }
 
 void CheckOther::strPlusChar(const Token *tok)
 {
-    reportError(tok, "error", "strPlusChar", "Unusual pointer arithmetic");
+    reportError(tok, Severity::error, "strPlusChar", "Unusual pointer arithmetic");
 }
 
 void CheckOther::nullPointerError(const Token *tok)
 {
-    reportError(tok, "error", "nullPointer", "Possible null pointer dereference");
+    reportError(tok, Severity::error, "nullPointer", "Possible null pointer dereference");
 }
 
 void CheckOther::zerodivError(const Token *tok)
 {
-    reportError(tok, "error", "zerodiv", "Division by zero");
+    reportError(tok, Severity::error, "zerodiv", "Division by zero");
 }

src/checkstl.cpp

@@ -31,13 +31,13 @@ CheckStl instance;
 // Error message for bad iterator usage..
 void CheckStl::iteratorsError(const Token *tok, const std::string &container1, const std::string &container2)
 {
-    reportError(tok, "error", "iterators", "Same iterator is used with both " + container1 + " and " + container2);
+    reportError(tok, Severity::error, "iterators", "Same iterator is used with both " + container1 + " and " + container2);
 }
 
 // Error message used when dereferencing an iterator that has been erased..
 void CheckStl::dereferenceErasedError(const Token *tok, const std::string &itername)
 {
-    reportError(tok, "error", "eraseDereference", "Dereferenced iterator '" + itername + "' has been erased");
+    reportError(tok, Severity::error, "eraseDereference", "Dereferenced iterator '" + itername + "' has been erased");
 }
 
 void CheckStl::iterators()
@@ -131,7 +131,7 @@ void CheckStl::stlOutOfBounds()
 // Error message for bad iterator usage..
 void CheckStl::stlOutOfBoundsError(const Token *tok, const std::string &num, const std::string &var)
 {
-    reportError(tok, "error", "stlOutOfBounds", "When " + num + "==" + var + ".size(), " + var + "[" + num + "] is out of bounds");
+    reportError(tok, Severity::error, "stlOutOfBounds", "When " + num + "==" + var + ".size(), " + var + "[" + num + "] is out of bounds");
 }
 
 
@@ -210,7 +210,7 @@ void CheckStl::eraseCheckLoop(const Token *it)
 // Error message for bad iterator usage..
 void CheckStl::eraseError(const Token *tok)
 {
-    reportError(tok, "error", "erase", "Dangerous usage of erase\nAfter erase has been used the iterator may be invalid so dereferencing it or comparing it with other iterator is invalid.");
+    reportError(tok, Severity::error, "erase", "Dangerous usage of erase\nAfter erase has been used the iterator may be invalid so dereferencing it or comparing it with other iterator is invalid.");
 }
 
 
@@ -317,14 +317,14 @@ void CheckStl::pushback()
 // Error message for bad iterator usage..
 void CheckStl::pushbackError(const Token *tok, const std::string &iterator_name)
 {
-    reportError(tok, "error", "pushback", "After push_back or push_front, the iterator '" + iterator_name + "' may be invalid");
+    reportError(tok, Severity::error, "pushback", "After push_back or push_front, the iterator '" + iterator_name + "' may be invalid");
 }
 
 
 // Error message for bad iterator usage..
 void CheckStl::invalidPointerError(const Token *tok, const std::string &pointer_name)
 {
-    reportError(tok, "error", "pushback", "Invalid pointer '" + pointer_name + "' after push_back / push_front");
+    reportError(tok, Severity::error, "pushback", "Invalid pointer '" + pointer_name + "' after push_back / push_front");
 }
 
 
@@ -374,5 +374,5 @@ void CheckStl::stlBoundries()
 // Error message for bad boundry usage..
 void CheckStl::stlBoundriesError(const Token *tok)
 {
-    reportError(tok, "error", "stlBoundries", "STL range check should be using != and not < since the order of the pointers isn't guaranteed");
+    reportError(tok, Severity::error, "stlBoundries", "STL range check should be using != and not < since the order of the pointers isn't guaranteed");
 }

src/errorlogger.h

@@ -334,4 +334,28 @@ private:
     void _writemsg(const Tokenizer *tokenizer, const Token *tok, const char severity[], const std::string &msg, const std::string &id);
     void _writemsg(const Tokenizer *tokenizer, const std::list<const Token *> &callstack, const char severity[], const std::string &msg, const std::string &id);
 };
+
+/** enum class for severity */
+class Severity
+{
+public:
+    enum e { error, style, possibleError, possibleStyle };
+    static std::string stringify(e severity)
+    {
+        switch (severity)
+        {
+            case error:
+                return "error";
+            case style:
+                return "style";
+            case possibleError:
+                return "possible error";
+            case possibleStyle:
+                return "possible style";
+        };
+        return "???";
+    }
+};
+
+
 #endif

test/testbufferoverrun.cpp

@@ -200,7 +200,7 @@ private:
               "    int data[2];\n"
               "    data[ sizeof(data[0]) ] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Array index out of bounds\n", errout.str());
     }
 
     void sizeof3()
@@ -223,7 +223,7 @@ private:
               "    str[15] = 0;\n"
               "    str[16] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -235,7 +235,7 @@ private:
               "    str[15] = 0;\n"
               "    str[16] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -248,7 +248,7 @@ private:
                   "    for (i = 0; i < 100; i++)\n"
                   "        sum += val[i];\n"
                   "}\n");
-            ASSERT_EQUALS("[test.cpp:5]: (all) Buffer overrun\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:5]: (possible error) Buffer overrun\n", errout.str());
         }
 
         {
@@ -258,7 +258,7 @@ private:
                   "    for (i = 1; i < 100; i++)\n"
                   "        sum += val[i];\n"
                   "}\n");
-            ASSERT_EQUALS("[test.cpp:5]: (all) Buffer overrun\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:5]: (possible error) Buffer overrun\n", errout.str());
         }
 
 
@@ -269,7 +269,7 @@ private:
                   "    for (i = a; i < 100; i++)\n"
                   "        sum += val[i];\n"
                   "}\n");
-            ASSERT_EQUALS("[test.cpp:5]: (all) Buffer overrun\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:5]: (possible error) Buffer overrun\n", errout.str());
         }
     }
 
@@ -282,7 +282,7 @@ private:
               "    int i[SIZE];\n"
               "    i[SIZE] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -293,7 +293,7 @@ private:
               "    int i[10];\n"
               "    i[ sizeof(i) - 1 ] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -309,7 +309,7 @@ private:
               "    struct ABC abc;\n"
               "    abc.str[10] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:9]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -324,7 +324,7 @@ private:
               "{\n"
               "    abc->str[10] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:8]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -342,7 +342,7 @@ private:
               "    struct ABC abc;\n"
               "    abc.str[SIZE] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:11]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11]: (possible error) Array index out of bounds\n", errout.str());
     }
 
     void array_index_9()
@@ -357,7 +357,7 @@ private:
               "    char str[5];\n"
               "    memclr( str );   // ERROR\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:3]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:3]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -377,7 +377,7 @@ private:
               "{\n"
               "    memclr(abc->str);\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:13] -> [test.cpp:8]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:13] -> [test.cpp:8]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -398,7 +398,7 @@ private:
               "        abc->str[10] = 0;\n"
               "    }\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:12]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:12]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -415,7 +415,7 @@ private:
               "{\n"
               "    str[10] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:10]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10]: (possible error) Array index out of bounds\n", errout.str());
     }
 
     void array_index_13()
@@ -439,7 +439,7 @@ private:
               "    char str[3];\n"
               "    strcpy(str, \"abc\");\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (all) Buffer overrun\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Buffer overrun\n", errout.str());
     }
 
 
@@ -454,7 +454,7 @@ private:
               "{\n"
               "    strcpy( abc->str, \"abcdef\" );\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:8]: (all) Buffer overrun\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8]: (possible error) Buffer overrun\n", errout.str());
     }
 
 
@@ -468,7 +468,7 @@ private:
               "    for (i = 0; i <= 10; ++i)\n"
               "        a[i] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:7]: (all) Buffer overrun\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7]: (possible error) Buffer overrun\n", errout.str());
     }
 
 
@@ -480,7 +480,7 @@ private:
               "    for (int i = 0; i < 8; ++i)\n"
               "        p[i] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (all) Buffer overrun\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5]: (possible error) Buffer overrun\n", errout.str());
 
         // No false positive
         check("void foo(int x, int y)\n"
@@ -501,7 +501,7 @@ private:
               "    char str[3];\n"
               "    sprintf(str, \"%s\", \"abc\");\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (all) Buffer overrun\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Buffer overrun\n", errout.str());
     }
 
     void snprintf1()
@@ -555,7 +555,7 @@ private:
               "    strncpy(str, a, 10);\n"
               "    strncat(str, b, 10);\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (all) Dangerous usage of strncat. Tip: the 3rd parameter means maximum number of characters to append\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5]: (possible error) Dangerous usage of strncat. Tip: the 3rd parameter means maximum number of characters to append\n", errout.str());
     }
 
     void strncat2()
@@ -565,7 +565,7 @@ private:
               "    char str[5];\n"
               "    strncat(str, a, 5);\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (all) Dangerous usage of strncat. Tip: the 3rd parameter means maximum number of characters to append\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Dangerous usage of strncat. Tip: the 3rd parameter means maximum number of characters to append\n", errout.str());
     }
 
 
@@ -577,7 +577,7 @@ private:
               "    char str[10];\n"
               "    cin >> str;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (all) Buffer overrun\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Buffer overrun\n", errout.str());
     }
 
 
@@ -619,7 +619,7 @@ private:
               "{\n"
               "    str[3] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -631,14 +631,14 @@ private:
               "    char *s = new char[10];\n"
               "    s[10] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Array index out of bounds\n", errout.str());
 
         check("void foo()\n"
               "{\n"
               "    char *s = malloc(10);\n"
               "    s[10] = 0;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (all) Array index out of bounds\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Array index out of bounds\n", errout.str());
     }
 
 
@@ -649,7 +649,7 @@ private:
               "    char s[10];\n"
               "    memset(s, 5, '*');\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (all) The size argument is given as a char constant\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) The size argument is given as a char constant\n", errout.str());
     }
 };
 

test/testconstructors.cpp

@@ -216,7 +216,7 @@ private:
               "    void operator=(const Fred &fred) { }\n"
               "    int i;\n"
               "};\n");
-        ASSERT_EQUALS("[test.cpp:5]: (all style) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5]: (possible style) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='\n", errout.str());
     }
 
     void initvar_operator_eq3()
@@ -382,7 +382,7 @@ private:
               "\n"
               "void Fred::operator=(const Fred &f)\n"
               "{ }", true);
-        ASSERT_EQUALS("[test.cpp:13]: (all style) Member variable 'Fred::ints' is not assigned a value in 'Fred::operator='\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:13]: (possible style) Member variable 'Fred::ints' is not assigned a value in 'Fred::operator='\n", errout.str());
     }
 };
 

test/testdivision.cpp

@@ -74,7 +74,7 @@ private:
               "    unsigned int uvar = 2;\n"
               "    return ivar / uvar;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (all style) Warning: Division with signed and unsigned operators\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5]: (possible style) Warning: Division with signed and unsigned operators\n", errout.str());
     }
 
     void division2()
@@ -85,7 +85,7 @@ private:
               "    unsigned int uvar = 2;\n"
               "    return uvar / ivar;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (all style) Warning: Division with signed and unsigned operators\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5]: (possible style) Warning: Division with signed and unsigned operators\n", errout.str());
     }
 
     void division3()
@@ -98,7 +98,7 @@ private:
               "    u32 uvar = 2;\n"
               "    return uvar / ivar;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:7]: (all style) Warning: Division with signed and unsigned operators\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7]: (possible style) Warning: Division with signed and unsigned operators\n", errout.str());
     }
 
     void division4()

test/testmemleak.cpp

@@ -607,7 +607,7 @@ private:
               "        return;\n"
               "    }\n"
               "}\n", true);
-        ASSERT_EQUALS("[test.cpp:9]: (all) Memory leak: str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9]: (possible error) Memory leak: str\n", errout.str());
     }
 
 
@@ -1128,7 +1128,7 @@ private:
         check(code.c_str(), false);
         ASSERT_EQUALS("", errout.str());
         check(code.c_str(), true);
-        ASSERT_EQUALS("[test.cpp:12]: (all) Memory leak: str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:12]: (possible error) Memory leak: str\n", errout.str());
     }
 
     void switch3()
@@ -1923,7 +1923,7 @@ private:
               "{\n"
               "    Fred *f = new Fred;\n"
               "}\n", true);
-        ASSERT_EQUALS("[test.cpp:4]: (all) Memory leak: f\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Memory leak: f\n", errout.str());
     }
 
 
@@ -2519,7 +2519,7 @@ private:
               "    delete [] str2;\n"
               "}\n", true);
 
-        ASSERT_EQUALS("[test.cpp:4]: (all) Memory leak: Fred::str1\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Memory leak: Fred::str1\n", errout.str());
     }
 
 
@@ -2691,7 +2691,7 @@ private:
               "    int * p;\n"
               "    A() { p = new int; }\n"
               "};\n", true);
-        ASSERT_EQUALS("[test.cpp:4]: (all) Memory leak: A::p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Memory leak: A::p\n", errout.str());
     }
 
     void class11()
@@ -2704,7 +2704,7 @@ private:
               "};\n"
               "A::A() : p(new int[10])\n"
               "{ }", true);
-        ASSERT_EQUALS("[test.cpp:4]: (all) Memory leak: A::p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (possible error) Memory leak: A::p\n", errout.str());
     }