: _tokenizer(tokenizer), _settings(settings), _errorLogger(errorLogger)

{

// create global scope

scopeList.push_back(Scope(this, nullptr, nullptr));

// pointer to current scope

Scope *scope = &scopeList.back();

// Store current access in each scope (depends on evaluation progress)

std::map<const Scope*, AccessControl> access;

const bool printDebug =_settings->debugwarnings;

// find all scopes

for (const Token *tok = _tokenizer->tokens(); tok; tok = tok ? tok->next() : nullptr) {

// #5593 suggested to add here:

if (_errorLogger)

_errorLogger->reportProgress(_tokenizer->list.getSourceFilePath(),

"SymbolDatabase",

tok->progressValue());

// Locate next class

if ((_tokenizer->isCPP() && ((Token::Match(tok, "class|struct|union|namespace ::| %name% {|:|::|<") && tok->strAt(-1) != "friend") ||

(Token::Match(tok, "enum class| %name% {") || Token::Match(tok, "enum class| %name% : %name% {"))))

|| (_tokenizer->isC() && Token::Match(tok, "struct|union|enum %name% {"))) {

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

if (tok->strAt(1) == "::")

tok2 = tok2->next();

else if (_tokenizer->isCPP() && tok->strAt(1) == "class")

tok2 = tok2->next();

while (tok2 && tok2->str() == "::")

tok2 = tok2->tokAt(2);

// skip over template args

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

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

// make sure we have valid code

if (!tok2 || !Token::Match(tok2, "{|:")) {

// check for qualified variable

if (tok2 && tok2->next()) {

if (tok2->next()->str() == ";")

tok = tok2->next();

else if (Token::simpleMatch(tok2->next(), "= {") &&

Token::simpleMatch(tok2->linkAt(2), "} ;"))

tok = tok2->linkAt(2)->next();

else if (Token::Match(tok2->next(), "(|{") &&

tok2->next()->link()->strAt(1) == ";")

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

// skip variable declaration

else if (Token::Match(tok2, "*|&|>"))

continue;

else

break; // bail

continue;

}

break; // bail

}

Scope *new_scope = findScope(tok->next(), scope);

if (new_scope) {

// only create base list for classes and structures

if (new_scope->isClassOrStruct()) {

// goto initial '{'

if (!new_scope->definedType) {

_tokenizer->syntaxError(nullptr); // #6808

}

tok2 = new_scope->definedType->initBaseInfo(tok, tok2);

// make sure we have valid code

if (!tok2) {

break;

}

}

// definition may be different than declaration

if (_tokenizer->isCPP() && tok->str() == "class") {

access[new_scope] = Private;

new_scope->type = Scope::eClass;

} else if (tok->str() == "struct") {

access[new_scope] = Public;

new_scope->type = Scope::eStruct;

}

new_scope->classDef = tok;

new_scope->classStart = tok2;

new_scope->classEnd = tok2->link();

scope = new_scope;

tok = tok2;

} else {

scopeList.push_back(Scope(this, tok, scope));

new_scope = &scopeList.back();

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

access[new_scope] = Private;

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

access[new_scope] = Public;

// fill typeList...

if (new_scope->isClassOrStruct() || new_scope->type == Scope::eUnion || new_scope->type == Scope::eEnum) {

Type* new_type = findType(tok->next(), scope);

if (!new_type) {

typeList.push_back(Type(new_scope->classDef, new_scope, scope));

new_type = &typeList.back();

scope->definedTypes.push_back(new_type);

} else

new_type->classScope = new_scope;

new_scope->definedType = new_type;

}

// only create base list for classes and structures

if (new_scope->isClassOrStruct()) {

// goto initial '{'

tok2 = new_scope->definedType->initBaseInfo(tok, tok2);

// make sure we have valid code

if (!tok2) {

_tokenizer->syntaxError(tok);

}

} else if (new_scope->type == Scope::eEnum) {

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

tok2 = tok2->tokAt(2);

}

new_scope->classStart = tok2;

new_scope->classEnd = tok2->link();

// make sure we have valid code

if (!new_scope->classEnd) {

_tokenizer->syntaxError(tok);

}

if (new_scope->type == Scope::eEnum) {

tok2 = new_scope->addEnum(tok, _tokenizer->isCPP());

scope->nestedList.push_back(new_scope);

if (!tok2)

_tokenizer->syntaxError(tok);

} else {

// make the new scope the current scope

scope->nestedList.push_back(new_scope);

scope = new_scope;

}

tok = tok2;

}

}

// Namespace and unknown macro (#3854)

else if (_tokenizer->isCPP() &&

Token::Match(tok, "namespace %name% %type% (") &&

tok->tokAt(2)->isUpperCaseName() &&

Token::simpleMatch(tok->linkAt(3), ") {")) {

scopeList.push_back(Scope(this, tok, scope));

Scope *new_scope = &scopeList.back();

access[new_scope] = Public;

const Token *tok2 = tok->linkAt(3)->next();

new_scope->classStart = tok2;

new_scope->classEnd = tok2->link();

// make sure we have valid code

if (!new_scope->classEnd) {

scopeList.pop_back();

break;

}

// make the new scope the current scope

scope->nestedList.push_back(new_scope);

scope = &scopeList.back();

tok = tok2;

}

// forward declaration

else if (Token::Match(tok, "class|struct|union %name% ;") &&

tok->strAt(-1) != "friend") {

if (!findType(tok->next(), scope)) {

// fill typeList..

typeList.push_back(Type(tok, 0, scope));

scope->definedTypes.push_back(&typeList.back());

}

tok = tok->tokAt(2);

}

// using namespace

else if (_tokenizer->isCPP() && Token::Match(tok, "using namespace ::| %type% ;|::")) {

Scope::UsingInfo using_info;

using_info.start = tok; // save location

using_info.scope = findNamespace(tok->tokAt(2), scope);

scope->usingList.push_back(using_info);

// check for global namespace

if (tok->strAt(2) == "::")

tok = tok->tokAt(4);

else

tok = tok->tokAt(3);

// skip over qualification

while (tok && Token::Match(tok, "%type% ::"))

tok = tok->tokAt(2);

}

// unnamed struct and union

else if (Token::Match(tok, "struct|union {") &&

Token::Match(tok->next()->link(), "} *|&| %name% ;|[")) {

scopeList.push_back(Scope(this, tok, scope));

Scope *new_scope = &scopeList.back();

access[new_scope] = Public;

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

if (varNameTok->str() == "*") {

varNameTok = varNameTok->next();

} else if (varNameTok->str() == "&") {

varNameTok = varNameTok->next();

}

typeList.push_back(Type(tok, new_scope, scope));

new_scope->definedType = &typeList.back();

scope->definedTypes.push_back(&typeList.back());

scope->addVariable(varNameTok, tok, tok, access[scope], new_scope->definedType, scope, &settings->library);

const Token *tok2 = tok->next();

new_scope->classStart = tok2;

new_scope->classEnd = tok2->link();

// make sure we have valid code

if (!new_scope->classEnd) {

scopeList.pop_back();

break;

}

// make the new scope the current scope

scope->nestedList.push_back(new_scope);

scope = new_scope;

tok = tok2;

}

// anonymous struct, union and namespace

else if ((Token::Match(tok, "struct|union {") &&

Token::simpleMatch(tok->next()->link(), "} ;")) ||

Token::simpleMatch(tok, "namespace {")) {

scopeList.push_back(Scope(this, tok, scope));

Scope *new_scope = &scopeList.back();

access[new_scope] = Public;

const Token *tok2 = tok->next();

new_scope->classStart = tok2;

new_scope->classEnd = tok2->link();

typeList.push_back(Type(tok, new_scope, scope));

new_scope->definedType = &typeList.back();

scope->definedTypes.push_back(&typeList.back());

// make sure we have valid code

if (!new_scope->classEnd) {

scopeList.pop_back();

break;

}

// make the new scope the current scope

scope->nestedList.push_back(new_scope);

scope = new_scope;

tok = tok2;

}

// forward declared enum

else if (Token::Match(tok, "enum class| %name% ;") || Token::Match(tok, "enum class| %name% : %name% ;")) {

typeList.push_back(Type(tok, 0, scope));

scope->definedTypes.push_back(&typeList.back());

tok = tok->tokAt(2);

}

else {

// check for end of scope

if (tok == scope->classEnd) {

access.erase(scope);

scope = const_cast<Scope*>(scope->nestedIn);

continue;

}

// check if in class or structure

else if (scope->type == Scope::eClass || scope->type == Scope::eStruct) {

const Token *funcStart = nullptr;

const Token *argStart = nullptr;

const Token *declEnd = nullptr;

// What section are we in..

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

access[scope] = Private;

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

access[scope] = Protected;

else if (tok->str() == "public:" || tok->str() == "__published:")

access[scope] = Public;

else if (Token::Match(tok, "public|protected|private %name% :")) {

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

access[scope] = Private;

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

access[scope] = Protected;

else

access[scope] = Public;

tok = tok->tokAt(2);

}

// class function?

else if (isFunction(tok, scope, &funcStart, &argStart, &declEnd)) {

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

Function function;

// save the function definition argument start '('

function.argDef = argStart;

// save the access type

function.access = access[scope];

// save the function name location

function.tokenDef = funcStart;

// save the function parent scope

function.nestedIn = scope;

// operator function

if (function.tokenDef->isOperatorKeyword()) {

function.isOperator(true);

// 'operator =' is special

if (function.tokenDef->str() == "operator=")

function.type = Function::eOperatorEqual;

}

// class constructor/destructor

else if (function.tokenDef->str() == scope->className) {

// destructor

if (function.tokenDef->previous()->str() == "~")

function.type = Function::eDestructor;

// copy/move constructor?

else if (Token::Match(function.tokenDef, "%name% ( const| %name% &|&& &| %name%| )") ||

Token::Match(function.tokenDef, "%name% ( const| %name% <")) {

const Token* typeTok = function.tokenDef->tokAt(2);

if (typeTok->str() == "const")

typeTok = typeTok->next();

if (typeTok->strAt(1) == "<") { // TODO: Remove this branch (#4710)

if (Token::Match(typeTok->linkAt(1), "> & %name%| )"))

function.type = Function::eCopyConstructor;

else if (Token::Match(typeTok->linkAt(1), "> &&|& & %name%| )"))

function.type = Function::eMoveConstructor;

else

function.type = Function::eConstructor;

} else if (typeTok->strAt(1) == "&&" || typeTok->strAt(2) == "&")

function.type = Function::eMoveConstructor;

else

function.type = Function::eCopyConstructor;

if (typeTok->str() != function.tokenDef->str())

function.type = Function::eConstructor; // Overwrite, if types are not identical

}

// regular constructor

else

function.type = Function::eConstructor;

if (function.tokenDef->previous()->str() == "explicit")

function.isExplicit(true);

}

const Token *tok1 = tok;

// look for end of previous statement

while (tok1->previous() && !Token::Match(tok1->previous(), ";|}|{|public:|protected:|private:")) {

// virtual function

if (tok1->previous()->str() == "virtual") {

function.isVirtual(true);

break;

}

// static function

else if (tok1->previous()->str() == "static") {

function.isStatic(true);

break;

}

// friend function

else if (tok1->previous()->str() == "friend") {

function.isFriend(true);

break;

}

tok1 = tok1->previous();

}

// find the return type

if (!function.isConstructor() && !function.isDestructor()) {

if (argStart->link()->strAt(1) == ".") // Trailing return type

function.retDef = argStart->link()->tokAt(2);

else {

while (tok1 && Token::Match(tok1->next(), "virtual|static|friend|const|struct|union|enum"))

tok1 = tok1->next();

if (tok1)

function.retDef = tok1;

}

}

const Token *end = function.argDef->link();

// const function

if (end->next()->str() == "const")

function.isConst(true);

// count the number of constructors

if (function.isConstructor())

scope->numConstructors++;

if (function.type == Function::eCopyConstructor ||

function.type == Function::eMoveConstructor)

scope->numCopyOrMoveConstructors++;

// assume implementation is inline (definition and implementation same)

function.token = function.tokenDef;

function.arg = function.argDef;

// out of line function

if (_tokenizer->isFunctionHead(end, ";")) {

// find the function implementation later

tok = end->next();

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

tok = tok->next();

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

function.hasLvalRefQualifier(true);

tok = tok->next();

} else if (tok->str() == "&&") {

function.hasRvalRefQualifier(true);

tok = tok->next();

} else if (tok->str() == "noexcept") {

function.isNoExcept(!Token::simpleMatch(tok->next(), "( false )"));

tok = tok->next();

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

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

} else if (Token::simpleMatch(tok, "throw (")) {

function.isThrow(true);

if (tok->strAt(2) != ")")

function.throwArg = end->tokAt(2);

tok = tok->linkAt(1)->next();

}

if (Token::Match(tok, "= %any% ;")) {

function.isPure(tok->strAt(1) == "0");

function.isDefault(tok->strAt(1) == "default");

function.isDelete(tok->strAt(1) == "delete");

tok = tok->tokAt(2);

}

// skip over unknown tokens

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

tok = tok->next();

scope->addFunction(function);

}

// inline function

else {

function.isInline(true);

function.hasBody(true);

if (Token::Match(end, ") const| noexcept")) {

int arg = 2;

if (end->strAt(1) == "const")

arg++;

if (end->strAt(arg) == "(")

function.noexceptArg = end->tokAt(arg + 1);

function.isNoExcept(true);

} else if (Token::Match(end, ") const| throw (")) {

int arg = 3;

if (end->strAt(1) == "const")

arg++;

if (end->strAt(arg) != ")")

function.throwArg = end->tokAt(arg);

function.isThrow(true);

} else if (Token::Match(end, ") const| &|&&| [;{]")) {

int arg = 1;

if (end->strAt(arg) == "const")

arg++;

if (end->strAt(arg) == "&")

function.hasLvalRefQualifier(true);

else if (end->strAt(arg) == "&&")

function.hasRvalRefQualifier(true);

}

// find start of function '{'

bool foundInitList = false;

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

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

end = end->link();

} else if (foundInitList &&

Token::Match(end, "%name%|> {") &&

Token::Match(end->linkAt(1), "} ,|{")) {

end = end->linkAt(1);

} else {

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

foundInitList = true;

end = end->next();

}

}

if (!end || end->str() == ";")

continue;

scope->addFunction(function);

Function* funcptr = &scope->functionList.back();

const Token *tok2 = funcStart;

addNewFunction(&scope, &tok2);

if (scope) {

scope->functionOf = function.nestedIn;

scope->function = funcptr;

scope->function->functionScope = scope;

}

tok = tok2;

}

}

// nested class or friend function?

else {

/** @todo check entire qualification for match */

Scope * nested = scope->findInNestedListRecursive(tok->strAt(-2));

if (nested)

addClassFunction(&scope, &tok, argStart);

else {

/** @todo handle friend functions */

}

}

}

// friend class declaration?

else if (_tokenizer->isCPP() && Token::Match(tok, "friend class| ::| %any% ;|::")) {

Type::FriendInfo friendInfo;

// save the name start

friendInfo.nameStart = tok->strAt(1) == "class" ? tok->tokAt(2) : tok->next();

friendInfo.nameEnd = friendInfo.nameStart;

// skip leading "::"

if (friendInfo.nameEnd->str() == "::")

friendInfo.nameEnd = friendInfo.nameEnd->next();

// skip qualification "name ::"

while (friendInfo.nameEnd && friendInfo.nameEnd->strAt(1) == "::")

friendInfo.nameEnd = friendInfo.nameEnd->tokAt(2);

// save the name

if (friendInfo.nameEnd)

friendInfo.name = friendInfo.nameEnd->str();

// fill this in after parsing is complete

friendInfo.type = 0;

if (!scope->definedType)

_tokenizer->syntaxError(tok);

scope->definedType->friendList.push_back(friendInfo);

}

} else if (scope->type == Scope::eNamespace || scope->type == Scope::eGlobal) {

const Token *funcStart = nullptr;

const Token *argStart = nullptr;

const Token *declEnd = nullptr;

// function?

if (isFunction(tok, scope, &funcStart, &argStart, &declEnd)) {

// has body?

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

tok = funcStart;

// class function

if (tok->previous() && tok->previous()->str() == "::")

addClassFunction(&scope, &tok, argStart);

// class destructor

else if (tok->previous() &&

tok->previous()->str() == "~" &&

tok->strAt(-2) == "::")

addClassFunction(&scope, &tok, argStart);

// regular function

else {

Function* function = addGlobalFunction(scope, tok, argStart, funcStart);

if (!function)

_tokenizer->syntaxError(tok);

// global functions can't be const but we have tests that are

if (Token::Match(argStart->link(), ") const| noexcept")) {

int arg = 2;

if (argStart->link()->strAt(1) == "const")

arg++;

if (argStart->link()->strAt(arg) == "(")

function->noexceptArg = argStart->link()->tokAt(arg + 1);

function->isNoExcept(true);

} else if (Token::Match(argStart->link(), ") const| throw (")) {

int arg = 3;

if (argStart->link()->strAt(1) == "const")

arg++;

if (argStart->link()->strAt(arg) != ")")

function->throwArg = argStart->link()->tokAt(arg);

function->isThrow(true);

}

const Token *tok1 = tok->previous();

// look for end of previous statement

while (tok1 && !Token::Match(tok1, ";|}|{")) {

// static function

if (tok1->str() == "static") {

function->isStaticLocal(true);

break;

}

// extern function

else if (tok1->str() == "extern") {

function->isExtern(true);

break;

}

tok1 = tok1->previous();

}

}

// syntax error?

if (!scope)

_tokenizer->syntaxError(tok);

}

// function prototype?

else if (declEnd && declEnd->str() == ";") {

bool newFunc = true; // Is this function already in the database?

for (std::multimap<std::string, const Function *>::const_iterator i = scope->functionMap.find(tok->str()); i != scope->functionMap.end() && i->first == tok->str(); ++i) {

if (Function::argsMatch(scope, i->second->argDef->next(), argStart->next(), "", 0)) {

newFunc = false;

break;

}

}

// save function prototype in database

if (newFunc) {

Function* func = addGlobalFunctionDecl(scope, tok, argStart, funcStart);

if (Token::Match(argStart->link(), ") const| noexcept")) {

int arg = 2;

if (argStart->link()->strAt(1) == "const")

arg++;

if (argStart->link()->strAt(arg) == "(")

func->noexceptArg = argStart->link()->tokAt(arg + 1);

func->isNoExcept(true);

} else if (Token::Match(argStart->link(), ") const| throw (")) {

int arg = 3;

if (argStart->link()->strAt(1) == "const")

arg++;

if (argStart->link()->strAt(arg) != ")")

func->throwArg = argStart->link()->tokAt(arg);

func->isThrow(true);

}

const Token *tok1 = tok->previous();

// look for end of previous statement

while (tok1 && !Token::Match(tok1, ";|}|{")) {

// extern function

if (tok1->str() == "extern") {

func->isExtern(true);

break;

}

tok1 = tok1->previous();

}

}

tok = declEnd;

continue;

}

}

} else if (scope->isExecutable()) {

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

const Token* tok1 = tok->next();

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

scopeList.push_back(Scope(this, tok, scope, Scope::eElse, tok1));

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

scopeList.push_back(Scope(this, tok, scope, Scope::eDo, tok1));

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

scopeList.push_back(Scope(this, tok, scope, Scope::eTry, tok1));

tok = tok1;

scope->nestedList.push_back(&scopeList.back());

scope = &scopeList.back();

} else if (Token::Match(tok, "if|for|while|catch|switch (") && Token::simpleMatch(tok->next()->link(), ") {")) {

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

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

scopeList.push_back(Scope(this, tok, scope, Scope::eIf, scopeStartTok));

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

scopeList.push_back(Scope(this, tok, scope, Scope::eFor, scopeStartTok));

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

scopeList.push_back(Scope(this, tok, scope, Scope::eWhile, scopeStartTok));

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

scopeList.push_back(Scope(this, tok, scope, Scope::eCatch, scopeStartTok));

} else // if (tok->str() == "switch")

scopeList.push_back(Scope(this, tok, scope, Scope::eSwitch, scopeStartTok));

scope->nestedList.push_back(&scopeList.back());

scope = &scopeList.back();

if (scope->type == Scope::eFor)

scope->checkVariable(tok->tokAt(2), Local, &settings->library); // check for variable declaration and add it to new scope if found

else if (scope->type == Scope::eCatch)

scope->checkVariable(tok->tokAt(2), Throw, &settings->library); // check for variable declaration and add it to new scope if found

tok = scopeStartTok;

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

if (tok->previous()->varId())

tok = tok->link();

else {

const Token* tok2 = tok->previous();

while (!Token::Match(tok2, ";|}|{|)"))

tok2 = tok2->previous();

if (tok2->next() != tok && tok2->strAt(1) != ".")

tok2 = nullptr; // No lambda

if (tok2 && tok2->str() == ")" && tok2->link()->strAt(-1) == "]") {

scopeList.push_back(Scope(this, tok2->link()->linkAt(-1), scope, Scope::eLambda, tok));

scope->nestedList.push_back(&scopeList.back());

scope = &scopeList.back();

} else if (!Token::Match(tok->previous(), "=|,|(|return") && !(tok->strAt(-1) == ")" && Token::Match(tok->linkAt(-1)->previous(), "=|,|(|return"))) {

scopeList.push_back(Scope(this, tok, scope, Scope::eUnconditional, tok));

scope->nestedList.push_back(&scopeList.back());

scope = &scopeList.back();

} else {

tok = tok->link();

}

}

}

}

}

}

if (!_tokenizer->isC()) {

// fill in base class info

for (std::list<Type>::iterator it = typeList.begin(); it != typeList.end(); ++it) {

// finish filling in base class info

for (unsigned int i = 0; i < it->derivedFrom.size(); ++i) {

const Type* found = findType(it->derivedFrom[i].nameTok, it->enclosingScope);

if (found && found->findDependency(&(*it))) {

// circular dependency

//_tokenizer->syntaxError(nullptr);

} else {

it->derivedFrom[i].type = found;

}

}

}

// fill in friend info

for (std::list<Type>::iterator it = typeList.begin(); it != typeList.end(); ++it) {

for (std::list<Type::FriendInfo>::iterator i = it->friendList.begin(); i != it->friendList.end(); ++i) {

i->type = findType(i->nameStart, it->enclosingScope);

}

}

// fill in using info

for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {

for (std::list<Scope::UsingInfo>::iterator i = it->usingList.begin(); i != it->usingList.end(); ++i) {

// only find if not already found

if (i->scope == nullptr) {

// check scope for match

scope = findScope(i->start->tokAt(2), &(*it));

if (scope) {

// set found scope

i->scope = scope;

break;

}

}

}

}

}

// fill in variable info

for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {

// find variables

it->getVariableList(&settings->library);

}

// fill in function arguments

for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {

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

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

// add arguments

func->addArguments(this, &*it);

}

}

// fill in function scopes

for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {

if (it->type == Scope::eFunction)

functionScopes.push_back(&*it);

}

// fill in class and struct scopes

for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {

if (it->isClassOrStruct())

classAndStructScopes.push_back(&*it);

}

// fill in function return types

for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {

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

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

// add return types

if (func->retDef) {

const Token *type = func->retDef;

while (Token::Match(type, "static|const|struct|union|enum"))

type = type->next();

if (type) {

func->retType = findVariableTypeInBase(&*it, type);

if (!func->retType)

func->retType = findTypeInNested(type, func->nestedIn);

}

}

}

}

if (tokenizer->isC()) {

// For C code it is easy, as there are no constructors and no default values

for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {

scope = &(*it);

if (scope->definedType)

scope->definedType->needInitialization = Type::True;

}

} else {

// For C++, it is more difficult: Determine if user defined type needs initialization...

unsigned int unknowns = 0; // stop checking when there are no unknowns

unsigned int retry = 0; // bail if we don't resolve all the variable types for some reason

do {

unknowns = 0;

for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {

scope = &(*it);

if (!scope->definedType) {

_blankTypes.push_back(Type());

scope->definedType = &_blankTypes.back();

}

if (scope->isClassOrStruct() && scope->definedType->needInitialization == Type::Unknown) {

// check for default constructor

bool hasDefaultConstructor = false;

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

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

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

// check for no arguments: func ( )

if (func->argCount() == 0) {

hasDefaultConstructor = true;

break;

}

/** check for arguments with default values */

else if (func->argCount() == func->initializedArgCount()) {

hasDefaultConstructor = true;

break;

}

}

}

// User defined types with user defined default constructor doesn't need initialization.

// We assume the default constructor initializes everything.

// Another check will figure out if the constructor actually initializes everything.

if (hasDefaultConstructor)

scope->definedType->needInitialization = Type::False;

// check each member variable to see if it needs initialization

else {

bool needInitialization = false;

bool unknown = false;

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

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

if (var->isClass()) {

if (var->type()) {

// does this type need initialization?

if (var->type()->needInitialization == Type::True)

needInitialization = true;

else if (var->type()->needInitialization == Type::Unknown)

unknown = true;

}

} else if (!var->hasDefault())

needInitialization = true;

}

if (needInitialization)

scope->definedType->needInitialization = Type::True;

else if (!unknown)

scope->definedType->needInitialization = Type::False;

if (scope->definedType->needInitialization == Type::Unknown)

unknowns++;

}

} else if (scope->type == Scope::eUnion && scope->definedType->needInitialization == Type::Unknown)

scope->definedType->needInitialization = Type::True;

}

retry++;

} while (unknowns && retry < 100);

// this shouldn't happen so output a debug warning

if (retry == 100 && printDebug) {

for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {

scope = &(*it);

if (scope->isClassOrStruct() && scope->definedType->needInitialization == Type::Unknown)

debugMessage(scope->classDef, "SymbolDatabase::SymbolDatabase couldn't resolve all user defined types.");

}

}

}

// create variable symbol table

_variableList.resize(_tokenizer->varIdCount() + 1);

std::fill_n(_variableList.begin(), _variableList.size(), (const Variable*)nullptr);

// check all scopes for variables