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

symbolDatabase(tokenizer?tokenizer->getSymbolDatabase():nullptr)

{

{

const bool printStyle = _settings->isEnabled("style");

const bool printWarnings = _settings->isEnabled("warning");

if (!printStyle && !printWarnings)

return;

const bool printInconclusive = _settings->inconclusive;

const std::size_t classes = symbolDatabase->classAndStructScopes.size();

for (std::size_t i = 0; i < classes; ++i) {

const Scope * scope = symbolDatabase->classAndStructScopes[i];

// There are no constructors.

if (scope->numConstructors == 0 && printStyle) {

// 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->isStatic() && !Token::Match(var->nameToken(), "%varid% ; %varid% =", var->declarationId()) &&

(!var->isClass() || (var->type() && var->type()->needInitialization == Type::True))) {

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

break;

}

}

}

if (!printWarnings)

continue;

// #3196 => bailout if there are nested unions

// TODO: handle union variables better

{

bool bailout = false;

for (std::list<Scope *>::const_iterator it = scope->nestedList.begin(); it != scope->nestedList.end(); ++it) {

const Scope * const nestedScope = *it;

if (nestedScope->type == Scope::eUnion) {

bailout = true;

break;

}

}

if (bailout)

continue;

}

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->isConstructor() ||

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

continue;

// Mark all variables not used

clearAllVar(usage);

std::list<const Function *> 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) {

// check for C++11 initializer

if (var->hasDefault()) {

usage[count].init = true;

continue;

}

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

continue;

if (var->isConst() && func->isOperator()) // We can't set const members in assignment operator

continue;

// Check if this is a class constructor

if (!var->isPointer() && !var->isPointerArray() && 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 != Type::True)

continue;

}

// Check if type can't be copied

if (!var->isPointer() && !var->isPointerArray() && var->typeScope()) {

if (func->type == Function::eMoveConstructor) {

if (canNotMove(var->typeScope()))

continue;

} else {

if (canNotCopy(var->typeScope()))

continue;

}

}

bool inconclusive = false;

// Don't warn about unknown types in copy constructors since we

// don't know if they can be copied or not..

if (!var->isPointer() &&

!(var->type() && var->type()->needInitialization != Type::True) &&

(func->type == Function::eCopyConstructor || func->type == Function::eOperatorEqual)) {

if (!var->typeStartToken()->isStandardType()) {

if (printInconclusive)

inconclusive = true;

else

continue;

}

}

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

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

const Token *operStart = func->arg;

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(), inconclusive);

} else if (func->access != Private) {

const Scope *varType = var->typeScope();

if (!varType || varType->type != Scope::eUnion) {

if (func->type == Function::eConstructor &&

func->nestedIn && (func->nestedIn->numConstructors - func->nestedIn->numCopyOrMoveConstructors) > 1 &&

func->argCount() == 0 && func->functionScope &&

func->arg && func->arg->link()->next() == func->functionScope->classStart &&

func->functionScope->classStart->link() == func->functionScope->classStart->next()) {

// don't warn about user defined default constructor when there are other constructors

if (printInconclusive)

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

} else

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

}

}

}

}

}

{

if (!_settings->isEnabled("style"))

return;

const std::size_t classes = symbolDatabase->classAndStructScopes.size();

for (std::size_t i = 0; i < classes; ++i) {

const Scope * scope = symbolDatabase->classAndStructScopes[i];

// Do not perform check, if the class/struct has not any constructors

if (scope->numConstructors == 0)

continue;

// Is class abstract? Maybe this test is over-simplification, but it will suffice for simple cases,

// and it will avoid false positives.

bool isAbstractClass = false;

for (std::list<Function>::const_iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {

if (func->isPure()) {

isAbstractClass = true;

break;

}

}

// Abstract classes can't be instantiated. But if there is C++11

// "misuse" by derived classes then these constructors must be explicit.

if (isAbstractClass && _settings->standards.cpp != Standards::CPP11)

continue;

for (std::list<Function>::const_iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {

// We are looking for constructors, which are meeting following criteria:

// 1) Constructor is declared with a single parameter

// 2) Constructor is not declared as explicit

// 3) It is not a copy/move constructor of non-abstract class

// 4) Constructor is not marked as delete (programmer can mark the default constructor as deleted, which is ok)

if (!func->isConstructor() || func->isDelete() || (!func->hasBody() && func->access == Private))

continue;

if (!func->isExplicit() &&

func->argCount() == 1 &&

func->type != Function::eCopyConstructor &&

func->type != Function::eMoveConstructor) {

noExplicitConstructorError(func->tokenDef, scope->className, scope->type == Scope::eStruct);

}

}

}

{

if (!_settings->isEnabled("style"))

return;

const std::size_t classes = symbolDatabase->classAndStructScopes.size();

for (std::size_t i = 0; i < classes; ++i) {

const Scope * scope = symbolDatabase->classAndStructScopes[i];

std::map<unsigned int, const Token*> allocatedVars;

for (std::list<Function>::const_iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {

if (func->type == Function::eConstructor && func->functionScope) {

const Token* tok = func->functionScope->classDef->linkAt(1);

for (const Token* const end = func->functionScope->classStart; tok != end; tok = tok->next()) {

if (Token::Match(tok, "%var% ( new|malloc|g_malloc|g_try_malloc|realloc|g_realloc|g_try_realloc")) {

const Variable* var = tok->variable();

if (var && var->isPointer() && var->scope() == scope)

allocatedVars[tok->varId()] = tok;

}

}

for (const Token* const end = func->functionScope->classEnd; tok != end; tok = tok->next()) {

if (Token::Match(tok, "%var% = new|malloc|g_malloc|g_try_malloc|realloc|g_realloc|g_try_realloc")) {

const Variable* var = tok->variable();

if (var && var->isPointer() && var->scope() == scope && !var->isStatic())

allocatedVars[tok->varId()] = tok;

}

}

}

}

std::set<const Token*> copiedVars;

const Token* copyCtor = 0;

for (std::list<Function>::const_iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {

if (func->type == Function::eCopyConstructor) {

copyCtor = func->tokenDef;

if (func->functionScope) {

const Token* tok = func->tokenDef->linkAt(1)->next();

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

tok=tok->next();

while (Token::Match(tok, "%name% (")) {

if (allocatedVars.find(tok->varId()) != allocatedVars.end()) {

if (tok->varId() && Token::Match(tok->tokAt(2), "%name% . %name% )"))

copiedVars.insert(tok);

else if (!Token::Match(tok->tokAt(2), "%any% )"))

allocatedVars.erase(tok->varId()); // Assume memory is allocated

}

tok = tok->linkAt(1)->tokAt(2);

}

}

for (tok=func->functionScope->classStart; tok!=func->functionScope->classEnd; tok=tok->next()) {

if (Token::Match(tok, "%var% = new|malloc|g_malloc|g_try_malloc|realloc|g_realloc|g_try_realloc")) {

allocatedVars.erase(tok->varId());

} else if (Token::Match(tok, "%var% = %name% . %name% ;") && allocatedVars.find(tok->varId()) != allocatedVars.end()) {

copiedVars.insert(tok);

}

}

} else // non-copyable or implementation not seen

allocatedVars.clear();

break;

}

}

if (!copyCtor) {

if (!allocatedVars.empty() && scope->definedType->derivedFrom.empty()) // TODO: Check if base class is non-copyable

noCopyConstructorError(scope->classDef, scope->className, scope->type == Scope::eStruct);

} else {

if (!copiedVars.empty()) {

for (std::set<const Token*>::const_iterator it = copiedVars.begin(); it != copiedVars.end(); ++it) {

copyConstructorShallowCopyError(*it, (*it)->str());

}

}

// throw error if count mismatch

/* FIXME: This doesn't work. See #4154

}

}

{

// The constructor might be intentionally missing. Therefore this is not a "warning"

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

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

"' does not have a copy constructor which is recommended since the class contains a pointer to allocated memory.");

{

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

bool constructor = false;

bool publicAssign = false;

bool publicCopy = false;

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

if (func->isConstructor())

constructor = true;

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

func->access == Public)

publicCopy = true;

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

publicAssign = true;

}

return constructor && !(publicAssign || publicCopy);

{

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

bool constructor = false;

bool publicAssign = false;

bool publicCopy = false;

bool publicMove = false;

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

if (func->isConstructor())

constructor = true;

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

func->access == Public)

publicCopy = true;

else if ((func->type == Function::eMoveConstructor) &&

func->access == Public)

publicMove = true;

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

publicAssign = true;

}

return constructor && !(publicAssign || publicCopy || publicMove);

{

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

unsigned int count = 0;

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

if (var->declarationId() == varid) {

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->declarationId() == varid) {

usage[count].init = true;

return;

}

}

{

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

usage[i].assign = true;

{

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

usage[i].assign = false;

usage[i].init = false;

}

{

// Iterate through each base class...

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

const Type *derivedFrom = scope->definedType->derivedFrom[i].type;

// Check if base class exists in database

if (derivedFrom && derivedFrom->classScope) {

const std::list<Function>& functionList = derivedFrom->classScope->functionList;

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

for (func = functionList.begin(); func != 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;

{

if (!func.functionScope)

throw InternalError(0, "Internal Error: Invalid syntax"); // #5702

bool initList = func.isConstructor();

const Token *ftok = func.arg->link()->next();

int level = 0;

for (; ftok && ftok != func.functionScope->classEnd; ftok = ftok->next()) {

// Class constructor.. initializing variables like this

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

if (initList) {

if (level == 0 && Token::Match(ftok, "%name% {|(") && Token::Match(ftok->linkAt(1), "}|) ,|{")) {

if (ftok->str() != func.name()) {

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

} else { // c++11 delegate constructor

const Function *member = ftok->function();

// member function found

if (member) {

// recursive call

// assume that all variables are initialized

if (std::find(callstack.begin(), callstack.end(), member) != callstack.end()) {

/** @todo false negative: just bail */

assignAllVar(usage);

return;

}

// member function has implementation

if (member->hasBody()) {

// initialize variable use list using member function

callstack.push_back(member);

initializeVarList(*member, 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);

}

}

}

} else if (level != 0 && Token::Match(ftok, "%name% =")) // assignment in the initializer: var(value = x)

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

// Level handling

if (ftok->link() && Token::Match(ftok, "(|<"))

level++;

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

if (level != 0 ||

(Token::Match(ftok->previous(), "%name%|>") && Token::Match(ftok->link(), "} ,|{")))

level++;

else

initList = false;

} else if (ftok->link() && Token::Match(ftok, ")|>|}"))

level--;

}

if (initList)

continue;

// Variable getting value from stream?

if (Token::Match(ftok, ">> %name%")) {

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

}

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

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;

}

// Using swap to assign all variables..

if (func.type == Function::eOperatorEqual && Token::Match(ftok, "[;{}] %name% (") && Token::Match(ftok->linkAt(2), ") . %name% ( *| this ) ;")) {

assignAllVar(usage);

break;

}

// Calling member variable function?

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

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

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

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

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

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

break;

}

}

ftok = ftok->tokAt(2);

}

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

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

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

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

continue;

// Goto the first token in this statement..

ftok = ftok->next();

// skip "return"

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

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, ":: %name%"))

ftok = ftok->next();

while (Token::Match(ftok, "%name% ::"))

ftok = ftok->tokAt(2);

// Clearing all variables..

if (Token::Match(ftok, "::| memset ( this ,")) {

assignAllVar(usage);

return;

}

// Clearing array..

else if (Token::Match(ftok, "::| memset ( %name% ,")) {

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

ftok = ftok->next();

assignVar(ftok->tokAt(2)->varId(), scope, usage);

ftok = ftok->linkAt(1);

continue;

}

// Calling member function?

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

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

if (ftok->function() && ftok->function()->nestedIn == scope) {

const Function *member = ftok->function();

// recursive call

// assume that all variables are initialized

if (std::find(callstack.begin(), callstack.end(), member) != callstack.end()) {

/** @todo false negative: just bail */

assignAllVar(usage);

return;

}

// member function has implementation

if (member->hasBody()) {

// initialize variable use list using member function

callstack.push_back(member);

initializeVarList(*member, 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, "::| %name% (") && ftok->str() != "if") {

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

ftok = ftok->next();

// 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;

}

}

// check if member function

if (ftok->function() && ftok->function()->nestedIn == scope &&

!ftok->function()->isConstructor()) {

const Function *member = ftok->function();

// recursive call

// assume that all variables are initialized

if (std::find(callstack.begin(), callstack.end(), member) != callstack.end()) {

assignAllVar(usage);

return;

}

// member function has implementation

if (member->hasBody()) {

// initialize variable use list using member function

callstack.push_back(member);

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

callstack.pop_back();

// Assume that variables that are passed to it are initialized..

for (const Token *tok2 = ftok; tok2; tok2 = tok2->next()) {

if (Token::Match(tok2, "[;{}]"))

break;

if (Token::Match(tok2, "[(,] &| %name% [,)]")) {

tok2 = tok2->next();

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

tok2 = tok2->next();

assignVar(tok2->varId(), scope, usage);

}

}

}

// 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.isConstructor() && 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->definedType->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 {

for (const Token *tok = ftok->tokAt(2); tok && tok != ftok->next()->link(); tok = tok->next()) {

if (tok->isName()) {

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

}

}

}

}

}

// Assignment of member variable?

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

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

bool bailout = ftok->variable() && ftok->variable()->isReference();

const Token* tok2 = ftok->tokAt(2);

if (tok2->str() == "&") {

tok2 = tok2->next();

bailout = true;

}

if (tok2->variable() && (bailout || tok2->variable()->isArray()) && tok2->strAt(1) != "[")

assignVar(tok2->varId(), scope, usage);

}

// Assignment of array item of member variable?

else if (Token::Match(ftok, "%name% [|.")) {

const Token *tok2 = ftok;

while (tok2) {

if (tok2->strAt(1) == "[")

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

else if (Token::Match(tok2->next(), ". %name%"))

tok2 = tok2->tokAt(2);

else

break;

}

if (tok2 && tok2->strAt(1) == "=")

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

}

// Assignment of array item of member variable?

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

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

} else if (Token::Match(ftok, "* this . %name% =")) {

assignVar(ftok->tokAt(3)->varId(), scope, usage);

}

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

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

assignVar(ftok->varId(), 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 although it has private member variables. "

"Member variables of builtin types are left uninitialized when the class is "

"instantiated. That may cause bugs or undefined behavior.");

{

const std::string message(std::string(isStruct ? "Struct" : "Class") + " '" + classname + "' has a constructor with 1 argument that is not explicit.");

const std::string verbose(message + " Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.");

reportError(tok, Severity::style, "noExplicitConstructor", message + "\n" + verbose);

{

if (!_settings->isEnabled("performance"))

return;

const std::size_t functions = symbolDatabase->functionScopes.size();

for (std::size_t i = 0; i < functions; ++i) {

const Scope * scope = symbolDatabase->functionScopes[i];

// Check every constructor

if (!scope->function || (!scope->function->isConstructor()))

continue;

const Scope* owner = scope->functionOf;

for (const Token* tok = scope->classStart; tok != scope->classEnd; tok = tok->next()) {

if (Token::Match(tok, "%name% (")) // Assignments might depend on this function call or if/for/while/switch statement from now on.

break;

if (Token::Match(tok, "try|do {"))

break;

if (Token::Match(tok, "%var% =") && tok->strAt(-1) != "*") {

const Variable* var = tok->variable();

if (var && var->scope() == owner && !var->isStatic()) {

if (var->isPointer() || var->isReference() || (!var->type() && !var->isStlStringType() && !(Token::Match(var->typeStartToken(), "std :: %type% <") && !Token::simpleMatch(var->typeStartToken()->linkAt(3), "> ::"))))

continue;

bool allowed = true;

for (const Token* tok2 = tok->tokAt(2); tok2 && tok2->str() != ";"; tok2 = tok2->next()) {

const Variable* var2 = tok2->variable();

if (var2) {

if (var2->scope() == owner && tok2->strAt(-1)!=".") { // Is there a dependency between two member variables?

allowed = false;

break;

} else if (var2->isArray() && var2->isLocal()) { // Can't initialize with a local array

allowed = false;

break;

}

} else if (tok2->str() == "this") { // 'this' instance is not completely constructed in initialization list

allowed = false;

break;

} else if (Token::Match(tok2, "%name% (") && tok2->strAt(-1) != "." && isMemberFunc(owner, tok2)) { // Member function called?

allowed = false;

break;

}

}

if (!allowed)

continue;

suggestInitializationList(tok, tok->str());

}

}

}

}

{

reportError(tok, Severity::performance, "useInitializationList", "Variable '" + varname + "' is assigned in constructor body. Consider performing initialization in initialization list.\n"

"When an object of a class is created, the constructors of all member variables are called consecutively "

"in the order the variables are declared, even if you don't explicitly write them to the initialization list. You "

"could avoid assigning '" + varname + "' a value by passing the value to the constructor in the initialization list.");

{

if (!scope)

return true; // Assume it is used, if scope is not seen

for (std::list<Function>::const_iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {

if (func->functionScope) {

if (Token::Match(func->tokenDef, "%name% (")) {

for (const Token *ftok = func->tokenDef->tokAt(2); ftok && ftok->str() != ")"; ftok = ftok->next()) {

if (Token::Match(ftok, "= %name% [(,)]") && ftok->strAt(1) == name)

return true;

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

ftok = ftok->link();

}

}

for (const Token *ftok = func->functionScope->classDef->linkAt(1); ftok != func->functionScope->classEnd; ftok = ftok->next()) {

if (ftok->str() == name) // Function used. TODO: Handle overloads

return true;

}

} else if ((func->type != Function::eCopyConstructor &&

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

func->access != Private) // Assume it is used, if a function implementation isn't seen, but empty private copy constructors and assignment operators are OK

return true;

}

for (std::list<Scope*>::const_iterator i = scope->nestedList.begin(); i != scope->nestedList.end(); ++i) {

if ((*i)->isClassOrStruct())

if (checkFunctionUsage(name, *i)) // Check nested classes, which can access private functions of their base

return true;

}

for (std::list<Variable>::const_iterator i = scope->varlist.begin(); i != scope->varlist.end(); ++i) {

if (i->isStatic()) {

const Token* tok = Token::findmatch(scope->classEnd, "%varid% =|(|{", i->declarationId());

if (tok)

tok = tok->tokAt(2);

while (tok && tok->str() != ";") {

if (tok->str() == name && (tok->strAt(-1) == "." || tok->strAt(-2) == scope->className))

return true;

tok = tok->next();

}

}

}

return false; // Unused in this scope

{

if (!_settings->isEnabled("style"))

return;

const std::size_t classes = symbolDatabase->classAndStructScopes.size();

for (std::size_t i = 0; i < classes; ++i) {

const Scope * scope = symbolDatabase->classAndStructScopes[i];

// do not check borland classes with properties..

if (Token::findsimplematch(scope->classStart, "; __property ;", scope->classEnd))

continue;

std::list<const Function*> privateFuncs;

for (std::list<Function>::const_iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {

// Get private functions..

if (func->type == Function::eFunction && func->access == Private && !func->isOperator()) // TODO: There are smarter ways to check private operator usage

privateFuncs.push_back(&*func);

}

// Bailout for overridden virtual functions of base classes

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

// Check virtual functions

for (std::list<const Function*>::iterator it = privateFuncs.begin(); it != privateFuncs.end();) {

if ((*it)->isImplicitlyVirtual(true)) // Give true as default value to be returned if we don't see all base classes

privateFuncs.erase(it++);

else

++it;

}

}

while (!privateFuncs.empty()) {

const std::string& funcName = privateFuncs.front()->tokenDef->str();

// Check that all private functions are used

bool used = checkFunctionUsage(funcName, scope); // Usage in this class

// Check in friend classes

const std::list<Type::FriendInfo>& friendList = scope->definedType->friendList;

for (std::list<Type::FriendInfo>::const_iterator it = friendList.begin(); !used && it != friendList.end(); ++it) {

if (it->type)

used = checkFunctionUsage(funcName, it->type->classScope);

else

used = true; // Assume, it is used if we do not see friend class

}

if (!used)

unusedPrivateFunctionError(privateFuncs.front()->tokenDef, scope->className, funcName);

privateFuncs.pop_front();

}

}

{

const bool printWarnings = _settings->isEnabled("warning");

const std::size_t functions = symbolDatabase->functionScopes.size();

for (std::size_t i = 0; i < functions; ++i) {

const Scope * scope = symbolDatabase->functionScopes[i];

for (const Token *tok = scope->classStart; tok && tok != scope->classEnd; tok = tok->next()) {

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

const Token* arg1 = tok->tokAt(2);

const Token* arg3 = arg1->nextArgument();