: Check(myName(), tokenizer, settings, errorLogger),

symbolDatabase(NULL)

{

{

// Multiple calls => bail out

if (symbolDatabase)

return;

symbolDatabase = _tokenizer->getSymbolDatabase();

{

if (!_settings->_checkCodingStyle)

return;

createSymbolDatabase();

std::list<Scope>::const_iterator scope;

for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope)

{

// only check classes and structures

if (!scope->isClassOrStruct())

continue;

// There are no constructors.

if (scope->numConstructors == 0)

{

// If there is a private variable, there should be a constructor..

std::list<Variable>::const_iterator var;

for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var)

{

if (var->isPrivate() && !var->isClass() && !var->isStatic())

{

noConstructorError(scope->classDef, scope->className, scope->classDef->str() == "struct");

break;

}

}

}

std::list<Function>::const_iterator func;

std::vector<Usage> usage(scope->varlist.size());

for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)

{

if (!func->hasBody || !(func->type == Function::eConstructor ||

func->type == Function::eCopyConstructor ||

func->type == Function::eOperatorEqual))

continue;

// Mark all variables not used

clearAllVar(usage);

std::list<std::string> callstack;

initializeVarList(*func, callstack, &(*scope), usage);

// Check if any variables are uninitialized

std::list<Variable>::const_iterator var;

unsigned int count = 0;

for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var, ++count)

{

if (usage[count].assign || usage[count].init || var->isStatic())

continue;

if (var->isConst() && var->nameToken()->previous()->str() != "*")

continue;

// Check if this is a class constructor

if (var->isClass() && func->type == Function::eConstructor)

{

// Unknown type so assume it is initialized

if (!var->type())

continue;

// Known type that doesn't need initialization or

// known type that has member variables of an unknown type

else if (var->type()->needInitialization != Scope::True)

continue;

}

// Check if type can't be copied

if (var->type() && canNotCopy(var->type()))

continue;

// It's non-static and it's not initialized => error

if (func->type == Function::eOperatorEqual)

{

const Token *operStart = func->token->tokAt(1);

bool classNameUsed = false;

for (const Token *operTok = operStart; operTok != operStart->link(); operTok = operTok->next())

{

if (operTok->str() == scope->className)

{

classNameUsed = true;

break;

}

}

if (classNameUsed)

operatorEqVarError(func->token, scope->className, var->name());

}

else if (func->access != Private)

uninitVarError(func->token, scope->className, var->name());

}

}

}

{

std::list<Function>::const_iterator func;

bool privateAssign = false;

bool privateCopy = false;

for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)

{

if (func->type == Function::eCopyConstructor && func->access == Private)

privateCopy = true;

else if (func->type == Function::eOperatorEqual && func->access == Private)

privateAssign = true;

}

return privateAssign && privateCopy;

{

std::list<Variable>::const_iterator var;

unsigned int count = 0;

for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var, ++count)

{

if (var->name() == varname)

{

usage[count].assign = true;

return;

}

}

{

std::list<Variable>::const_iterator var;

unsigned int count = 0;

for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var, ++count)

{

if (var->name() == varname)

{

usage[count].init = true;

return;

}

}

{

for (size_t i = 0; i < usage.size(); ++i)

usage[i].assign = true;

{

for (size_t i = 0; i < usage.size(); ++i)

{

usage[i].assign = false;

usage[i].init = false;

}

{

// Iterate through each base class...

for (size_t i = 0; i < scope->derivedFrom.size(); ++i)

{

const Scope *derivedFrom = scope->derivedFrom[i].scope;

// Check if base class exists in database

if (derivedFrom)

{

std::list<Function>::const_iterator func;

for (func = derivedFrom->functionList.begin(); func != derivedFrom->functionList.end(); ++func)

{

if (func->tokenDef->str() == tok->str())

return true;

}

}

// Base class not found so assume it is in it.

else

return true;

}

return false;

{

bool Assign = false;

unsigned int indentlevel = 0;

const Token *ftok = func.token;

for (; ftok; ftok = ftok->next())

{

if (!ftok->next())

break;

// Class constructor.. initializing variables like this

// clKalle::clKalle() : var(value) { }

if (indentlevel == 0)

{

if (Assign && Token::Match(ftok, "%var% ("))

{

initVar(ftok->str(), scope, usage);

// assignment in the initializer..

// : var(value = x)

if (Token::Match(ftok->tokAt(2), "%var% ="))

assignVar(ftok->strAt(2), scope, usage);

}

Assign |= (ftok->str() == ":");

}

if (ftok->str() == "{")

{

++indentlevel;

Assign = false;

}

else if (ftok->str() == "}")

{

if (indentlevel <= 1)

break;

--indentlevel;

}

if (indentlevel < 1)

continue;

// Variable getting value from stream?

if (Token::Match(ftok, ">> %var%"))

{

assignVar(ftok->strAt(1), scope, usage);

}

// Before a new statement there is "[{};)=]"

if (! Token::Match(ftok, "[{};()=]"))

continue;

if (Token::simpleMatch(ftok, "( !"))

ftok = ftok->next();

// Using the operator= function to initialize all variables..

if (Token::Match(ftok->next(), "return| * this ="))

{

assignAllVar(usage);

break;

}

// Calling member variable function?

if (Token::Match(ftok->next(), "%var% . %var% ("))

{

std::list<Variable>::const_iterator var;

for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var)

{

if (var->varId() == ftok->next()->varId())

{

/** @todo false negative: we assume function changes variable state */

assignVar(ftok->next()->str(), scope, usage);

continue;

}

}

ftok = ftok->tokAt(2);

}

if (!Token::Match(ftok->next(), "%var%") &&

!Token::Match(ftok->next(), "this . %var%") &&

!Token::Match(ftok->next(), "* %var% =") &&

!Token::Match(ftok->next(), "( * this ) . %var%"))

continue;

// Goto the first token in this statement..

ftok = ftok->next();

// Skip "( * this )"

if (Token::simpleMatch(ftok, "( * this ) ."))

{

ftok = ftok->tokAt(5);

}

// Skip "this->"

if (Token::simpleMatch(ftok, "this ."))

ftok = ftok->tokAt(2);

// Skip "classname :: "

if (Token::Match(ftok, "%var% ::"))

ftok = ftok->tokAt(2);

// Clearing all variables..

if (Token::simpleMatch(ftok, "memset ( this ,"))

{

assignAllVar(usage);

return;

}

// Clearing array..

else if (Token::Match(ftok, "memset ( %var% ,"))

{

assignVar(ftok->strAt(2), scope, usage);

ftok = ftok->next()->link();

continue;

}

// Calling member function?

else if (Token::simpleMatch(ftok, "operator= (") &&

ftok->previous()->str() != "::")

{

// check if member function exists

std::list<Function>::const_iterator it;

for (it = scope->functionList.begin(); it != scope->functionList.end(); ++it)

{

if (ftok->str() == it->tokenDef->str() && it->type != Function::eConstructor)

break;

}

// member function found

if (it != scope->functionList.end())

{

// member function has implementation

if (it->hasBody)

{

// initialize variable use list using member function

callstack.push_back(ftok->str());

initializeVarList(*it, callstack, scope, usage);

callstack.pop_back();

}

// there is a called member function, but it has no implementation, so we assume it initializes everything

else

{

assignAllVar(usage);

}

}

// using default operator =, assume everything initialized

else

{

assignAllVar(usage);

}

}

else if (Token::Match(ftok, "%var% (") && ftok->str() != "if")

{

// Passing "this" => assume that everything is initialized

for (const Token *tok2 = ftok->next()->link(); tok2 && tok2 != ftok; tok2 = tok2->previous())

{

if (tok2->str() == "this")

{

assignAllVar(usage);

return;

}

}

// recursive call / calling overloaded function

// assume that all variables are initialized

if (std::find(callstack.begin(), callstack.end(), ftok->str()) != callstack.end())

{

assignAllVar(usage);

return;

}

// check if member function

std::list<Function>::const_iterator it;

for (it = scope->functionList.begin(); it != scope->functionList.end(); ++it)

{

if (ftok->str() == it->tokenDef->str() && it->type != Function::eConstructor)

break;

}

// member function found

if (it != scope->functionList.end())

{

// member function has implementation

if (it->hasBody)

{

// initialize variable use list using member function

callstack.push_back(ftok->str());

initializeVarList(*it, callstack, scope, usage);

callstack.pop_back();

}

// there is a called member function, but it has no implementation, so we assume it initializes everything

else

{

assignAllVar(usage);

}

}

// not member function

else

{

// could be a base class virtual function, so we assume it initializes everything

if (func.type != Function::eConstructor && isBaseClassFunc(ftok, scope))

{

/** @todo False Negative: we should look at the base class functions to see if they

assignAllVar(usage);

}

// has friends, so we assume it initializes everything

if (!scope->friendList.empty())

assignAllVar(usage);

// the function is external and it's neither friend nor inherited virtual function.

// assume all variables that are passed to it are initialized..

else

{

unsigned int indentlevel2 = 0;

for (const Token *tok = ftok->tokAt(2); tok; tok = tok->next())

{

if (tok->str() == "(")

++indentlevel2;

else if (tok->str() == ")")

{

if (indentlevel2 == 0)

break;

--indentlevel2;

}

if (tok->isName())

{

assignVar(tok->str(), scope, usage);

}

}

}

}

}

// Assignment of member variable?

else if (Token::Match(ftok, "%var% ="))

{

assignVar(ftok->str(), scope, usage);

}

// Assignment of array item of member variable?

else if (Token::Match(ftok, "%var% [ %any% ] ="))

{

assignVar(ftok->str(), scope, usage);

}

// Assignment of member of array item of member variable?

else if (Token::Match(ftok, "%var% [ %any% ] . %var% =") ||

Token::Match(ftok, "%var% [ %any% ] . %var% . %var% ="))

{

assignVar(ftok->str(), scope, usage);

}

// Assignment of array item of member variable?

else if (Token::Match(ftok, "%var% [ %any% ] [ %any% ] ="))

{

assignVar(ftok->str(), scope, usage);

}

// Assignment of array item of member variable?

else if (Token::Match(ftok, "* %var% ="))

{

assignVar(ftok->next()->str(), scope, usage);

}

// Assignment of struct member of member variable?

else if (Token::Match(ftok, "%var% . %any% ="))

{

assignVar(ftok->str(), scope, usage);

}

// The functions 'clear' and 'Clear' are supposed to initialize variable.

if (Token::Match(ftok, "%var% . clear|Clear ("))

{

assignVar(ftok->str(), scope, usage);

}

}

{

// For performance reasons the constructor might be intentionally missing. Therefore this is not a "warning"

reportError(tok, Severity::style, "noConstructor",

"The " + std::string(isStruct ? "struct" : "class") + " '" + classname +

"' does not have a constructor.\n"

"The " + std::string(isStruct ? "struct" : "class") + " '" + classname +

" 'does not have a constructor but it has attributes. "

"The attributes are not initialized which may cause bugs or undefined behavior.");

{

if (!_settings->_checkCodingStyle)

return;

// don't check code that contains templates. Templates that are

// "unused" are removed from the code. #2067

if (_tokenizer->codeWithTemplates())

return;

// dont check borland classes with properties..

if (Token::findmatch(_tokenizer->tokens(), "; __property ;"))

return;

createSymbolDatabase();

std::list<Scope>::const_iterator scope;

for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope)

{

// only check classes and structures

if (!scope->isClassOrStruct())

continue;

// don’t check derived classes

if (!scope->derivedFrom.empty())

continue;

// skip checking if there are friends

if (!scope->friendList.empty())

continue;

// Locate some class

const Token *tok1 = scope->classDef;

// check that the whole class implementation is seen

bool whole = true;

std::list<Function>::const_iterator func;

for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)

{

if (!func->hasBody)

{

// empty private copy constructors and assignment operators are OK

if ((func->type == Function::eCopyConstructor ||

func->type == Function::eOperatorEqual) &&

func->access == Private)

continue;

whole = false;

break;

}

}

if (!whole)

continue;

const std::string &classname = tok1->next()->str();

std::list<const Token *> FuncList;

/** @todo embedded class have access to private functions */

if (!scope->getNestedNonFunctions())

{

for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)

{

// Get private functions..

if (func->type == Function::eFunction && func->access == Private)

FuncList.push_back(func->tokenDef);

}

}

// Check that all private functions are used..

for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)

{

const Token *ftok = func->start;

if (ftok)

{

const Token *etok = ftok->link();

for (; ftok != etok; ftok = ftok->next())

{

if (Token::Match(ftok, "%var% ("))

{

// Remove function from FuncList

std::list<const Token *>::iterator it = FuncList.begin();

while (it != FuncList.end())

{

if (ftok->str() == (*it)->str())

FuncList.erase(it++);

else

++it;

}

}

}

}

}

while (!FuncList.empty())

{

// Final check; check if the function pointer is used somewhere..

const std::string _pattern("return|(|)|,|= &|" + FuncList.front()->str());

// or if the function address is used somewhere...

// eg. sigc::mem_fun(this, &className::classFunction)

const std::string _pattern2("& " + classname + " :: " + FuncList.front()->str());

const std::string methodAsArgument("(|, " + classname + " :: " + FuncList.front()->str() + " ,|)");

if (!Token::findmatch(_tokenizer->tokens(), _pattern.c_str()) &&

!Token::findmatch(_tokenizer->tokens(), _pattern2.c_str()) &&

!Token::findmatch(_tokenizer->tokens(), methodAsArgument.c_str())

)

{

unusedPrivateFunctionError(FuncList.front(), classname, FuncList.front()->str());

}

FuncList.pop_front();

}

}

{

createSymbolDatabase();

std::list<Scope>::const_iterator scope;

for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope)

{

std::list<Function>::const_iterator func;

for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)

{

// only check functions with bodies

if (!func->hasBody)

continue;

// Locate all 'memset' tokens..

const Token *end = func->start->link();

for (const Token *tok = func->start; tok && tok != end; tok = tok->next())

{

if (!Token::Match(tok, "memset|memcpy|memmove"))

continue;

const Token *typeTok = 0;

if (Token::Match(tok, "memset ( %var% , %num% , sizeof ( %type% ) )"))

typeTok = tok->tokAt(8);

else if (Token::Match(tok, "memset ( & %var% , %num% , sizeof ( %type% ) )"))

typeTok = tok->tokAt(9);

else if (Token::Match(tok, "memset ( & %var% , %num% , sizeof ( %type% :: %type% ) )"))

typeTok = tok->tokAt(11);

else if (Token::Match(tok, "memset ( %var% , %num% , sizeof ( struct %type% ) )"))

typeTok = tok->tokAt(9);

else if (Token::Match(tok, "memset ( & %var% , %num% , sizeof ( struct %type% ) )"))

typeTok = tok->tokAt(10);

else if (Token::Match(tok, "%type% ( %var% , %var% , sizeof ( %type% ) )"))

typeTok = tok->tokAt(8);

else if (Token::Match(tok, "memset ( & %var% , %num% , sizeof ( %var% ) )"))

{

unsigned int varid = tok->tokAt(3)->varId();

const Variable *var = symbolDatabase->getVariableFromVarId(varid);

if (var && (var->typeStartToken() == var->typeEndToken() ||

Token::Match(var->typeStartToken(), "%type% :: %type%")))

typeTok = var->typeEndToken();

}

// No type defined => The tokens didn't match

if (!typeTok)

continue;

const Scope *type = symbolDatabase->findVariableType(&(*scope), typeTok);

if (type)

checkMemsetType(&(*scope), tok, type);

}

}

}

{

// recursively check all parent classes

for (size_t i = 0; i < type->derivedFrom.size(); i++)

{

if (type->derivedFrom[i].scope)

checkMemsetType(start, tok, type->derivedFrom[i].scope);

}

// Warn if type is a class that contains any virtual functions

std::list<Function>::const_iterator func;

for (func = type->functionList.begin(); func != type->functionList.end(); ++func)

{

if (func->isVirtual)

memsetError(tok, tok->str(), "virtual method", type->classDef->str());

}

// Warn if type is a class or struct that contains any std::* variables

std::list<Variable>::const_iterator var;

for (var = type->varlist.begin(); var != type->varlist.end(); ++var)

{

// don't warn if variable static or const

if (!var->isStatic() && !var->isConst())

{

const Token *tok1 = var->typeStartToken();

// check for std:: type that is not a pointer or reference

if (Token::simpleMatch(tok1, "std ::") && !Token::Match(var->nameToken()->previous(), "*|&"))

memsetError(tok, tok->str(), "'std::" + tok1->strAt(2) + "'", type->classDef->str());

// check for known type that is not a pointer or reference

else if (var->type() && !Token::Match(var->nameToken()->previous(), "*|&"))

checkMemsetType(start, tok, var->type());

}

}

{

if (!_settings->_checkCodingStyle)

return;

createSymbolDatabase();

std::list<Scope>::const_iterator scope;

for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope)

{

if (!scope->isClassOrStruct())

continue;

std::list<Function>::const_iterator func;

for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)

{

if (func->type == Function::eOperatorEqual && func->access != Private)

{

// use definition for check so we don't have to deal with qualification

if (!(Token::Match(func->tokenDef->tokAt(-3), ";|}|{|public:|protected:|private: %type% &") &&

func->tokenDef->strAt(-2) == scope->className))

operatorEqReturnError(func->tokenDef->tokAt(-1), scope->className);

}

}

}

{

if (!_settings->_checkCodingStyle)

return;

createSymbolDatabase();

std::list<Scope>::const_iterator scope;

for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope)

{

// only check classes and structures

if (scope->isClassOrStruct())

{

std::list<Function>::const_iterator func;

for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)

{

if (func->type == Function::eOperatorEqual && func->hasBody)

{

// make sure return signature is correct

if (Token::Match(func->tokenDef->tokAt(-3), ";|}|{|public:|protected:|private: %type% &") &&

func->tokenDef->strAt(-2) == scope->className)

{

// find the ')'

const Token *tok = func->token->next()->link();

checkReturnPtrThis(&(*scope), &(*func), tok->tokAt(2), tok->next()->link());

}

}

}

}

}

{

bool foundReturn = false;

for (; tok && tok != last; tok = tok->next())

{

// check for return of reference to this

if (tok->str() == "return")

{

foundReturn = true;

std::string cast("( " + scope->className + " & )");

if (Token::Match(tok->next(), cast.c_str()))

tok = tok->tokAt(4);

// check if a function is called

if (Token::Match(tok->tokAt(1), "%any% (") &&

tok->tokAt(2)->link()->next()->str() == ";")

{

std::list<Function>::const_iterator it;

// check if it is a member function

for (it = scope->functionList.begin(); it != scope->functionList.end(); ++it)

{

// check for a regular function with the same name and a body

if (it->type == Function::eFunction && it->hasBody &&

it->token->str() == tok->next()->str())

{

// check for the proper return type

if (it->tokenDef->previous()->str() == "&" &&

it->tokenDef->strAt(-2) == scope->className)

{

// make sure it's not a const function

if (it->arg->link()->next()->str() != "const")

{

/** @todo make sure argument types match */

// make sure it's not the same function

if (&*it != func)

checkReturnPtrThis(scope, &*it, it->arg->link()->next(), it->arg->link()->next()->link());

// just bail for now

else

return;

}

}

}

}

}

// check if *this is returned

else if (!(Token::Match(tok->tokAt(1), "(| * this ;|=") ||

Token::Match(tok->tokAt(1), "(| * this +=") ||

Token::simpleMatch(tok->tokAt(1), "operator= (") ||

Token::simpleMatch(tok->tokAt(1), "this . operator= (") ||

(Token::Match(tok->tokAt(1), "%type% :: operator= (") &&

tok->next()->str() == scope->className)))

operatorEqRetRefThisError(func->token);

}

}

if (!foundReturn)

operatorEqRetRefThisError(func->token);

{

if (!_settings->_checkCodingStyle)

return;

createSymbolDatabase();

std::list<Scope>::const_iterator scope;

for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope)

{

if (!scope->isClassOrStruct())

continue;

std::list<Function>::const_iterator func;

// skip classes with multiple inheritance

if (scope->derivedFrom.size() > 1)

continue;

for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)

{

if (func->type == Function::eOperatorEqual && func->hasBody)

{

// make sure return signature is correct

if (Token::Match(func->tokenDef->tokAt(-3), ";|}|{|public:|protected:|private: %type% &") &&

func->tokenDef->strAt(-2) == scope->className)

{

// find the parameter name

const Token *rhs = func->argumentList.begin()->nameToken();

if (!hasAssignSelf(&(*func), rhs))

{

if (hasDeallocation(&(*func)))

operatorEqToSelfError(func->token);

}

}

}

}

}

{

// This function is called when no simple check was found for assignment

// to self. We are currently looking for a specific sequence of:

// deallocate member ; ... member = allocate

// This check is far from ideal because it can cause false negatives.