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

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

{

{

const bool printStyle = mSettings->isEnabled(Settings::STYLE);

const bool printWarnings = mSettings->isEnabled(Settings::WARNING);

if (!printStyle && !printWarnings)

return;

const bool printInconclusive = mSettings->inconclusive;

for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {

bool usedInUnion = false;

for (const Scope &unionScope : mSymbolDatabase->scopeList) {

if (unionScope.type != Scope::eUnion)

continue;

for (const Variable &var : unionScope.varlist) {

if (var.type() && var.type()->classScope == scope) {

usedInUnion = true;

break;

}

}

}

// There are no constructors.

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

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

for (const Variable &var : scope->varlist) {

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 (const Scope * const nestedScope : scope->nestedList) {

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

bailout = true;

break;

}

}

if (bailout)

continue;

}

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

for (const Function &func : scope->functionList) {

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

int count = -1;

for (const Variable &var : scope->varlist) {

++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.valueType()->pointer == 0 && var.type() && var.type()->needInitialization == Type::False && var.type()->derivedFrom.empty())

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 ((func.type == Function::eCopyConstructor || func.type == Function::eMoveConstructor || func.type == Function::eOperatorEqual) && !isVariableCopyNeeded(var))

inconclusive = true;

if (!printInconclusive && inconclusive)

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 || mSettings->standards.cpp >= Standards::CPP11) {

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->bodyStart &&

func.functionScope->bodyStart->link() == func.functionScope->bodyStart->next()) {

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

if (printInconclusive)

uninitVarError(func.token, func.access == Private, scope->className, var.name(), true);

} else

uninitVarError(func.token, func.access == Private, scope->className, var.name(), inconclusive);

}

}

}

}

}

{

if (!mSettings->isEnabled(Settings::STYLE))

return;

for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {

// 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 (const Function &func : scope->functionList) {

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 && mSettings->standards.cpp != Standards::CPP11)

continue;

for (const Function &func : scope->functionList) {

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

}

}

}

{

bool u = false;

// check if there is base class that is not copyable

for (const Type::BaseInfo &baseInfo : scope->definedType->derivedFrom) {

if (!baseInfo.type || !baseInfo.type->classScope) {

u = true;

continue;

}

if (isNonCopyable(baseInfo.type->classScope, &u))

return true;

for (const Function &func : baseInfo.type->classScope->functionList) {

if (func.type != Function::eCopyConstructor)

continue;

if (func.access == Private || func.isDelete())

return true;

}

}

*unknown = u;

return false;

{

if (!mSettings->isEnabled(Settings::STYLE))

return;

for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {

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

for (const Function &func : scope->functionList) {

if (func.type != Function::eConstructor || !func.functionScope)

continue;

const Token* tok = func.token->linkAt(1);

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

if (Token::Match(tok, "%var% ( new") ||

(Token::Match(tok, "%var% ( %name% (") && mSettings->library.alloc(tok->tokAt(2)))) {

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

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

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

}

}

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

if (Token::Match(tok, "%var% = new") ||

(Token::Match(tok, "%var% = %name% (") && mSettings->library.alloc(tok->tokAt(2)))) {

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

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

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

}

}

}

if (!allocatedVars.empty()) {

const Function *funcCopyCtor = nullptr;

const Function *funcOperatorEq = nullptr;

const Function *funcDestructor = nullptr;

for (const Function &func : scope->functionList) {

if (func.type == Function::eCopyConstructor)

funcCopyCtor = &func;

else if (func.type == Function::eOperatorEqual)

funcOperatorEq = &func;

else if (func.type == Function::eDestructor)

funcDestructor = &func;

}

if (!funcCopyCtor || funcCopyCtor->isDefault()) {

bool unknown = false;

if (!isNonCopyable(scope, &unknown) && !unknown)

noCopyConstructorError(scope, funcCopyCtor, allocatedVars.begin()->second, unknown);

}

if (!funcOperatorEq || funcOperatorEq->isDefault()) {

bool unknown = false;

if (!isNonCopyable(scope, &unknown) && !unknown)

noOperatorEqError(scope, funcOperatorEq, allocatedVars.begin()->second, unknown);

}

if (!funcDestructor || funcDestructor->isDefault()) {

const Token * mustDealloc = nullptr;

for (std::map<unsigned int, const Token*>::const_iterator it = allocatedVars.begin(); it != allocatedVars.end(); ++it) {

if (!Token::Match(it->second, "%var% [(=] new %type%")) {

mustDealloc = it->second;

break;

}

if (it->second->valueType() && it->second->valueType()->isIntegral()) {

mustDealloc = it->second;

break;

}

const Variable *var = it->second->variable();

if (var && var->typeScope() && var->typeScope()->functionList.empty() && var->type()->derivedFrom.empty())

mustDealloc = it->second;

}

if (mustDealloc)

noDestructorError(scope, funcDestructor, mustDealloc);

}

}

std::set<const Token*> copiedVars;

const Token* copyCtor = nullptr;

for (const Function &func : scope->functionList) {

if (func.type != Function::eCopyConstructor)

continue;

copyCtor = func.tokenDef;

if (!func.functionScope) {

allocatedVars.clear();

break;

}

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->bodyStart; tok != func.functionScope->bodyEnd; 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);

}

}

break;

}

if (copyCtor && !copiedVars.empty()) {

for (const Token *cv : copiedVars)

copyConstructorShallowCopyError(cv, cv->str());

// throw error if count mismatch

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

}

}

{

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

"$symbol:" + varname + "\nValue of pointer '$symbol', which points to allocated memory, is copied in copy constructor instead of allocating new memory.", CWE398, false);

{

const std::string &classname = scope ? scope->className : "class";

const std::string type = (scope && scope->type == Scope::eStruct) ? "Struct" : "Class";

const bool isDestructor = (function[0] == 'd');

std::string errmsg = "$symbol:" + classname + '\n';

if (isdefault) {

errmsg += type + " '$symbol' has dynamic memory/resource allocation(s). The " + function + " is explicitly defaulted but the default " + function + " does not work well.";

if (isDestructor)

errmsg += " It is recommended to define the " + std::string(function) + '.';

else

errmsg += " It is recommended to define or delete the " + std::string(function) + '.';

} else {

errmsg += type + " '$symbol' does not have a " + function + " which is recommended since it has dynamic memory/resource allocation(s).";

}

return errmsg;

{

bool constructor = false;

bool publicAssign = false;

bool publicCopy = false;

for (const Function &func : scope->functionList) {

if (func.isConstructor())

constructor = true;

if (func.access != Public)

continue;

if (func.type == Function::eCopyConstructor) {

publicCopy = true;

break;

} else if (func.type == Function::eOperatorEqual) {

publicAssign = true;

break;

}

}

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

{

bool constructor = false;

bool publicAssign = false;

bool publicCopy = false;

bool publicMove = false;

for (const Function &func : scope->functionList) {

if (func.isConstructor())

constructor = true;

if (func.access != Public)

continue;

if (func.type == Function::eCopyConstructor) {

publicCopy = true;

break;

} else if (func.type == Function::eMoveConstructor) {

publicMove = true;

break;

} else if (func.type == Function::eOperatorEqual) {

publicAssign = true;

break;

}

}

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

{

unsigned int count = 0;

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

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

usage[count].assign = true;

return;

}

}

{

unsigned int count = 0;

for (std::list<Variable>::const_iterator 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;

for (const Function &func : functionList) {

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(nullptr, "Internal Error: Invalid syntax"); // #5702

bool initList = func.isConstructor();

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

int level = 0;

for (; ftok && ftok != func.functionScope->bodyEnd; 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%") && isLikelyStreamRead(true, ftok)) {

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

}

// If assignment comes after an && or || this is really inconclusive because of short circuiting

if (Token::Match(ftok, "%oror%|&&"))

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% (")) {

for (const Variable &var : scope->varlist) {

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;

}

// Ticket #7068

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

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

ftok = ftok->next();

int offsetToMember = 4;

if (ftok->strAt(2) == "&")

++offsetToMember;

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

ftok = ftok->linkAt(1);

continue;

}

// 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",

"$symbol:" + classname + "\n" +

"The " + std::string(isStruct ? "struct" : "class") + " '$symbol' does not have a constructor although it has private member variables.\n"

"The " + std::string(isStruct ? "struct" : "class") + " '$symbol' 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.", CWE398, false);

{

const std::string message(std::string(isStruct ? "Struct" : "Class") + " '$symbol' 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", "$symbol:" + classname + '\n' + message + '\n' + verbose, CWE398, false);

{

if (!mSettings->isEnabled(Settings::PERFORMANCE))

return;

for (const Scope *scope : mSymbolDatabase->functionScopes) {

// Check every constructor

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

continue;

const Scope* owner = scope->functionOf;

for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; 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->isEnumType() || var->valueType()->type > ValueType::Type::ITERATOR)

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", "$symbol:" + varname + "\nVariable '$symbol' 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 '$symbol' a value by passing the value to the constructor in the initialization list.", CWE398, false);

{

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) == privfunc->name())

return true;

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

ftok = ftok->link();

}

}

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

if (ftok->function() == privfunc)

return true;

if (ftok->varId() == 0U && ftok->str() == privfunc->name()) // TODO: This condition should be redundant

return true;

}