walkero
/
cppcheck
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Revert "Check for memset on nested structs (ticket #1288)" 

Turns out this fix is incomplete.

This reverts commit a084697410.
This commit is contained in:
Greg Hewgill 2011-03-10 20:19:31 +13:00
parent e94ebd829d
commit 1ec6a642dc
3 changed files with 9 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
lib/checkclass.cpp
View File

@ -695,14 +695,6 @@ void CheckClass::unusedPrivateFunctionError(const Token *tok, const std::string
void CheckClass::checkMemsetType(const Token *tok, const std::string &type)
{
// check for cached message for this type
std::map<std::string, std::string>::const_iterator msg = _memsetClassMessages.find(type);
if (msg != _memsetClassMessages.end())
{
memsetError(tok, type, msg->second);
return;
}
// Warn if type is a class or struct that contains any std::* variables
const std::string pattern2(std::string("struct|class ") + type + " :|{");
const Token *tstruct = Token::findmatch(_tokenizer->tokens(), pattern2.c_str());
@ -710,8 +702,7 @@ void CheckClass::checkMemsetType(const Token *tok, const std::string &type)
if (!tstruct)
return;
// typeKind is either 'struct' or 'class'
const std::string &typeKind = tstruct->str();
const std::string &typeName = tstruct->str();
if (tstruct->tokAt(2)->str() == ":")
{
@ -752,7 +743,7 @@ void CheckClass::checkMemsetType(const Token *tok, const std::string &type)
tstruct->str().find(":") != std::string::npos)
{
if (Token::Match(tstruct->next(), "std :: %type% %var% ;"))
memsetError(tok, type, tok->str(), "'std::" + tstruct->strAt(3) + "'", typeKind);
memsetError(tok, tok->str(), "'std::" + tstruct->strAt(3) + "'", typeName);
else if (Token::Match(tstruct->next(), "std :: %type% <"))
{
@ -780,12 +771,10 @@ void CheckClass::checkMemsetType(const Token *tok, const std::string &type)
// found error => report
if (Token::Match(tstruct, "> %var% ;"))
memsetError(tok, type, tok->str(), "'std::" + typestr + "'", typeKind);
memsetError(tok, tok->str(), "'std::" + typestr + "'", typeName);
}
else if (Token::simpleMatch(tstruct->next(), "virtual"))
memsetError(tok, type, tok->str(), "virtual method", typeKind);
else if (!Token::Match(tstruct->next(), "static|}"))
checkMemsetType(tok, tstruct->next()->str());
memsetError(tok, tok->str(), "virtual method", typeName);
}
}
}
@ -827,16 +816,9 @@ void CheckClass::noMemset()
}
}
void CheckClass::memsetError(const Token *tok, const std::string &type, const std::string &message)
void CheckClass::memsetError(const Token *tok, const std::string &memfunc, const std::string &classname, const std::string &type)
{
reportError(tok, Severity::error, "memsetClass", message);
// cache the message for this type so we don't have to look it up again
_memsetClassMessages[type] = message;
}
void CheckClass::memsetError(const Token *tok, const std::string &type, const std::string &memfunc, const std::string &classname, const std::string &typekind)
{
memsetError(tok, type, "Using '" + memfunc + "' on " + typekind + " that contains a " + classname);
reportError(tok, Severity::error, "memsetClass", "Using '" + memfunc + "' on " + type + " that contains a " + classname);
}
//---------------------------------------------------------------------------

10
lib/checkclass.h
View File

@ -84,6 +84,7 @@ public:
* Important: The checking doesn't work on simplified tokens list.
*/
void noMemset();
void checkMemsetType(const Token *tok, const std::string &type);
/** @brief 'operator=' should return something and it should not be const. */
void operatorEq();
@ -117,8 +118,7 @@ private:
void uninitVarError(const Token *tok, const std::string &classname, const std::string &varname);
void operatorEqVarError(const Token *tok, const std::string &classname, const std::string &varname);
void unusedPrivateFunctionError(const Token *tok, const std::string &classname, const std::string &funcname);
void memsetError(const Token *tok, const std::string &type, const std::string &message);
void memsetError(const Token *tok, const std::string &type, const std::string &memfunc, const std::string &classname, const std::string &typekind);
void memsetError(const Token *tok, const std::string &memfunc, const std::string &classname, const std::string &type);
void operatorEqReturnError(const Token *tok);
void virtualDestructorError(const Token *tok, const std::string &Base, const std::string &Derived);
void thisSubtractionError(const Token *tok);
@ -134,7 +134,7 @@ private:
c.uninitVarError(0, "classname", "varname");
c.operatorEqVarError(0, "classname", "");
c.unusedPrivateFunctionError(0, "classname", "funcname");
c.memsetError(0, "type", "memfunc", "classname", "class");
c.memsetError(0, "memfunc", "classname", "class");
c.operatorEqReturnError(0);
//c.virtualDestructorError(0, "Base", "Derived");
c.thisSubtractionError(0);
@ -228,10 +228,6 @@ private:
void initializeVarList(const Function &func, std::list<std::string> &callstack, const Scope *scope, std::vector<Usage> &usage);
bool canNotCopy(const Scope *scope) const;
// noMemset helpers
void checkMemsetType(const Token *tok, const std::string &type);
std::map<std::string, std::string> _memsetClassMessages;
};
/// @}
//---------------------------------------------------------------------------

12
test/testclass.cpp
View File

@ -2962,18 +2962,6 @@ private:
"}\n");
ASSERT_EQUALS("[test.cpp:9]: (error) Using 'memset' on class that contains a 'std::string'\n", errout.str());
checkNoMemset("struct Stringy {\n"
" std::string inner;\n"
"};\n"
"struct Foo {\n"
" Stringy s;\n"
"};\n"
"int main() {\n"
" Foo foo;\n"
" memset(&foo, 0, sizeof(Foo));\n"
"}\n");
ASSERT_EQUALS("[test.cpp:9]: (error) Using 'memset' on struct that contains a 'std::string'\n", errout.str());
checkNoMemset("class Fred\n"
"{\n"
" virtual ~Fred();\n"