CWE mapping of useAutoPointerMalloc, uselessCallsCompare, uselessCallsSwap, uselessCallsSubstr, uselessCallsEmpty, uselessCallsRemove, derefInvalidIterator, reademptycontainer, multiplySizeof, divideSizeof, stringLiteralWrite, incorrectStringCompare, literalWithCharPtrCompare, charLiteralWithCharPtrCompare, incorrectStringBooleanError, staticStringCompare, stringCompare, signConversion, truncLongCastAssignment, truncLongCastReturn, unusedFunction, unusedVariable, unusedAllocatedMemory, unreadVariable, unassignedVariable, unusedStructMember, postfixOperator, va_start_wrongParameter (danmar#824)

boos · PKEuS · commit 28f1222dc2ea · 2016-09-03T00:31:35.000+02:00
Add an optional extended description…
diff --git a/lib/checkpostfixoperator.cpp b/lib/checkpostfixoperator.cpp
@@ -32,6 +32,11 @@ namespace {
     CheckPostfixOperator instance;
 }
 
+
+// CWE ids used
+static const struct CWE CWE398(398U);   // Indicator of Poor Code Quality
+
+
 void CheckPostfixOperator::postfixOperator()
 {
     if (!_settings->isEnabled("performance"))
@@ -74,5 +79,5 @@ void CheckPostfixOperator::postfixOperatorError(const Token *tok)
                 "Pre-increment/decrement can be more efficient than "
                 "post-increment/decrement. Post-increment/decrement usually "
                 "involves keeping a copy of the previous value around and "
-                "adds a little extra code.");
+                "adds a little extra code.", CWE398, false);
 }
diff --git a/lib/checksizeof.cpp b/lib/checksizeof.cpp
@@ -338,15 +338,15 @@ void CheckSizeof::suspiciousSizeofCalculation()
 void CheckSizeof::multiplySizeofError(const Token *tok)
 {
     reportError(tok, Severity::warning,
-                "multiplySizeof", "Multiplying sizeof() with sizeof() indicates a logic error.", CWE(0U), true);
+                "multiplySizeof", "Multiplying sizeof() with sizeof() indicates a logic error.", CWE682, true);
 }
 
 void CheckSizeof::divideSizeofError(const Token *tok)
 {
     reportError(tok, Severity::warning,
                 "divideSizeof", "Division of result of sizeof() on pointer type.\n"
                 "Division of result of sizeof() on pointer type. sizeof() returns the size of the pointer, "
-                "not the size of the memory area it points to.", CWE(0U), true);
+                "not the size of the memory area it points to.", CWE682, true);
 }
 
 void CheckSizeof::sizeofVoid()
diff --git a/lib/checkstl.cpp b/lib/checkstl.cpp
@@ -30,9 +30,12 @@ namespace {
 // CWE IDs used:
 static const struct CWE CWE398(398U);   // Indicator of Poor Code Quality
 static const struct CWE CWE597(597U);   // Use of Wrong Operator in String Comparison
+static const struct CWE CWE628(628U);   // Function Call with Incorrectly Specified Arguments
 static const struct CWE CWE664(664U);   // Improper Control of a Resource Through its Lifetime
 static const struct CWE CWE704(704U);   // Incorrect Type Conversion or Cast
+static const struct CWE CWE762(762U);   // Mismatched Memory Management Routines
 static const struct CWE CWE788(788U);   // Access of Memory Location After End of Buffer
+static const struct CWE CWE825(825U);   // Expired Pointer Dereference
 static const struct CWE CWE834(834U);   // Excessive Iteration
 
 // Error message for bad iterator usage..
@@ -1277,7 +1280,7 @@ void CheckStl::autoPointerMallocError(const Token *tok, const std::string& alloc
 {
     const std::string summary = "Object pointed by an 'auto_ptr' is destroyed using operator 'delete'. You should not use 'auto_ptr' for pointers obtained with function '" + allocFunction + "'.";
     const std::string verbose = summary + " This means that you should only use 'auto_ptr' for pointers obtained with operator 'new'. This excludes use C library allocation functions (for example '" + allocFunction + "'), which must be deallocated by the appropriate C library function.";
-    reportError(tok, Severity::error, "useAutoPointerMalloc", summary + "\n" + verbose);
+    reportError(tok, Severity::error, "useAutoPointerMalloc", summary + "\n" + verbose, CWE762, false);
 }
 
 namespace {
@@ -1341,7 +1344,7 @@ void CheckStl::uselessCallsReturnValueError(const Token *tok, const std::string
            << "(" << varname << "." << function << "(" << varname << ")). As it is currently the "
            << "code is inefficient. It is possible either the string searched ('"
            << varname << "') or searched for ('" << varname << "') is wrong.";
-    reportError(tok, Severity::warning, "uselessCallsCompare", errmsg.str());
+    reportError(tok, Severity::warning, "uselessCallsCompare", errmsg.str(), CWE628, false);
 }
 
 void CheckStl::uselessCallsSwapError(const Token *tok, const std::string &varname)
@@ -1351,27 +1354,27 @@ void CheckStl::uselessCallsSwapError(const Token *tok, const std::string &varnam
            << "The 'swap()' function has no logical effect when given itself as parameter "
            << "(" << varname << ".swap(" << varname << ")). As it is currently the "
            << "code is inefficient. Is the object or the parameter wrong here?";
-    reportError(tok, Severity::performance, "uselessCallsSwap", errmsg.str());
+    reportError(tok, Severity::performance, "uselessCallsSwap", errmsg.str(), CWE628, false);
 }
 
 void CheckStl::uselessCallsSubstrError(const Token *tok, bool empty)
 {
     if (empty)
-        reportError(tok, Severity::performance, "uselessCallsSubstr", "Ineffective call of function 'substr' because it returns an empty string.");
+        reportError(tok, Severity::performance, "uselessCallsSubstr", "Ineffective call of function 'substr' because it returns an empty string.", CWE398, false);
     else
-        reportError(tok, Severity::performance, "uselessCallsSubstr", "Ineffective call of function 'substr' because it returns a copy of the object. Use operator= instead.");
+        reportError(tok, Severity::performance, "uselessCallsSubstr", "Ineffective call of function 'substr' because it returns a copy of the object. Use operator= instead.", CWE398, false);
 }
 
 void CheckStl::uselessCallsEmptyError(const Token *tok)
 {
-    reportError(tok, Severity::warning, "uselessCallsEmpty", "Ineffective call of function 'empty()'. Did you intend to call 'clear()' instead?");
+    reportError(tok, Severity::warning, "uselessCallsEmpty", "Ineffective call of function 'empty()'. Did you intend to call 'clear()' instead?", CWE398, false);
 }
 
 void CheckStl::uselessCallsRemoveError(const Token *tok, const std::string& function)
 {
     reportError(tok, Severity::warning, "uselessCallsRemove", "Return value of std::" + function + "() ignored. Elements remain in container.\n"
                 "The return value of std::" + function + "() is ignored. This function returns an iterator to the end of the range containing those elements that should be kept. "
-                "Elements past new end remain valid but with unspecified values. Use the erase method of the container to delete them.");
+                "Elements past new end remain valid but with unspecified values. Use the erase method of the container to delete them.", CWE762, false);
 }
 
 // Check for iterators being dereferenced before being checked for validity.
@@ -1442,7 +1445,7 @@ void CheckStl::dereferenceInvalidIteratorError(const Token* deref, const std::st
 {
     reportError(deref, Severity::warning,
                 "derefInvalidIterator", "Possible dereference of an invalid iterator: " + iterName + "\n" +
-                "Make sure to check that the iterator is valid before dereferencing it - not after.");
+                "Make sure to check that the iterator is valid before dereferencing it - not after.", CWE825, false);
 }
 
 
@@ -1557,5 +1560,5 @@ void CheckStl::readingEmptyStlContainer()
 
 void CheckStl::readingEmptyStlContainerError(const Token *tok)
 {
-    reportError(tok, Severity::style, "reademptycontainer", "Reading from empty STL container '" + (tok ? tok->str() : std::string("var")) + "'", CWE(0U), true);
+    reportError(tok, Severity::style, "reademptycontainer", "Reading from empty STL container '" + (tok ? tok->str() : std::string("var")) + "'", CWE398, true);
 }
diff --git a/lib/checkstring.cpp b/lib/checkstring.cpp
@@ -34,7 +34,7 @@ static const struct CWE CWE571(571U);   // Expression is Always True
 static const struct CWE CWE595(595U);   // Comparison of Object References Instead of Object Contents
 static const struct CWE CWE628(628U);   // Function Call with Incorrectly Specified Arguments
 static const struct CWE CWE665(665U);   // Improper Initialization
-
+static const struct CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
 
 //---------------------------------------------------------------------------
 // Writing string literal is UB
@@ -75,7 +75,7 @@ void CheckString::stringLiteralWriteError(const Token *tok, const Token *strValu
     }
     errmsg += " directly or indirectly is undefined behaviour.";
 
-    reportError(callstack, Severity::error, "stringLiteralWrite", errmsg);
+    reportError(callstack, Severity::error, "stringLiteralWrite", errmsg, CWE758, false);
 }
 
 //---------------------------------------------------------------------------
diff --git a/lib/checktype.cpp b/lib/checktype.cpp
@@ -37,6 +37,7 @@ namespace {
 
 // CWE ids used:
 static const struct CWE CWE195(195U);   // Signed to Unsigned Conversion Error
+static const struct CWE CWE197(197U);   // Numeric Truncation Error
 static const struct CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
 static const struct CWE CWE190(190U);   // Integer Overflow or Wraparound
 
@@ -290,7 +291,7 @@ void CheckType::longCastAssignError(const Token *tok)
                 Severity::style,
                 "truncLongCastAssignment",
                 "int result is assigned to long variable. If the variable is long to avoid loss of information, then you have loss of information.\n"
-                "int result is assigned to long variable. If the variable is long to avoid loss of information, then there is loss of information. To avoid loss of information you must cast a calculation operand to long, for example 'l = a * b;' => 'l = (long)a * b;'.");
+                "int result is assigned to long variable. If the variable is long to avoid loss of information, then there is loss of information. To avoid loss of information you must cast a calculation operand to long, for example 'l = a * b;' => 'l = (long)a * b;'.", CWE197, false);
 }
 
 void CheckType::longCastReturnError(const Token *tok)
@@ -299,5 +300,5 @@ void CheckType::longCastReturnError(const Token *tok)
                 Severity::style,
                 "truncLongCastReturn",
                 "int result is returned as long value. If the return value is long to avoid loss of information, then you have loss of information.\n"
-                "int result is returned as long value. If the return value is long to avoid loss of information, then there is loss of information. To avoid loss of information you must cast a calculation operand to long, for example 'return a*b;' => 'return (long)a*b'.");
+                "int result is returned as long value. If the return value is long to avoid loss of information, then there is loss of information. To avoid loss of information you must cast a calculation operand to long, for example 'return a*b;' => 'return (long)a*b'.", CWE197, false);
 }
diff --git a/lib/checkunusedvar.cpp b/lib/checkunusedvar.cpp
@@ -30,6 +30,7 @@ namespace {
 }
 
 static const struct CWE CWE563(563U);   // Assignment to Variable without Use ('Unused Variable')
+static const struct CWE CWE665(665U);   // Improper Initialization
 
 
 /**
@@ -1205,17 +1206,17 @@ void CheckUnusedVar::unusedVariableError(const Token *tok, const std::string &va
 
 void CheckUnusedVar::allocatedButUnusedVariableError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, Severity::style, "unusedAllocatedMemory", "Variable '" + varname + "' is allocated memory that is never used.");
+    reportError(tok, Severity::style, "unusedAllocatedMemory", "Variable '" + varname + "' is allocated memory that is never used.", CWE563, false);
 }
 
 void CheckUnusedVar::unreadVariableError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, Severity::style, "unreadVariable", "Variable '" + varname + "' is assigned a value that is never used.");
+    reportError(tok, Severity::style, "unreadVariable", "Variable '" + varname + "' is assigned a value that is never used.", CWE563, false);
 }
 
 void CheckUnusedVar::unassignedVariableError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, Severity::style, "unassignedVariable", "Variable '" + varname + "' is not assigned a value.");
+    reportError(tok, Severity::style, "unassignedVariable", "Variable '" + varname + "' is not assigned a value.", CWE665, false);
 }
 
 //---------------------------------------------------------------------------
@@ -1302,7 +1303,7 @@ void CheckUnusedVar::checkStructMemberUsage()
 void CheckUnusedVar::unusedStructMemberError(const Token *tok, const std::string &structname, const std::string &varname, bool isUnion)
 {
     const char* prefix = isUnion ? "union member '" : "struct member '";
-    reportError(tok, Severity::style, "unusedStructMember", std::string(prefix) + structname + "::" + varname + "' is never used.");
+    reportError(tok, Severity::style, "unusedStructMember", std::string(prefix) + structname + "::" + varname + "' is never used.", CWE563, false);
 }
 
 bool CheckUnusedVar::isRecordTypeWithoutSideEffects(const Type* type)
diff --git a/lib/checkvaarg.cpp b/lib/checkvaarg.cpp
@@ -32,8 +32,9 @@ namespace {
 //---------------------------------------------------------------------------
 
 // CWE ids used:
-static const struct CWE CWE664(664U);
-static const struct CWE CWE758(758U);
+static const struct CWE CWE664(664U);   // Improper Control of a Resource Through its Lifetime
+static const struct CWE CWE688(688U);   // Function Call With Incorrect Variable or Reference as Argument
+static const struct CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
 
 void CheckVaarg::va_start_argument()
 {
@@ -70,7 +71,7 @@ void CheckVaarg::va_start_argument()
 void CheckVaarg::wrongParameterTo_va_start_error(const Token *tok, const std::string& paramIsName, const std::string& paramShouldName)
 {
     reportError(tok, Severity::warning,
-                "va_start_wrongParameter", "'" + paramIsName + "' given to va_start() is not last named argument of the function. Did you intend to pass '" + paramShouldName + "'?");
+                "va_start_wrongParameter", "'" + paramIsName + "' given to va_start() is not last named argument of the function. Did you intend to pass '" + paramShouldName + "'?", CWE688, false);
 }
 
 void CheckVaarg::referenceAs_va_start_error(const Token *tok, const std::string& paramName)

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,11 @@ namespace {`
`32`	`32`	`CheckPostfixOperator instance;`
`33`	`33`	`}`
`34`	`34`
	`35`	`+`
	`36`	`+// CWE ids used`
	`37`	`+static const struct CWE CWE398(398U); // Indicator of Poor Code Quality`
	`38`	`+`
	`39`	`+`
`35`	`40`	`void CheckPostfixOperator::postfixOperator()`
`36`	`41`	`{`
`37`	`42`	`if (!_settings->isEnabled("performance"))`
`@@ -74,5 +79,5 @@ void CheckPostfixOperator::postfixOperatorError(const Token *tok)`
`74`	`79`	`"Pre-increment/decrement can be more efficient than "`
`75`	`80`	`"post-increment/decrement. Post-increment/decrement usually "`
`76`	`81`	`"involves keeping a copy of the previous value around and "`
`77`		`- "adds a little extra code.");`
	`82`	`+ "adds a little extra code.", CWE398, false);`
`78`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -338,15 +338,15 @@ void CheckSizeof::suspiciousSizeofCalculation()`
`338`	`338`	`void CheckSizeof::multiplySizeofError(const Token *tok)`
`339`	`339`	`{`
`340`	`340`	`reportError(tok, Severity::warning,`
`341`		`- "multiplySizeof", "Multiplying sizeof() with sizeof() indicates a logic error.", CWE(0U), true);`
	`341`	`+ "multiplySizeof", "Multiplying sizeof() with sizeof() indicates a logic error.", CWE682, true);`
`342`	`342`	`}`
`343`	`343`
`344`	`344`	`void CheckSizeof::divideSizeofError(const Token *tok)`
`345`	`345`	`{`
`346`	`346`	`reportError(tok, Severity::warning,`
`347`	`347`	`"divideSizeof", "Division of result of sizeof() on pointer type.\n"`
`348`	`348`	`"Division of result of sizeof() on pointer type. sizeof() returns the size of the pointer, "`
`349`		`- "not the size of the memory area it points to.", CWE(0U), true);`
	`349`	`+ "not the size of the memory area it points to.", CWE682, true);`
`350`	`350`	`}`
`351`	`351`
`352`	`352`	`void CheckSizeof::sizeofVoid()`
Original file line number	Diff line number	Diff line change
`@@ -30,9 +30,12 @@ namespace {`
`30`	`30`	`// CWE IDs used:`
`31`	`31`	`static const struct CWE CWE398(398U); // Indicator of Poor Code Quality`
`32`	`32`	`static const struct CWE CWE597(597U); // Use of Wrong Operator in String Comparison`
	`33`	`+static const struct CWE CWE628(628U); // Function Call with Incorrectly Specified Arguments`
`33`	`34`	`static const struct CWE CWE664(664U); // Improper Control of a Resource Through its Lifetime`
`34`	`35`	`static const struct CWE CWE704(704U); // Incorrect Type Conversion or Cast`
	`36`	`+static const struct CWE CWE762(762U); // Mismatched Memory Management Routines`
`35`	`37`	`static const struct CWE CWE788(788U); // Access of Memory Location After End of Buffer`
	`38`	`+static const struct CWE CWE825(825U); // Expired Pointer Dereference`
`36`	`39`	`static const struct CWE CWE834(834U); // Excessive Iteration`
`37`	`40`
`38`	`41`	`// Error message for bad iterator usage..`
`@@ -1277,7 +1280,7 @@ void CheckStl::autoPointerMallocError(const Token *tok, const std::string& alloc`
`1277`	`1280`	`{`
`1278`	`1281`	`const std::string summary = "Object pointed by an 'auto_ptr' is destroyed using operator 'delete'. You should not use 'auto_ptr' for pointers obtained with function '" + allocFunction + "'.";`
`1279`	`1282`	`const std::string verbose = summary + " This means that you should only use 'auto_ptr' for pointers obtained with operator 'new'. This excludes use C library allocation functions (for example '" + allocFunction + "'), which must be deallocated by the appropriate C library function.";`
`1280`		`- reportError(tok, Severity::error, "useAutoPointerMalloc", summary + "\n" + verbose);`
	`1283`	`+ reportError(tok, Severity::error, "useAutoPointerMalloc", summary + "\n" + verbose, CWE762, false);`
`1281`	`1284`	`}`
`1282`	`1285`
`1283`	`1286`	`namespace {`
`@@ -1341,7 +1344,7 @@ void CheckStl::uselessCallsReturnValueError(const Token *tok, const std::string`
`1341`	`1344`	`<< "(" << varname << "." << function << "(" << varname << ")). As it is currently the "`
`1342`	`1345`	`<< "code is inefficient. It is possible either the string searched ('"`
`1343`	`1346`	`<< varname << "') or searched for ('" << varname << "') is wrong.";`
`1344`		`- reportError(tok, Severity::warning, "uselessCallsCompare", errmsg.str());`
	`1347`	`+ reportError(tok, Severity::warning, "uselessCallsCompare", errmsg.str(), CWE628, false);`
`1345`	`1348`	`}`
`1346`	`1349`
`1347`	`1350`	`void CheckStl::uselessCallsSwapError(const Token *tok, const std::string &varname)`
`@@ -1351,27 +1354,27 @@ void CheckStl::uselessCallsSwapError(const Token *tok, const std::string &varnam`
`1351`	`1354`	`<< "The 'swap()' function has no logical effect when given itself as parameter "`
`1352`	`1355`	`<< "(" << varname << ".swap(" << varname << ")). As it is currently the "`
`1353`	`1356`	`<< "code is inefficient. Is the object or the parameter wrong here?";`
`1354`		`- reportError(tok, Severity::performance, "uselessCallsSwap", errmsg.str());`
	`1357`	`+ reportError(tok, Severity::performance, "uselessCallsSwap", errmsg.str(), CWE628, false);`
`1355`	`1358`	`}`
`1356`	`1359`
`1357`	`1360`	`void CheckStl::uselessCallsSubstrError(const Token *tok, bool empty)`
`1358`	`1361`	`{`
`1359`	`1362`	`if (empty)`
`1360`		`- reportError(tok, Severity::performance, "uselessCallsSubstr", "Ineffective call of function 'substr' because it returns an empty string.");`
	`1363`	`+ reportError(tok, Severity::performance, "uselessCallsSubstr", "Ineffective call of function 'substr' because it returns an empty string.", CWE398, false);`
`1361`	`1364`	`else`
`1362`		`- reportError(tok, Severity::performance, "uselessCallsSubstr", "Ineffective call of function 'substr' because it returns a copy of the object. Use operator= instead.");`
	`1365`	`+ reportError(tok, Severity::performance, "uselessCallsSubstr", "Ineffective call of function 'substr' because it returns a copy of the object. Use operator= instead.", CWE398, false);`
`1363`	`1366`	`}`
`1364`	`1367`
`1365`	`1368`	`void CheckStl::uselessCallsEmptyError(const Token *tok)`
`1366`	`1369`	`{`
`1367`		`- reportError(tok, Severity::warning, "uselessCallsEmpty", "Ineffective call of function 'empty()'. Did you intend to call 'clear()' instead?");`
	`1370`	`+ reportError(tok, Severity::warning, "uselessCallsEmpty", "Ineffective call of function 'empty()'. Did you intend to call 'clear()' instead?", CWE398, false);`
`1368`	`1371`	`}`
`1369`	`1372`
`1370`	`1373`	`void CheckStl::uselessCallsRemoveError(const Token *tok, const std::string& function)`
`1371`	`1374`	`{`
`1372`	`1375`	`reportError(tok, Severity::warning, "uselessCallsRemove", "Return value of std::" + function + "() ignored. Elements remain in container.\n"`
`1373`	`1376`	`"The return value of std::" + function + "() is ignored. This function returns an iterator to the end of the range containing those elements that should be kept. "`
`1374`		`- "Elements past new end remain valid but with unspecified values. Use the erase method of the container to delete them.");`
	`1377`	`+ "Elements past new end remain valid but with unspecified values. Use the erase method of the container to delete them.", CWE762, false);`
`1375`	`1378`	`}`
`1376`	`1379`
`1377`	`1380`	`// Check for iterators being dereferenced before being checked for validity.`
`@@ -1442,7 +1445,7 @@ void CheckStl::dereferenceInvalidIteratorError(const Token* deref, const std::st`
`1442`	`1445`	`{`
`1443`	`1446`	`reportError(deref, Severity::warning,`
`1444`	`1447`	`"derefInvalidIterator", "Possible dereference of an invalid iterator: " + iterName + "\n" +`
`1445`		`- "Make sure to check that the iterator is valid before dereferencing it - not after.");`
	`1448`	`+ "Make sure to check that the iterator is valid before dereferencing it - not after.", CWE825, false);`
`1446`	`1449`	`}`
`1447`	`1450`
`1448`	`1451`
`@@ -1557,5 +1560,5 @@ void CheckStl::readingEmptyStlContainer()`
`1557`	`1560`
`1558`	`1561`	`void CheckStl::readingEmptyStlContainerError(const Token *tok)`
`1559`	`1562`	`{`
`1560`		`- reportError(tok, Severity::style, "reademptycontainer", "Reading from empty STL container '" + (tok ? tok->str() : std::string("var")) + "'", CWE(0U), true);`
	`1563`	`+ reportError(tok, Severity::style, "reademptycontainer", "Reading from empty STL container '" + (tok ? tok->str() : std::string("var")) + "'", CWE398, true);`
`1561`	`1564`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ static const struct CWE CWE571(571U); // Expression is Always True`
`34`	`34`	`static const struct CWE CWE595(595U); // Comparison of Object References Instead of Object Contents`
`35`	`35`	`static const struct CWE CWE628(628U); // Function Call with Incorrectly Specified Arguments`
`36`	`36`	`static const struct CWE CWE665(665U); // Improper Initialization`
`37`		`-`
	`37`	`+static const struct CWE CWE758(758U); // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior`
`38`	`38`
`39`	`39`	`//---------------------------------------------------------------------------`
`40`	`40`	`// Writing string literal is UB`
`@@ -75,7 +75,7 @@ void CheckString::stringLiteralWriteError(const Token tok, const Token strValu`
`75`	`75`	`}`
`76`	`76`	`errmsg += " directly or indirectly is undefined behaviour.";`
`77`	`77`
`78`		`- reportError(callstack, Severity::error, "stringLiteralWrite", errmsg);`
	`78`	`+ reportError(callstack, Severity::error, "stringLiteralWrite", errmsg, CWE758, false);`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`//---------------------------------------------------------------------------`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@ namespace {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`static const struct CWE CWE563(563U); // Assignment to Variable without Use ('Unused Variable')`
	`33`	`+static const struct CWE CWE665(665U); // Improper Initialization`
`33`	`34`
`34`	`35`
`35`	`36`	`/**`
`@@ -1205,17 +1206,17 @@ void CheckUnusedVar::unusedVariableError(const Token *tok, const std::string &va`
`1205`	`1206`
`1206`	`1207`	`void CheckUnusedVar::allocatedButUnusedVariableError(const Token *tok, const std::string &varname)`
`1207`	`1208`	`{`
`1208`		`- reportError(tok, Severity::style, "unusedAllocatedMemory", "Variable '" + varname + "' is allocated memory that is never used.");`
	`1209`	`+ reportError(tok, Severity::style, "unusedAllocatedMemory", "Variable '" + varname + "' is allocated memory that is never used.", CWE563, false);`
`1209`	`1210`	`}`
`1210`	`1211`
`1211`	`1212`	`void CheckUnusedVar::unreadVariableError(const Token *tok, const std::string &varname)`
`1212`	`1213`	`{`
`1213`		`- reportError(tok, Severity::style, "unreadVariable", "Variable '" + varname + "' is assigned a value that is never used.");`
	`1214`	`+ reportError(tok, Severity::style, "unreadVariable", "Variable '" + varname + "' is assigned a value that is never used.", CWE563, false);`
`1214`	`1215`	`}`
`1215`	`1216`
`1216`	`1217`	`void CheckUnusedVar::unassignedVariableError(const Token *tok, const std::string &varname)`
`1217`	`1218`	`{`
`1218`		`- reportError(tok, Severity::style, "unassignedVariable", "Variable '" + varname + "' is not assigned a value.");`
	`1219`	`+ reportError(tok, Severity::style, "unassignedVariable", "Variable '" + varname + "' is not assigned a value.", CWE665, false);`
`1219`	`1220`	`}`
`1220`	`1221`
`1221`	`1222`	`//---------------------------------------------------------------------------`
`@@ -1302,7 +1303,7 @@ void CheckUnusedVar::checkStructMemberUsage()`
`1302`	`1303`	`void CheckUnusedVar::unusedStructMemberError(const Token *tok, const std::string &structname, const std::string &varname, bool isUnion)`
`1303`	`1304`	`{`
`1304`	`1305`	`const char* prefix = isUnion ? "union member '" : "struct member '";`
`1305`		`- reportError(tok, Severity::style, "unusedStructMember", std::string(prefix) + structname + "::" + varname + "' is never used.");`
	`1306`	`+ reportError(tok, Severity::style, "unusedStructMember", std::string(prefix) + structname + "::" + varname + "' is never used.", CWE563, false);`
`1306`	`1307`	`}`
`1307`	`1308`
`1308`	`1309`	`bool CheckUnusedVar::isRecordTypeWithoutSideEffects(const Type* type)`
Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,9 @@ namespace {`
`32`	`32`	`//---------------------------------------------------------------------------`
`33`	`33`
`34`	`34`	`// CWE ids used:`
`35`		`-static const struct CWE CWE664(664U);`
`36`		`-static const struct CWE CWE758(758U);`
	`35`	`+static const struct CWE CWE664(664U); // Improper Control of a Resource Through its Lifetime`
	`36`	`+static const struct CWE CWE688(688U); // Function Call With Incorrect Variable or Reference as Argument`
	`37`	`+static const struct CWE CWE758(758U); // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior`
`37`	`38`
`38`	`39`	`void CheckVaarg::va_start_argument()`
`39`	`40`	`{`
`@@ -70,7 +71,7 @@ void CheckVaarg::va_start_argument()`
`70`	`71`	`void CheckVaarg::wrongParameterTo_va_start_error(const Token *tok, const std::string& paramIsName, const std::string& paramShouldName)`
`71`	`72`	`{`
`72`	`73`	`reportError(tok, Severity::warning,`
`73`		`- "va_start_wrongParameter", "'" + paramIsName + "' given to va_start() is not last named argument of the function. Did you intend to pass '" + paramShouldName + "'?");`
	`74`	`+ "va_start_wrongParameter", "'" + paramIsName + "' given to va_start() is not last named argument of the function. Did you intend to pass '" + paramShouldName + "'?", CWE688, false);`
`74`	`75`	`}`
`75`	`76`
`76`	`77`	`void CheckVaarg::referenceAs_va_start_error(const Token *tok, const std::string& paramName)`