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

Symbol database: renamed classes. ticket: #2468

This commit is contained in:
Robert Reif 2011-01-17 18:29:19 +01:00 committed by Daniel Marjamäki
parent bf9528558e
commit 959e10cee5
9 changed files with 362 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

284
lib/checkclass.cpp
View File

@ -68,51 +68,51 @@ void CheckClass::constructors()
createSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
// only check classes and structures
if (!info->isClassOrStruct())
if (!scope->isClassOrStruct())
continue;
// There are no constructors.
if (info->numConstructors == 0)
if (scope->numConstructors == 0)
{
// If there is a private variable, there should be a constructor..
std::list<Var>::const_iterator var;
for (var = info->varlist.begin(); var != info->varlist.end(); ++var)
std::list<Variable>::const_iterator var;
for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var)
{
if (var->access == Private && !var->isClass && !var->isStatic)
{
noConstructorError(info->classDef, info->className, info->classDef->str() == "struct");
noConstructorError(scope->classDef, scope->className, scope->classDef->str() == "struct");
break;
}
}
}
std::list<Func>::const_iterator func;
std::vector<Usage> usage(info->varlist.size());
std::list<Function>::const_iterator func;
std::vector<Usage> usage(scope->varlist.size());
for (func = info->functionList.begin(); func != info->functionList.end(); ++func)
for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)
{
if (!func->hasBody || !(func->type == Func::Constructor ||
func->type == Func::CopyConstructor ||
func->type == Func::OperatorEqual))
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, info, usage);
initializeVarList(*func, callstack, scope, usage);
// Check if any variables are uninitialized
std::list<Var>::const_iterator var;
std::list<Variable>::const_iterator var;
unsigned int count = 0;
for (var = info->varlist.begin(); var != info->varlist.end(); ++var, ++count)
for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var, ++count)
{
if (usage[count].assign || usage[count].init || var->isStatic)
continue;
@ -121,7 +121,7 @@ void CheckClass::constructors()
continue;
// Check if this is a class constructor
if (var->isClass && func->type == Func::Constructor)
if (var->isClass && func->type == Function::eConstructor)
{
// Unknown type so assume it is initialized
if (!var->type)
@ -129,12 +129,12 @@ void CheckClass::constructors()
// Known type that doesn't need initialization or
// known type that has member variables of an unknown type
else if (var->type->needInitialization != SpaceInfo::True)
else if (var->type->needInitialization != Scope::True)
continue;
}
// It's non-static and it's not initialized => error
if (func->type == Func::OperatorEqual)
if (func->type == Function::eOperatorEqual)
{
const Token *operStart = 0;
if (func->token->str() == "=")
@ -145,7 +145,7 @@ void CheckClass::constructors()
bool classNameUsed = false;
for (const Token *operTok = operStart; operTok != operStart->link(); operTok = operTok->next())
{
if (operTok->str() == info->className)
if (operTok->str() == scope->className)
{
classNameUsed = true;
break;
@ -153,21 +153,21 @@ void CheckClass::constructors()
}
if (classNameUsed)
operatorEqVarError(func->token, info->className, var->token->str());
operatorEqVarError(func->token, scope->className, var->token->str());
}
else if (func->access != Private)
uninitVarError(func->token, info->className, var->token->str());
uninitVarError(func->token, scope->className, var->token->str());
}
}
}
}
void CheckClass::assignVar(const std::string &varname, const SpaceInfo *info, std::vector<Usage> &usage)
void CheckClass::assignVar(const std::string &varname, const Scope *scope, std::vector<Usage> &usage)
{
std::list<Var>::const_iterator var;
std::list<Variable>::const_iterator var;
unsigned int count = 0;
for (var = info->varlist.begin(); var != info->varlist.end(); ++var, ++count)
for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var, ++count)
{
if (var->token->str() == varname)
{
@ -177,12 +177,12 @@ void CheckClass::assignVar(const std::string &varname, const SpaceInfo *info, st
}
}
void CheckClass::initVar(const std::string &varname, const SpaceInfo *info, std::vector<Usage> &usage)
void CheckClass::initVar(const std::string &varname, const Scope *scope, std::vector<Usage> &usage)
{
std::list<Var>::const_iterator var;
std::list<Variable>::const_iterator var;
unsigned int count = 0;
for (var = info->varlist.begin(); var != info->varlist.end(); ++var, ++count)
for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var, ++count)
{
if (var->token->str() == varname)
{
@ -207,17 +207,17 @@ void CheckClass::clearAllVar(std::vector<Usage> &usage)
}
}
bool CheckClass::isBaseClassFunc(const Token *tok, const SpaceInfo *info)
bool CheckClass::isBaseClassFunc(const Token *tok, const Scope *scope)
{
// Iterate through each base class...
for (size_t i = 0; i < info->derivedFrom.size(); ++i)
for (size_t i = 0; i < scope->derivedFrom.size(); ++i)
{
const SpaceInfo *derivedFrom = info->derivedFrom[i].spaceInfo;
const Scope *derivedFrom = scope->derivedFrom[i].spaceInfo;
// Check if base class exists in database
if (derivedFrom)
{
std::list<Func>::const_iterator func;
std::list<Function>::const_iterator func;
for (func = derivedFrom->functionList.begin(); func != derivedFrom->functionList.end(); ++func)
{
@ -234,7 +234,7 @@ bool CheckClass::isBaseClassFunc(const Token *tok, const SpaceInfo *info)
return false;
}
void CheckClass::initializeVarList(const Func &func, std::list<std::string> &callstack, const SpaceInfo *info, std::vector<Usage> &usage)
void CheckClass::initializeVarList(const Function &func, std::list<std::string> &callstack, const Scope *scope, std::vector<Usage> &usage)
{
bool Assign = false;
unsigned int indentlevel = 0;
@ -251,12 +251,12 @@ void CheckClass::initializeVarList(const Func &func, std::list<std::string> &cal
{
if (Assign && Token::Match(ftok, "%var% ("))
{
initVar(ftok->str(), info, usage);
initVar(ftok->str(), scope, usage);
// assignment in the initializer..
// : var(value = x)
if (Token::Match(ftok->tokAt(2), "%var% ="))
assignVar(ftok->strAt(2), info, usage);
assignVar(ftok->strAt(2), scope, usage);
}
Assign |= (ftok->str() == ":");
@ -282,7 +282,7 @@ void CheckClass::initializeVarList(const Func &func, std::list<std::string> &cal
// Variable getting value from stream?
if (Token::Match(ftok, ">> %var%"))
{
assignVar(ftok->strAt(1), info, usage);
assignVar(ftok->strAt(1), scope, usage);
}
// Before a new statement there is "[{};)=]"
@ -302,13 +302,13 @@ void CheckClass::initializeVarList(const Func &func, std::list<std::string> &cal
// Calling member variable function?
if (Token::Match(ftok->next(), "%var% . %var% ("))
{
std::list<Var>::const_iterator var;
for (var = info->varlist.begin(); var != info->varlist.end(); ++var)
std::list<Variable>::const_iterator var;
for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var)
{
if (var->token->varId() == ftok->next()->varId())
{
/** @todo false negative: we assume function changes variable state */
assignVar(ftok->next()->str(), info, usage);
assignVar(ftok->next()->str(), scope, usage);
continue;
}
}
@ -349,7 +349,7 @@ void CheckClass::initializeVarList(const Func &func, std::list<std::string> &cal
// Clearing array..
else if (Token::Match(ftok, "memset ( %var% ,"))
{
assignVar(ftok->strAt(2), info, usage);
assignVar(ftok->strAt(2), scope, usage);
ftok = ftok->next()->link();
continue;
}
@ -359,22 +359,22 @@ void CheckClass::initializeVarList(const Func &func, std::list<std::string> &cal
ftok->previous()->str() != "::")
{
// check if member function exists
std::list<Func>::const_iterator it;
for (it = info->functionList.begin(); it != info->functionList.end(); ++it)
std::list<Function>::const_iterator it;
for (it = scope->functionList.begin(); it != scope->functionList.end(); ++it)
{
if (ftok->next()->str() == it->tokenDef->str() && it->type != Func::Constructor)
if (ftok->next()->str() == it->tokenDef->str() && it->type != Function::eConstructor)
break;
}
// member function found
if (it != info->functionList.end())
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, info, usage);
initializeVarList(*it, callstack, scope, usage);
callstack.pop_back();
}
@ -412,22 +412,22 @@ void CheckClass::initializeVarList(const Func &func, std::list<std::string> &cal
}
// check if member function
std::list<Func>::const_iterator it;
for (it = info->functionList.begin(); it != info->functionList.end(); ++it)
std::list<Function>::const_iterator it;
for (it = scope->functionList.begin(); it != scope->functionList.end(); ++it)
{
if (ftok->str() == it->tokenDef->str() && it->type != Func::Constructor)
if (ftok->str() == it->tokenDef->str() && it->type != Function::eConstructor)
break;
}
// member function found
if (it != info->functionList.end())
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, info, usage);
initializeVarList(*it, callstack, scope, usage);
callstack.pop_back();
}
@ -442,7 +442,7 @@ void CheckClass::initializeVarList(const Func &func, std::list<std::string> &cal
else
{
// could be a base class virtual function, so we assume it initializes everything
if (func.type != Func::Constructor && isBaseClassFunc(ftok, info))
if (func.type != Function::eConstructor && isBaseClassFunc(ftok, scope))
{
/** @todo False Negative: we should look at the base class functions to see if they
* call any derived class virtual functions that change the derived class state
@ -451,7 +451,7 @@ void CheckClass::initializeVarList(const Func &func, std::list<std::string> &cal
}
// has friends, so we assume it initializes everything
if (!info->friendList.empty())
if (!scope->friendList.empty())
assignAllVar(usage);
// the function is external and it's neither friend nor inherited virtual function.
@ -471,7 +471,7 @@ void CheckClass::initializeVarList(const Func &func, std::list<std::string> &cal
}
if (tok->isName())
{
assignVar(tok->str(), info, usage);
assignVar(tok->str(), scope, usage);
}
}
}
@ -481,44 +481,44 @@ void CheckClass::initializeVarList(const Func &func, std::list<std::string> &cal
// Assignment of member variable?
else if (Token::Match(ftok, "%var% ="))
{
assignVar(ftok->str(), info, usage);
assignVar(ftok->str(), scope, usage);
}
// Assignment of array item of member variable?
else if (Token::Match(ftok, "%var% [ %any% ] ="))
{
assignVar(ftok->str(), info, usage);
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(), info, usage);
assignVar(ftok->str(), scope, usage);
}
// Assignment of array item of member variable?
else if (Token::Match(ftok, "%var% [ %any% ] [ %any% ] ="))
{
assignVar(ftok->str(), info, usage);
assignVar(ftok->str(), scope, usage);
}
// Assignment of array item of member variable?
else if (Token::Match(ftok, "* %var% ="))
{
assignVar(ftok->next()->str(), info, usage);
assignVar(ftok->next()->str(), scope, usage);
}
// Assignment of struct member of member variable?
else if (Token::Match(ftok, "%var% . %any% ="))
{
assignVar(ftok->str(), info, usage);
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(), info, usage);
assignVar(ftok->str(), scope, usage);
}
}
}
@ -569,32 +569,32 @@ void CheckClass::privateFunctions()
createSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
// only check classes and structures
if (!info->isClassOrStruct())
if (!scope->isClassOrStruct())
continue;
// don’t check derived classes
if (!info->derivedFrom.empty())
if (!scope->derivedFrom.empty())
continue;
// Locate some class
const Token *tok1 = info->classDef;
const Token *tok1 = scope->classDef;
// check that the whole class implementation is seen
bool whole = true;
std::list<Func>::const_iterator func;
for (func = info->functionList.begin(); func != info->functionList.end(); ++func)
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 == Func::CopyConstructor || func->type == Func::OperatorEqual) && func->access == Private)
if ((func->type == Function::eCopyConstructor || func->type == Function::eOperatorEqual) && func->access == Private)
continue;
whole = false;
@ -609,12 +609,12 @@ void CheckClass::privateFunctions()
std::list<const Token *> FuncList;
/** @todo embedded class have access to private functions */
if (!info->getNestedNonFunctions())
if (!scope->getNestedNonFunctions())
{
for (func = info->functionList.begin(); func != info->functionList.end(); ++func)
for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)
{
// Get private functions..
if (func->type == Func::Function &&
if (func->type == Function::eFunction &&
func->access == Private && func->hasBody)
FuncList.push_back(func->tokenDef);
}
@ -834,15 +834,15 @@ void CheckClass::operatorEq()
createSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
std::list<Func>::const_iterator it;
std::list<Function>::const_iterator it;
for (it = (*i)->functionList.begin(); it != (*i)->functionList.end(); ++it)
{
if (it->type == Func::OperatorEqual && it->access != Private)
if (it->type == Function::eOperatorEqual && it->access != Private)
{
if (it->token->strAt(-2) == "void")
operatorEqReturnError(it->token->tokAt(-2));
@ -861,7 +861,7 @@ void CheckClass::operatorEqReturnError(const Token *tok)
// operator= should return a reference to *this
//---------------------------------------------------------------------------
void CheckClass::checkReturnPtrThis(const SpaceInfo *info, const Func *func, const Token *tok, const Token *last)
void CheckClass::checkReturnPtrThis(const Scope *scope, const Function *func, const Token *tok, const Token *last)
{
bool foundReturn = false;
@ -871,7 +871,7 @@ void CheckClass::checkReturnPtrThis(const SpaceInfo *info, const Func *func, con
if (tok->str() == "return")
{
foundReturn = true;
std::string cast("( " + info->className + " & )");
std::string cast("( " + scope->className + " & )");
if (Token::Match(tok->next(), cast.c_str()))
tok = tok->tokAt(4);
@ -879,22 +879,22 @@ void CheckClass::checkReturnPtrThis(const SpaceInfo *info, const Func *func, con
if (Token::Match(tok->tokAt(1), "%any% (") &&
tok->tokAt(2)->link()->next()->str() == ";")
{
std::list<Func>::const_iterator it;
std::list<Function>::const_iterator it;
// check if it is a member function
for (it = info->functionList.begin(); it != info->functionList.end(); ++it)
for (it = scope->functionList.begin(); it != scope->functionList.end(); ++it)
{
// check for a regular function with the same name and a bofy
if (it->type == Func::Function && it->hasBody &&
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) == info->className)
it->tokenDef->strAt(-2) == scope->className)
{
// make sure it's not a const function
if (it->arg->link()->next()->str() != "const")
checkReturnPtrThis(info, &*it, it->arg->link()->next(), it->arg->link()->next()->link());
checkReturnPtrThis(scope, &*it, it->arg->link()->next(), it->arg->link()->next()->link());
}
}
}
@ -918,29 +918,29 @@ void CheckClass::operatorEqRetRefThis()
createSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
// only check classes and structures
if (info->isClassOrStruct())
if (scope->isClassOrStruct())
{
std::list<Func>::const_iterator func;
std::list<Function>::const_iterator func;
for (func = info->functionList.begin(); func != info->functionList.end(); ++func)
for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)
{
if (func->type == Func::OperatorEqual && func->hasBody)
if (func->type == Function::eOperatorEqual && func->hasBody)
{
// make sure return signature is correct
if (Token::Match(func->tokenDef->tokAt(-4), ";|}|{|public:|protected:|private: %type% &") &&
func->tokenDef->strAt(-3) == info->className)
func->tokenDef->strAt(-3) == scope->className)
{
// find the ')'
const Token *tok = func->token->next()->link();
checkReturnPtrThis(info, &(*func), tok->tokAt(2), tok->next()->link());
checkReturnPtrThis(scope, &(*func), tok->tokAt(2), tok->next()->link());
}
}
}
@ -974,29 +974,29 @@ void CheckClass::operatorEqToSelf()
createSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
std::list<Func>::const_iterator it;
const Scope *scope = *i;
std::list<Function>::const_iterator it;
// skip classes with multiple inheritance
if (info->derivedFrom.size() > 1)
if (scope->derivedFrom.size() > 1)
continue;
for (it = info->functionList.begin(); it != info->functionList.end(); ++it)
for (it = scope->functionList.begin(); it != scope->functionList.end(); ++it)
{
if (it->type == Func::OperatorEqual && it->hasBody)
if (it->type == Function::eOperatorEqual && it->hasBody)
{
// make sure return signature is correct
if (Token::Match(it->tokenDef->tokAt(-4), ";|}|{|public:|protected:|private: %type% &") &&
it->tokenDef->strAt(-3) == info->className)
it->tokenDef->strAt(-3) == scope->className)
{
// check for proper function parameter signature
if ((Token::Match(it->tokenDef->next(), "( const %var% & )") ||
Token::Match(it->tokenDef->next(), "( const %var% & %var% )")) &&
it->tokenDef->strAt(3) == info->className)
it->tokenDef->strAt(3) == scope->className)
{
// find the parameter name
const Token *rhs = it->token;
@ -1151,18 +1151,18 @@ void CheckClass::virtualDestructor()
createSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
// Skip base classes and namespaces
if (info->derivedFrom.empty())
if (scope->derivedFrom.empty())
continue;
// Find the destructor
const Func *destructor = info->getDestructor();
const Function *destructor = scope->getDestructor();
// Check for destructor with implementation
if (!destructor || !destructor->hasBody)
@ -1172,22 +1172,22 @@ void CheckClass::virtualDestructor()
if (destructor->token->tokAt(3)->link() == destructor->token->tokAt(4))
continue;
const Token *derived = info->classDef;
const Token *derived = scope->classDef;
const Token *derivedClass = derived->tokAt(1);
// Iterate through each base class...
for (unsigned int j = 0; j < info->derivedFrom.size(); ++j)
for (unsigned int j = 0; j < scope->derivedFrom.size(); ++j)
{
// Check if base class is public and exists in database
if (info->derivedFrom[j].access != Private && info->derivedFrom[j].spaceInfo)
if (scope->derivedFrom[j].access != Private && scope->derivedFrom[j].spaceInfo)
{
const SpaceInfo *spaceInfo = info->derivedFrom[j].spaceInfo;
const Scope *spaceInfo = scope->derivedFrom[j].spaceInfo;
// Name of base class..
const std::string baseName = spaceInfo->className;
// Find the destructor declaration for the base class.
const Func *base_destructor = spaceInfo->getDestructor();
const Function *base_destructor = spaceInfo->getDestructor();
const Token *base = 0;
if (base_destructor)
base = base_destructor->token;
@ -1270,22 +1270,22 @@ void CheckClass::checkConst()
createSymbolDatabase();
std::list<SpaceInfo *>::const_iterator it;
std::list<Scope *>::const_iterator it;
for (it = symbolDatabase->spaceInfoList.begin(); it != symbolDatabase->spaceInfoList.end(); ++it)
{
const SpaceInfo *info = *it;
const Scope *scope = *it;
// only check classes and structures
if (!info->isClassOrStruct())
if (!scope->isClassOrStruct())
continue;
std::list<Func>::const_iterator func;
std::list<Function>::const_iterator func;
for (func = info->functionList.begin(); func != info->functionList.end(); ++func)
for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)
{
// does the function have a body?
if (func->type == Func::Function && func->hasBody && !func->isFriend && !func->isStatic && !func->isConst && !func->isVirtual)
if (func->type == Function::eFunction && func->hasBody && !func->isFriend && !func->isStatic && !func->isConst && !func->isVirtual)
{
// get last token of return type
const Token *previous = func->tokenDef->isName() ? func->token->previous() : func->token->tokAt(-2);
@ -1343,18 +1343,18 @@ void CheckClass::checkConst()
const Token *paramEnd = func->arg->link();
// check if base class function is virtual
if (!info->derivedFrom.empty())
if (!scope->derivedFrom.empty())
{
if (isVirtualFunc(info, func->tokenDef))
if (isVirtualFunc(scope, func->tokenDef))
continue;
}
// if nothing non-const was found. write error..
if (checkConstFunc(info, paramEnd))
if (checkConstFunc(scope, paramEnd))
{
std::string classname = info->className;
const SpaceInfo *nest = info->nestedIn;
while (nest && nest->type != SpaceInfo::Global)
std::string classname = scope->className;
const Scope *nest = scope->nestedIn;
while (nest && nest->type != Scope::eGlobal)
{
classname = std::string(nest->className + "::" + classname);
nest = nest->nestedIn;
@ -1378,7 +1378,7 @@ void CheckClass::checkConst()
}
}
bool CheckClass::isMemberVar(const SpaceInfo *info, const Token *tok)
bool CheckClass::isMemberVar(const Scope *scope, const Token *tok)
{
const Token *tok1 = tok;
@ -1397,11 +1397,11 @@ bool CheckClass::isMemberVar(const SpaceInfo *info, const Token *tok)
tok = tok->tokAt(2);
// ignore class namespace
if (tok->str() == info->className && tok->next()->str() == "::")
if (tok->str() == scope->className && tok->next()->str() == "::")
tok = tok->tokAt(2);
std::list<Var>::const_iterator var;
for (var = info->varlist.begin(); var != info->varlist.end(); ++var)
std::list<Variable>::const_iterator var;
for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var)
{
if (var->token->str() == tok->str())
{
@ -1410,13 +1410,13 @@ bool CheckClass::isMemberVar(const SpaceInfo *info, const Token *tok)
}
// not found in this class
if (!info->derivedFrom.empty())
if (!scope->derivedFrom.empty())
{
// check each base class
for (unsigned int i = 0; i < info->derivedFrom.size(); ++i)
for (unsigned int i = 0; i < scope->derivedFrom.size(); ++i)
{
// find the base class
const SpaceInfo *spaceInfo = info->derivedFrom[i].spaceInfo;
const Scope *spaceInfo = scope->derivedFrom[i].spaceInfo;
// find the function in the base class
if (spaceInfo)
@ -1430,24 +1430,24 @@ bool CheckClass::isMemberVar(const SpaceInfo *info, const Token *tok)
return false;
}
bool CheckClass::isConstMemberFunc(const SpaceInfo *info, const Token *tok)
bool CheckClass::isConstMemberFunc(const Scope *scope, const Token *tok)
{
std::list<Func>::const_iterator func;
std::list<Function>::const_iterator func;
for (func = info->functionList.begin(); func != info->functionList.end(); ++func)
for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)
{
if (func->tokenDef->str() == tok->str() && func->isConst)
return true;
}
// not found in this class
if (!info->derivedFrom.empty())
if (!scope->derivedFrom.empty())
{
// check each base class
for (unsigned int i = 0; i < info->derivedFrom.size(); ++i)
for (unsigned int i = 0; i < scope->derivedFrom.size(); ++i)
{
// find the base class
const SpaceInfo *spaceInfo = info->derivedFrom[i].spaceInfo;
const Scope *spaceInfo = scope->derivedFrom[i].spaceInfo;
// find the function in the base class
if (spaceInfo)
@ -1461,7 +1461,7 @@ bool CheckClass::isConstMemberFunc(const SpaceInfo *info, const Token *tok)
return false;
}
bool CheckClass::checkConstFunc(const SpaceInfo *info, const Token *tok)
bool CheckClass::checkConstFunc(const Scope *scope, const Token *tok)
{
// if the function doesn't have any assignment nor function call,
// it can be a const function..
@ -1483,12 +1483,12 @@ bool CheckClass::checkConstFunc(const SpaceInfo *info, const Token *tok)
(tok1->str().find("=") == 1 &&
tok1->str().find_first_of("<!>") == std::string::npos))
{
if (tok1->previous()->varId() == 0 && !info->derivedFrom.empty())
if (tok1->previous()->varId() == 0 && !scope->derivedFrom.empty())
{
isconst = false;
break;
}
else if (isMemberVar(info, tok1->previous()))
else if (isMemberVar(scope, tok1->previous()))
{
isconst = false;
break;
@ -1515,7 +1515,7 @@ bool CheckClass::checkConstFunc(const SpaceInfo *info, const Token *tok)
}
// streaming: <<
else if (tok1->str() == "<<" && isMemberVar(info, tok1->previous()))
else if (tok1->str() == "<<" && isMemberVar(scope, tok1->previous()))
{
isconst = false;
break;
@ -1532,7 +1532,7 @@ bool CheckClass::checkConstFunc(const SpaceInfo *info, const Token *tok)
else if (Token::Match(tok1, "%var% (") &&
!(Token::Match(tok1, "return|c_str|if|string") || tok1->isStandardType()))
{
if (!isConstMemberFunc(info, tok1))
if (!isConstMemberFunc(scope, tok1))
{
isconst = false;
break;
@ -1558,17 +1558,17 @@ bool CheckClass::checkConstFunc(const SpaceInfo *info, const Token *tok)
//---------------------------------------------------------------------------
// check if this function is defined virtual in the base classes
bool CheckClass::isVirtualFunc(const SpaceInfo *info, const Token *functionToken) const
bool CheckClass::isVirtualFunc(const Scope *scope, const Token *functionToken) const
{
// check each base class
for (unsigned int i = 0; i < info->derivedFrom.size(); ++i)
for (unsigned int i = 0; i < scope->derivedFrom.size(); ++i)
{
// check if base class exists in database
if (info->derivedFrom[i].spaceInfo)
if (scope->derivedFrom[i].spaceInfo)
{
const SpaceInfo *derivedFrom = info->derivedFrom[i].spaceInfo;
const Scope *derivedFrom = scope->derivedFrom[i].spaceInfo;
std::list<Func>::const_iterator func;
std::list<Function>::const_iterator func;
// check if function defined in base class
for (func = derivedFrom->functionList.begin(); func != derivedFrom->functionList.end(); ++func)
@ -1597,7 +1597,7 @@ bool CheckClass::isVirtualFunc(const SpaceInfo *info, const Token *functionToken
}
// check for matching function parameters
if (returnMatch && symbolDatabase->argsMatch(info, tok->tokAt(2), functionToken->tokAt(2), std::string(""), 0))
if (returnMatch && symbolDatabase->argsMatch(scope, tok->tokAt(2), functionToken->tokAt(2), std::string(""), 0))
{
return true;
}

24
lib/checkclass.h
View File

@ -163,18 +163,18 @@ private:
}
// operatorEqRetRefThis helper function
void checkReturnPtrThis(const SpaceInfo *info, const Func *func, const Token *tok, const Token *last);
void checkReturnPtrThis(const Scope *scope, const Function *func, const Token *tok, const Token *last);
// operatorEqToSelf helper functions
bool hasDeallocation(const Token *first, const Token *last);
bool hasAssignSelf(const Token *first, const Token *last, const Token *rhs);
// checkConst helper functions
bool isMemberVar(const SpaceInfo *info, const Token *tok);
bool isConstMemberFunc(const SpaceInfo *info, const Token *tok);
bool checkConstFunc(const SpaceInfo *info, const Token *tok);
bool isMemberVar(const Scope *scope, const Token *tok);
bool isConstMemberFunc(const Scope *scope, const Token *tok);
bool checkConstFunc(const Scope *scope, const Token *tok);
/** @brief check if this function is virtual in the base classes */
bool isVirtualFunc(const SpaceInfo *info, const Token *functionToken) const;
bool isVirtualFunc(const Scope *scope, const Token *functionToken) const;
// constructors helper function
/** @brief Information about a member variable. Used when checking for uninitialized variables */
@ -189,23 +189,23 @@ private:
bool init;
};
bool isBaseClassFunc(const Token *tok, const SpaceInfo *info);
bool isBaseClassFunc(const Token *tok, const Scope *scope);
/**
* @brief assign a variable in the varlist
* @param varname name of variable to mark assigned
* @param info pointer to variable SpaceInfo
* @param scope pointer to variable Scope
* @param usage reference to usage vector
*/
void assignVar(const std::string &varname, const SpaceInfo *info, std::vector<Usage> &usage);
void assignVar(const std::string &varname, const Scope *scope, std::vector<Usage> &usage);
/**
* @brief initialize a variable in the varlist
* @param varname name of variable to mark initialized
* @param info pointer to variable SpaceInfo
* @param scope pointer to variable Scope
* @param usage reference to usage vector
*/
void initVar(const std::string &varname, const SpaceInfo *info, std::vector<Usage> &usage);
void initVar(const std::string &varname, const Scope *scope, std::vector<Usage> &usage);
/**
* @brief set all variables in list assigned
@ -223,10 +223,10 @@ private:
* @brief parse a scope for a constructor or member function and set the "init" flags in the provided varlist
* @param func reference to the function that should be checked
* @param callstack the function doesn't look into recursive function calls.
* @param info pointer to variable SpaceInfo
* @param scope pointer to variable Scope
* @param usage reference to usage vector
*/
void initializeVarList(const Func &func, std::list<std::string> &callstack, const SpaceInfo *info, std::vector<Usage> &usage);
void initializeVarList(const Function &func, std::list<std::string> &callstack, const Scope *scope, std::vector<Usage> &usage);
};
/// @}
//---------------------------------------------------------------------------

86
lib/checkmemoryleak.cpp
View File

@ -565,19 +565,19 @@ void CheckMemoryLeakInFunction::parse_noreturn()
noreturn.insert("errx");
noreturn.insert("verrx");
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
// only check functions
if (info->type != SpaceInfo::Function)
if (scope->type != Scope::eFunction)
continue;
// parse this function to check if it contains an "exit" call..
unsigned int indentlevel = 1;
for (const Token *tok2 = info->classStart->next(); tok2; tok2 = tok2->next())
for (const Token *tok2 = scope->classStart->next(); tok2; tok2 = tok2->next())
{
if (tok2->str() == "{")
++indentlevel;
@ -589,7 +589,7 @@ void CheckMemoryLeakInFunction::parse_noreturn()
}
if (Token::Match(tok2->previous(), "[;{}] exit ("))
{
noreturn.insert(info->className);
noreturn.insert(scope->className);
break;
}
}
@ -597,7 +597,7 @@ void CheckMemoryLeakInFunction::parse_noreturn()
// This function is not a noreturn function
if (indentlevel == 0)
{
notnoreturn.insert(info->className);
notnoreturn.insert(scope->className);
}
}
}
@ -2491,25 +2491,25 @@ void CheckMemoryLeakInFunction::checkScope(const Token *Tok1, const std::string
//---------------------------------------------------------------------------
void CheckMemoryLeakInFunction::checkReallocUsage()
{
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
// only check functions
if (info->type != SpaceInfo::Function)
if (scope->type != Scope::eFunction)
continue;
// Record the varid's of the function parameters
std::set<unsigned int> parameterVarIds;
for (const Token *tok2 = info->classDef->next(); tok2 && tok2->str() != ")"; tok2 = tok2->next())
for (const Token *tok2 = scope->classDef->next(); tok2 && tok2->str() != ")"; tok2 = tok2->next())
{
if (tok2->varId() != 0)
parameterVarIds.insert(tok2->varId());
}
const Token *tok = info->classStart;
const Token *tok = scope->classStart;
const Token *startOfFunction = tok;
// Search for the "var = realloc(var, 100);" pattern within this function
@ -2644,19 +2644,19 @@ void CheckMemoryLeakInFunction::check()
// fill the "noreturn"
parse_noreturn();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
// only check functions
if (info->type != SpaceInfo::Function)
if (scope->type != Scope::eFunction)
continue;
const Token *tok = info->classStart;
const Token *tok1 = info->classDef->next();
bool classmember = info->functionOf != NULL;
const Token *tok = scope->classStart;
const Token *tok1 = scope->classDef->next();
bool classmember = scope->functionOf != NULL;
parseFunctionScope(tok, tok1, classmember);
}
@ -2701,17 +2701,17 @@ void CheckMemoryLeakInClass::check()
{
const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
// only check classes and structures
if (info->type == SpaceInfo::Class)
if (scope->type == Scope::eClass)
{
std::list<Var>::const_iterator var;
for (var = info->varlist.begin(); var != info->varlist.end(); ++var)
std::list<Variable>::const_iterator var;
for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var)
{
if (!var->isStatic && var->token->previous()->str() == "*")
{
@ -2719,9 +2719,9 @@ void CheckMemoryLeakInClass::check()
if (var->token->tokAt(-2)->isStandardType())
{
if (var->access == Private)
checkPublicFunctions(info, var->token);
checkPublicFunctions(scope, var->token);
variable(info, var->token);
variable(scope, var->token);
}
// known class?
@ -2731,9 +2731,9 @@ void CheckMemoryLeakInClass::check()
if (var->type->derivedFrom.empty() && var->type->numConstructors == 0)
{
if (var->access == Private)
checkPublicFunctions(info, var->token);
checkPublicFunctions(scope, var->token);
variable(info, var->token);
variable(scope, var->token);
}
}
}
@ -2743,10 +2743,10 @@ void CheckMemoryLeakInClass::check()
}
void CheckMemoryLeakInClass::variable(const SpaceInfo *classinfo, const Token *tokVarname)
void CheckMemoryLeakInClass::variable(const Scope *scope, const Token *tokVarname)
{
const std::string varname = tokVarname->strAt(0);
const std::string classname = classinfo->className;
const std::string classname = scope->className;
// Check if member variable has been allocated and deallocated..
CheckMemoryLeak::AllocType Alloc = CheckMemoryLeak::No;
@ -2756,12 +2756,12 @@ void CheckMemoryLeakInClass::variable(const SpaceInfo *classinfo, const Token *t
bool deallocInDestructor = false;
// Inspect member functions
std::list<Func>::const_iterator func;
for (func = classinfo->functionList.begin(); func != classinfo->functionList.end(); ++func)
std::list<Function>::const_iterator func;
for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)
{
const Token *functionToken = func->token;
const bool constructor = func->type == Func::Constructor;
const bool destructor = func->type == Func::Destructor;
const bool constructor = func->type == Function::eConstructor;
const bool destructor = func->type == Function::eDestructor;
unsigned int indent = 0;
bool initlist = false;
for (const Token *tok = functionToken; tok; tok = tok->next())
@ -2795,7 +2795,7 @@ void CheckMemoryLeakInClass::variable(const SpaceInfo *classinfo, const Token *t
// Foo::var1 = ..
// bail out when not same class
if (Token::simpleMatch(tok->previous(), "::") &&
tok->strAt(-2) != classinfo->className)
tok->strAt(-2) != scope->className)
return;
AllocType alloc = getAllocationType(tok->tokAt((indent > 0) ? 2 : 3), 0);
@ -2826,7 +2826,7 @@ void CheckMemoryLeakInClass::variable(const SpaceInfo *classinfo, const Token *t
AllocType dealloc = getDeallocationType(tok, varname);
if (dealloc == No)
{
std::string temp = classinfo->className + " :: " + varname;
std::string temp = scope->className + " :: " + varname;
dealloc = getDeallocationType(tok, temp);
}
if (dealloc == No)
@ -2879,7 +2879,7 @@ void CheckMemoryLeakInClass::variable(const SpaceInfo *classinfo, const Token *t
}
void CheckMemoryLeakInClass::checkPublicFunctions(const SpaceInfo *spaceinfo, const Token *classtok)
void CheckMemoryLeakInClass::checkPublicFunctions(const Scope *scope, const Token *classtok)
{
// Check that public functions deallocate the pointers that they allocate.
// There is no checking how these functions are used and therefore it
@ -2891,11 +2891,11 @@ void CheckMemoryLeakInClass::checkPublicFunctions(const SpaceInfo *spaceinfo, co
// Parse public functions..
// If they allocate member variables, they should also deallocate
std::list<Func>::const_iterator func;
std::list<Function>::const_iterator func;
for (func = spaceinfo->functionList.begin(); func != spaceinfo->functionList.end(); ++func)
for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func)
{
if (func->type != Func::Constructor &&
if (func->type != Function::eConstructor &&
func->access == Public && func->hasBody)
{
const Token *tok2 = func->token;
@ -2908,7 +2908,7 @@ void CheckMemoryLeakInClass::checkPublicFunctions(const SpaceInfo *spaceinfo, co
publicAllocationError(tok2, tok2->strAt(1));
}
else if (Token::Match(tok2, "{|}|; %type% :: %varid% =", varid) &&
tok2->next()->str() == spaceinfo->className)
tok2->next()->str() == scope->className)
{
const CheckMemoryLeak::AllocType alloc = getAllocationType(tok2->tokAt(5), varid);
if (alloc != CheckMemoryLeak::No)
@ -3166,18 +3166,18 @@ void CheckMemoryLeakNoVar::check()
const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
SpaceInfo *info = *i;
Scope *scope = *i;
// only check functions
if (info->type != SpaceInfo::Function)
if (scope->type != Scope::eFunction)
continue;
// goto the "}" that ends the executable scope..
const Token *tok = info->classEnd;
const Token *tok = scope->classEnd;
// parse the executable scope until tok is reached...
for (const Token *tok2 = tok->link(); tok2 && tok2 != tok; tok2 = tok2->next())

4
lib/checkmemoryleak.h
View File

@ -387,10 +387,10 @@ public:
void check();
private:
void variable(const SpaceInfo *spaceinfo, const Token *tokVarname);
void variable(const Scope *scope, const Token *tokVarname);
/** Public functions: possible double-allocation */
void checkPublicFunctions(const SpaceInfo *spaceinfo, const Token *classtok);
void checkPublicFunctions(const Scope *scope, const Token *classtok);
void publicAllocationError(const Token *tok, const std::string &varname);
void getErrorMessages(ErrorLogger * /*errorLogger*/, const Settings * /*settings*/)

76
lib/checkother.cpp
View File

@ -562,27 +562,27 @@ static bool isOp(const Token *tok)
/**
* @brief This class is used to capture the control flow within a function.
*/
class Scope
class ScopeInfo
{
public:
Scope() : _token(NULL), _parent(NULL) { }
Scope(const Token *token, Scope *parent_) : _token(token), _parent(parent_) { }
~Scope();
ScopeInfo() : _token(NULL), _parent(NULL) { }
ScopeInfo(const Token *token, ScopeInfo *parent_) : _token(token), _parent(parent_) { }
~ScopeInfo();
Scope *parent()
ScopeInfo *parent()
{
return _parent;
}
Scope *addChild(const Token *token);
void remove(Scope *scope);
ScopeInfo *addChild(const Token *token);
void remove(ScopeInfo *scope);
private:
const Token *_token;
Scope *_parent;
std::list<Scope *> _children;
ScopeInfo *_parent;
std::list<ScopeInfo *> _children;
};
Scope::~Scope()
ScopeInfo::~ScopeInfo()
{
while (!_children.empty())
{
@ -591,18 +591,18 @@ Scope::~Scope()
}
}
Scope *Scope::addChild(const Token *token)
ScopeInfo *ScopeInfo::addChild(const Token *token)
{
Scope *temp = new Scope(token, this);
ScopeInfo *temp = new ScopeInfo(token, this);
_children.push_back(temp);
return temp;
}
void Scope::remove(Scope *scope)
void ScopeInfo::remove(ScopeInfo *scope)
{
std::list<Scope *>::iterator it;
std::list<ScopeInfo *>::iterator it;
for (it = _children.begin(); it != _children.end(); ++it)
{
@ -629,7 +629,7 @@ public:
public:
VariableUsage(const Token *name = 0,
VariableType type = standard,
Scope *scope = NULL,
ScopeInfo *scope = NULL,
bool read = false,
bool write = false,
bool modified = false,
@ -659,13 +659,13 @@ public:
const Token *_name;
VariableType _type;
Scope *_scope;
ScopeInfo *_scope;
bool _read;
bool _write;
bool _modified; // read/modify/write
bool _allocateMemory;
std::set<unsigned int> _aliases;
std::set<Scope *> _assignments;
std::set<ScopeInfo *> _assignments;
};
typedef std::map<unsigned int, VariableUsage> VariableMap;
@ -678,7 +678,7 @@ public:
{
return _varUsage;
}
void addVar(const Token *name, VariableType type, Scope *scope, bool write_);
void addVar(const Token *name, VariableType type, ScopeInfo *scope, bool write_);
void allocateMemory(unsigned int varid);
void read(unsigned int varid);
void readAliases(unsigned int varid);
@ -797,7 +797,7 @@ void Variables::eraseAll(unsigned int varid)
void Variables::addVar(const Token *name,
VariableType type,
Scope *scope,
ScopeInfo *scope,
bool write_)
{
if (name->varId() > 0)
@ -955,7 +955,7 @@ Variables::VariableUsage *Variables::find(unsigned int varid)
return 0;
}
static int doAssignment(Variables &variables, const Token *tok, bool dereference, Scope *scope)
static int doAssignment(Variables &variables, const Token *tok, bool dereference, ScopeInfo *scope)
{
int next = 0;
@ -1090,7 +1090,7 @@ static int doAssignment(Variables &variables, const Token *tok, bool dereference
// not in same scope as declaration
else
{
std::set<Scope *>::iterator assignment;
std::set<ScopeInfo *>::iterator assignment;
// check for an assignment in this scope
assignment = var1->_assignments.find(scope);
@ -1158,7 +1158,7 @@ static int doAssignment(Variables &variables, const Token *tok, bool dereference
variables.clearAliases(varid1);
else
{
std::set<Scope *>::iterator assignment;
std::set<ScopeInfo *>::iterator assignment;
// check for an assignment in this scope
assignment = var1->_assignments.find(scope);
@ -1240,14 +1240,14 @@ void CheckOther::functionVariableUsage()
// Parse all executing scopes..
const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *info = *i;
// only check functions
if (info->type != SpaceInfo::Function)
if (info->type != Scope::eFunction)
continue;
// First token for the current scope..
@ -1257,8 +1257,8 @@ void CheckOther::functionVariableUsage()
Variables variables;
// scopes
Scope scopes;
Scope *scope = &scopes;
ScopeInfo scopes;
ScopeInfo *scope = &scopes;
unsigned int indentlevel = 0;
for (const Token *tok = tok1; tok; tok = tok->next())
@ -1267,7 +1267,7 @@ void CheckOther::functionVariableUsage()
{
// replace the head node when found
if (indentlevel == 0)
scopes = Scope(tok, NULL);
scopes = ScopeInfo(tok, NULL);
// add the new scope
else
scope = scope->addChild(tok);
@ -1694,7 +1694,7 @@ void CheckOther::functionVariableUsage()
if (!start->tokAt(3)->isStandardType())
{
// lookup the type
const SpaceInfo *type = symbolDatabase->findVarType(info, start->tokAt(3));
const Scope *type = symbolDatabase->findVariableType(info, start->tokAt(3));
// unknown type?
if (!type)
@ -1702,7 +1702,7 @@ void CheckOther::functionVariableUsage()
// has default constructor or
// has members with unknown type or default constructor
else if (type->needInitialization == SpaceInfo::False)
else if (type->needInitialization == Scope::False)
allocate = false;
}
}
@ -1908,19 +1908,19 @@ void CheckOther::checkVariableScope()
const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
// only check functions
if (info->type != SpaceInfo::Function)
if (scope->type != Scope::eFunction)
continue;
// Walk through all tokens..
int indentlevel = 0;
for (const Token *tok = info->classStart; tok; tok = tok->next())
for (const Token *tok = scope->classStart; tok; tok = tok->next())
{
// Skip function local class and struct declarations..
if ((tok->str() == "class") || (tok->str() == "struct") || (tok->str() == "union"))
@ -2536,19 +2536,19 @@ void CheckOther::checkMisusedScopedObject()
const SymbolDatabase * const symbolDatabase = _tokenizer->getSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = symbolDatabase->spaceInfoList.begin(); i != symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
// only check functions
if (info->type != SpaceInfo::Function)
if (scope->type != Scope::eFunction)
continue;
unsigned int depth = 0;
for (const Token *tok = info->classStart; tok; tok = tok->next())
for (const Token *tok = scope->classStart; tok; tok = tok->next())
{
if (tok->str() == "{")
{

168
lib/symboldatabase.cpp
View File

@ -46,14 +46,14 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
}
// find all namespaces (class,struct and namespace)
SpaceInfo *info = new SpaceInfo(this, NULL, NULL);
Scope *info = new Scope(this, NULL, NULL);
spaceInfoList.push_back(info);
for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next())
{
// Locate next class
if (Token::Match(tok, "class|struct|namespace %var% [{:]"))
{
SpaceInfo *new_info = new SpaceInfo(this, tok, info);
Scope *new_info = new Scope(this, tok, info);
const Token *tok2 = tok->tokAt(2);
// only create base list for classes and structures
@ -91,7 +91,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
}
// check if in class or structure
else if (info->type == SpaceInfo::Class || info->type == SpaceInfo::Struct)
else if (info->type == Scope::eClass || info->type == Scope::eStruct)
{
const Token *funcStart = 0;
const Token *argStart = 0;
@ -118,7 +118,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
// class function?
else if (tok->previous()->str() != "::" && isFunction(tok, &funcStart, &argStart))
{
Func function;
Function function;
// save the function definition argument start '('
function.argDef = argStart;
@ -136,20 +136,20 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
// 'operator =' is special
if (function.tokenDef->str() == "=")
function.type = Func::OperatorEqual;
function.type = Function::eOperatorEqual;
}
// class constructor/destructor
else if (function.tokenDef->str() == info->className)
{
if (function.tokenDef->previous()->str() == "~")
function.type = Func::Destructor;
function.type = Function::eDestructor;
else if ((Token::Match(function.tokenDef, "%var% ( const %var% & )") ||
Token::Match(function.tokenDef, "%var% ( const %var% & %var% )")) &&
function.tokenDef->strAt(3) == info->className)
function.type = Func::CopyConstructor;
function.type = Function::eCopyConstructor;
else
function.type = Func::Constructor;
function.type = Function::eConstructor;
if (function.tokenDef->previous()->str() == "explicit")
function.isExplicit = true;
@ -206,7 +206,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
function.isPure = true;
// count the number of constructors
if (function.type == Func::Constructor || function.type == Func::CopyConstructor)
if (function.type == Function::eConstructor || function.type == Function::eCopyConstructor)
info->numConstructors++;
// assume implementation is inline (definition and implementation same)
@ -232,7 +232,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
info->functionList.push_back(function);
const Token *tok2 = funcStart;
SpaceInfo *functionOf = info;
Scope *functionOf = info;
addNewFunction(&info, &tok2);
if (info)
@ -249,7 +249,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
// friend class declaration?
else if (Token::Match(tok, "friend class| %any% ;"))
{
SpaceInfo::FriendInfo friendInfo;
Scope::FriendInfo friendInfo;
friendInfo.name = tok->strAt(1) == "class" ? tok->strAt(2) : tok->strAt(1);
/** @todo fill this in later after parsing is complete */
@ -258,7 +258,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
info->friendList.push_back(friendInfo);
}
}
else if (info->type == SpaceInfo::Namespace || info->type == SpaceInfo::Global)
else if (info->type == Scope::eNamespace || info->type == Scope::eGlobal)
{
const Token *funcStart = 0;
const Token *argStart = 0;
@ -281,7 +281,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
// regular function
else
{
Func function;
Function function;
// save the function definition argument start '('
function.argDef = argStart;
@ -296,9 +296,9 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
function.isInline = false;
function.hasBody = true;
function.arg = function.argDef;
function.type = Func::Function;
function.type = Function::eFunction;
SpaceInfo *old_info = info;
Scope *old_info = info;
addNewFunction(&info, &tok);
@ -319,7 +319,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
Token::Match(argStart->link()->tokAt(2)->link(), ") const| {"))
{
const Token *tok1 = funcStart;
SpaceInfo *old_info = info;
Scope *old_info = info;
// class function
if (tok1->previous()->str() == "::")
@ -340,7 +340,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
}
}
std::list<SpaceInfo *>::iterator it;
std::list<Scope *>::iterator it;
// fill in base class info
for (it = spaceInfoList.begin(); it != spaceInfoList.end(); ++it)
@ -354,22 +354,22 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
// finish filling in base class info
for (unsigned int i = 0; i < info->derivedFrom.size(); ++i)
{
std::list<SpaceInfo *>::iterator it1;
std::list<Scope *>::iterator it1;
for (it1 = spaceInfoList.begin(); it1 != spaceInfoList.end(); ++it1)
{
SpaceInfo *spaceInfo = *it1;
Scope *spaceInfo = *it1;
/** @todo handle derived base classes and namespaces */
if (spaceInfo->type == SpaceInfo::Class || spaceInfo->type == SpaceInfo::Struct)
if (spaceInfo->type == Scope::eClass || spaceInfo->type == Scope::eStruct)
{
// do class names match?
if (spaceInfo->className == info->derivedFrom[i].name)
{
// are they in the same namespace or different namespaces with same name?
if ((spaceInfo->nestedIn == info->nestedIn) ||
((spaceInfo->nestedIn && spaceInfo->nestedIn->type == SpaceInfo::Namespace) &&
(info->nestedIn && info->nestedIn->type == SpaceInfo::Namespace) &&
((spaceInfo->nestedIn && spaceInfo->nestedIn->type == Scope::eNamespace) &&
(info->nestedIn && info->nestedIn->type == Scope::eNamespace) &&
(spaceInfo->nestedIn->className == info->nestedIn->className)))
{
info->derivedFrom[i].spaceInfo = spaceInfo;
@ -387,10 +387,10 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
info = *it;
// skip functions
if (info->type != SpaceInfo::Function)
if (info->type != Scope::eFunction)
{
// find variables
info->getVarList();
info->getVariableList();
}
}
@ -406,16 +406,16 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
{
info = *it;
if (info->isClassOrStruct() && info->needInitialization == SpaceInfo::Unknown)
if (info->isClassOrStruct() && info->needInitialization == Scope::Unknown)
{
// check for default constructor
bool hasDefaultConstructor = false;
std::list<Func>::const_iterator func;
std::list<Function>::const_iterator func;
for (func = info->functionList.begin(); func != info->functionList.end(); ++func)
{
if (func->type == Func::Constructor)
if (func->type == Function::eConstructor)
{
// check for no arguments: func ( )
if (func->argDef->next() == func->argDef->link())
@ -437,7 +437,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
// We assume the default constructor initializes everything.
// Another check will figure out if the constructor actually initializes everything.
if (hasDefaultConstructor)
info->needInitialization = SpaceInfo::False;
info->needInitialization = Scope::False;
// check each member variable to see if it needs initialization
else
@ -445,7 +445,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
bool needInitialization = false;
bool unknown = false;
std::list<Var>::const_iterator var;
std::list<Variable>::const_iterator var;
for (var = info->varlist.begin(); var != info->varlist.end(); ++var)
{
if (var->isClass)
@ -453,9 +453,9 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
if (var->type)
{
// does this type need initialization?
if (var->type->needInitialization == SpaceInfo::True)
if (var->type->needInitialization == Scope::True)
needInitialization = true;
else if (var->type->needInitialization == SpaceInfo::Unknown)
else if (var->type->needInitialization == Scope::Unknown)
unknown = true;
}
}
@ -466,12 +466,12 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
if (!unknown)
{
if (needInitialization)
info->needInitialization = SpaceInfo::True;
info->needInitialization = Scope::True;
else
info->needInitialization = SpaceInfo::False;
info->needInitialization = Scope::False;
}
if (info->needInitialization == SpaceInfo::Unknown)
if (info->needInitialization == Scope::Unknown)
unknowns++;
}
}
@ -488,7 +488,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
{
info = *it;
if (info->isClassOrStruct() && info->needInitialization == SpaceInfo::Unknown)
if (info->isClassOrStruct() && info->needInitialization == Scope::Unknown)
{
std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
ErrorLogger::ErrorMessage::FileLocation loc;
@ -511,7 +511,7 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
SymbolDatabase::~SymbolDatabase()
{
std::list<SpaceInfo *>::iterator it;
std::list<Scope *>::iterator it;
for (it = spaceInfoList.begin(); it != spaceInfoList.end(); ++it)
delete *it;
@ -575,7 +575,7 @@ bool SymbolDatabase::isFunction(const Token *tok, const Token **funcStart, const
return false;
}
bool SymbolDatabase::argsMatch(const SpaceInfo *info, const Token *first, const Token *second, const std::string &path, unsigned int depth) const
bool SymbolDatabase::argsMatch(const Scope *info, const Token *first, const Token *second, const std::string &path, unsigned int depth) const
{
bool match = false;
while (first->str() == second->str())
@ -664,7 +664,7 @@ bool SymbolDatabase::argsMatch(const SpaceInfo *info, const Token *first, const
return match;
}
void SymbolDatabase::addFunction(SpaceInfo **info, const Token **tok, const Token *argStart)
void SymbolDatabase::addFunction(Scope **info, const Token **tok, const Token *argStart)
{
int count = 0;
bool added = false;
@ -693,15 +693,15 @@ void SymbolDatabase::addFunction(SpaceInfo **info, const Token **tok, const Toke
path_length++;
}
std::list<SpaceInfo *>::iterator it1;
std::list<Scope *>::iterator it1;
// search for match
for (it1 = spaceInfoList.begin(); it1 != spaceInfoList.end(); ++it1)
{
SpaceInfo *info1 = *it1;
Scope *info1 = *it1;
bool match = false;
if (info1->className == tok1->str() && (info1->type != SpaceInfo::Function))
if (info1->className == tok1->str() && (info1->type != Scope::eFunction))
{
// do the spaces match (same space) or do their names match (multiple namespaces)
if ((*info == info1->nestedIn) || (*info && info1 &&
@ -709,7 +709,7 @@ void SymbolDatabase::addFunction(SpaceInfo **info, const Token **tok, const Toke
!(*info)->className.empty() &&
(*info)->type == info1->nestedIn->type))
{
SpaceInfo *info2 = info1;
Scope *info2 = info1;
while (info2 && count > 0)
{
@ -728,7 +728,7 @@ void SymbolDatabase::addFunction(SpaceInfo **info, const Token **tok, const Toke
if (match)
{
std::list<Func>::iterator func;
std::list<Function>::iterator func;
for (func = info1->functionList.begin(); func != info1->functionList.end(); ++func)
{
@ -745,7 +745,7 @@ void SymbolDatabase::addFunction(SpaceInfo **info, const Token **tok, const Toke
func->arg = argStart;
}
}
else if (func->type == Func::Destructor &&
else if (func->type == Function::eDestructor &&
(*tok)->previous()->str() == "~" &&
func->tokenDef->str() == (*tok)->str())
{
@ -803,10 +803,10 @@ void SymbolDatabase::addFunction(SpaceInfo **info, const Token **tok, const Toke
addNewFunction(info, tok);
}
void SymbolDatabase::addNewFunction(SpaceInfo **info, const Token **tok)
void SymbolDatabase::addNewFunction(Scope **info, const Token **tok)
{
const Token *tok1 = *tok;
SpaceInfo *new_info = new SpaceInfo(this, tok1, *info);
Scope *new_info = new Scope(this, tok1, *info);
// skip to start of function
while (tok1 && tok1->str() != "{")
@ -837,7 +837,7 @@ void SymbolDatabase::addNewFunction(SpaceInfo **info, const Token **tok)
}
}
const Token *SymbolDatabase::initBaseInfo(SpaceInfo *info, const Token *tok)
const Token *SymbolDatabase::initBaseInfo(Scope *info, const Token *tok)
{
// goto initial '{'
const Token *tok2 = tok->tokAt(2);
@ -853,7 +853,7 @@ const Token *SymbolDatabase::initBaseInfo(SpaceInfo *info, const Token *tok)
// check for base classes
else if (level == 0 && Token::Match(tok2, ":|,"))
{
SpaceInfo::BaseInfo base;
Scope::BaseInfo base;
tok2 = tok2->next();
@ -924,7 +924,7 @@ const Token *SymbolDatabase::initBaseInfo(SpaceInfo *info, const Token *tok)
//---------------------------------------------------------------------------
unsigned int Func::argCount() const
unsigned int Function::argCount() const
{
unsigned int count = 0;
@ -942,7 +942,7 @@ unsigned int Func::argCount() const
return count;
}
unsigned int Func::initializedArgCount() const
unsigned int Function::initializedArgCount() const
{
unsigned int count = 0;
@ -960,48 +960,48 @@ unsigned int Func::initializedArgCount() const
//---------------------------------------------------------------------------
SpaceInfo::SpaceInfo(SymbolDatabase *check_, const Token *classDef_, SpaceInfo *nestedIn_) :
Scope::Scope(SymbolDatabase *check_, const Token *classDef_, Scope *nestedIn_) :
check(check_),
classDef(classDef_),
classStart(NULL),
classEnd(NULL),
nestedIn(nestedIn_),
numConstructors(0),
needInitialization(SpaceInfo::Unknown),
needInitialization(Scope::Unknown),
functionOf(NULL)
{
if (!classDef)
{
type = SpaceInfo::Global;
type = Scope::eGlobal;
access = Public;
}
else if (classDef->str() == "class")
{
type = SpaceInfo::Class;
type = Scope::eClass;
className = classDef->next()->str();
access = Private;
}
else if (classDef->str() == "struct")
{
type = SpaceInfo::Struct;
type = Scope::eStruct;
className = classDef->next()->str();
access = Public;
}
else if (classDef->str() == "union")
{
type = SpaceInfo::Union;
type = Scope::eUnion;
className = classDef->next()->str();
access = Public;
}
else if (classDef->str() == "namespace")
{
type = SpaceInfo::Namespace;
type = Scope::eNamespace;
className = classDef->next()->str();
access = Public;
}
else
{
type = SpaceInfo::Function;
type = Scope::eFunction;
className = classDef->str();
access = Public;
}
@ -1011,15 +1011,15 @@ SpaceInfo::SpaceInfo(SymbolDatabase *check_, const Token *classDef_, SpaceInfo *
}
bool
SpaceInfo::hasDefaultConstructor() const
Scope::hasDefaultConstructor() const
{
if (numConstructors)
{
std::list<Func>::const_iterator func;
std::list<Function>::const_iterator func;
for (func = functionList.begin(); func != functionList.end(); ++func)
{
if (func->type == Func::Constructor &&
if (func->type == Function::eConstructor &&
func->argDef->link() == func->argDef->next())
return true;
}
@ -1028,9 +1028,9 @@ SpaceInfo::hasDefaultConstructor() const
}
// Get variable list..
void SpaceInfo::getVarList()
void Scope::getVariableList()
{
AccessControl varaccess = type == Class ? Private : Public;
AccessControl varaccess = type == eClass ? Private : Public;
const Token *start;
if (classStart)
@ -1184,7 +1184,7 @@ void SpaceInfo::getVarList()
const ErrorLogger::ErrorMessage errmsg(locationList,
Severity::debug,
"SymbolDatabase::SpaceInfo::getVarList found variable \'" + vartok->str() + "\' with varid 0.",
"Scope::getVariableList found variable \'" + vartok->str() + "\' with varid 0.",
"debug");
if (check->_errorLogger)
check->_errorLogger->reportErr(errmsg);
@ -1192,12 +1192,12 @@ void SpaceInfo::getVarList()
Check::reportError(errmsg);
}
const SpaceInfo *spaceInfo = NULL;
const Scope *spaceInfo = NULL;
if (typetok)
spaceInfo = check->findVarType(this, typetok);
spaceInfo = check->findVariableType(this, typetok);
addVar(vartok, varaccess, isMutable, isStatic, isConst, isClass, spaceInfo);
addVariable(vartok, varaccess, isMutable, isStatic, isConst, isClass, spaceInfo);
}
}
}
@ -1230,7 +1230,7 @@ const Token* skipPointers(const Token* tok)
return ret;
}
bool SpaceInfo::isVariableDeclaration(const Token* tok, const Token*& vartok, const Token*& typetok) const
bool Scope::isVariableDeclaration(const Token* tok, const Token*& vartok, const Token*& typetok) const
{
const Token* localTypeTok = skipScopeIdentifiers(tok);
@ -1271,17 +1271,17 @@ bool SpaceInfo::isVariableDeclaration(const Token* tok, const Token*& vartok, co
return NULL != vartok;
}
bool SpaceInfo::isSimpleVariable(const Token* tok) const
bool Scope::isSimpleVariable(const Token* tok) const
{
return Token::Match(tok, "%var% ;");
}
bool SpaceInfo::isArrayVariable(const Token* tok) const
bool Scope::isArrayVariable(const Token* tok) const
{
return Token::Match(tok, "%var% [") && tok->next()->str() != "operator";
}
bool SpaceInfo::findClosingBracket(const Token* tok, const Token*& close) const
bool Scope::findClosingBracket(const Token* tok, const Token*& close) const
{
bool found = false;
if (NULL != tok && tok->str() == "<")
@ -1310,16 +1310,16 @@ bool SpaceInfo::findClosingBracket(const Token* tok, const Token*& close) const
//---------------------------------------------------------------------------
const SpaceInfo *SymbolDatabase::findVarType(const SpaceInfo *start, const Token *type) const
const Scope *SymbolDatabase::findVariableType(const Scope *start, const Token *type) const
{
std::list<SpaceInfo *>::const_iterator it;
std::list<Scope *>::const_iterator it;
for (it = spaceInfoList.begin(); it != spaceInfoList.end(); ++it)
{
const SpaceInfo *info = *it;
const Scope *info = *it;
// skip namespaces and functions
if (info->type == SpaceInfo::Namespace || info->type == SpaceInfo::Function || info->type == SpaceInfo::Global)
if (info->type == Scope::eNamespace || info->type == Scope::eFunction || info->type == Scope::eGlobal)
continue;
// do the names match?
@ -1328,7 +1328,7 @@ const SpaceInfo *SymbolDatabase::findVarType(const SpaceInfo *start, const Token
// check if type does not have a namespace
if (type->previous()->str() != "::")
{
const SpaceInfo *parent = start;
const Scope *parent = start;
// check if in same namespace
while (parent && parent != info->nestedIn)
@ -1352,9 +1352,9 @@ const SpaceInfo *SymbolDatabase::findVarType(const SpaceInfo *start, const Token
//---------------------------------------------------------------------------
SpaceInfo * SpaceInfo::findInNestedList(const std::string & name)
Scope * Scope::findInNestedList(const std::string & name)
{
std::list<SpaceInfo *>::iterator it;
std::list<Scope *>::iterator it;
for (it = nestedList.begin(); it != nestedList.end(); ++it)
{
@ -1366,12 +1366,12 @@ SpaceInfo * SpaceInfo::findInNestedList(const std::string & name)
//---------------------------------------------------------------------------
const Func *SpaceInfo::getDestructor() const
const Function *Scope::getDestructor() const
{
std::list<Func>::const_iterator it;
std::list<Function>::const_iterator it;
for (it = functionList.begin(); it != functionList.end(); ++it)
{
if (it->type == Func::Destructor)
if (it->type == Function::eDestructor)
return &*it;
}
return 0;
@ -1379,13 +1379,13 @@ const Func *SpaceInfo::getDestructor() const
//---------------------------------------------------------------------------
unsigned int SpaceInfo::getNestedNonFunctions() const
unsigned int Scope::getNestedNonFunctions() const
{
unsigned int nested = 0;
std::list<SpaceInfo *>::const_iterator ni;
std::list<Scope *>::const_iterator ni;
for (ni = nestedList.begin(); ni != nestedList.end(); ++ni)
{
if ((*ni)->type != SpaceInfo::Function)
if ((*ni)->type != Scope::eFunction)
nested++;
}
return nested;

67
lib/symboldatabase.h
View File

@ -31,7 +31,7 @@ class Tokenizer;
class Settings;
class ErrorLogger;
class SpaceInfo;
class Scope;
class SymbolDatabase;
/**
@ -40,10 +40,10 @@ class SymbolDatabase;
enum AccessControl { Public, Protected, Private };
/** @brief Information about a member variable. */
class Var
class Variable
{
public:
Var(const Token *token_, std::size_t index_, AccessControl access_, bool mutable_, bool static_, bool const_, bool class_, const SpaceInfo *type_)
Variable(const Token *token_, std::size_t index_, AccessControl access_, bool mutable_, bool static_, bool const_, bool class_, const Scope *type_)
: token(token_),
index(index_),
access(access_),
@ -77,15 +77,15 @@ public:
bool isClass;
/** @brief pointer to user defined type info (for known types) */
const SpaceInfo *type;
const Scope *type;
};
class Func
class Function
{
public:
enum Type { Constructor, CopyConstructor, OperatorEqual, Destructor, Function };
enum Type { eConstructor, eCopyConstructor, eOperatorEqual, eDestructor, eFunction };
Func()
Function()
: tokenDef(NULL),
argDef(NULL),
token(NULL),
@ -101,7 +101,7 @@ public:
isExplicit(false),
isOperator(false),
retFuncPtr(false),
type(Function)
type(eFunction)
{
}
@ -126,26 +126,29 @@ public:
Type type; // constructor, destructor, ...
};
class SpaceInfo
class Scope
{
// let tests access private function for testing
friend class TestSymbolDatabase;
public:
struct BaseInfo
{
AccessControl access; // public/protected/private
std::string name;
SpaceInfo *spaceInfo;
Scope *spaceInfo;
};
struct FriendInfo
{
std::string name;
SpaceInfo *spaceInfo;
Scope *spaceInfo;
};
enum SpaceType { Global, Class, Struct, Union, Namespace, Function };
enum SpaceType { eGlobal, eClass, eStruct, eUnion, eNamespace, eFunction };
enum NeedInitialization { Unknown, True, False };
SpaceInfo(SymbolDatabase *check_, const Token *classDef_, SpaceInfo *nestedIn_);
Scope(SymbolDatabase *check_, const Token *classDef_, Scope *nestedIn_);
SymbolDatabase *check;
SpaceType type;
@ -153,37 +156,37 @@ public:
const Token *classDef; // class/struct/union/namespace token
const Token *classStart; // '{' token
const Token *classEnd; // '}' token
std::list<Func> functionList;
std::list<Var> varlist;
std::list<Function> functionList;
std::list<Variable> varlist;
std::vector<BaseInfo> derivedFrom;
std::list<FriendInfo> friendList;
SpaceInfo *nestedIn;
std::list<SpaceInfo *> nestedList;
Scope *nestedIn;
std::list<Scope *> nestedList;
AccessControl access;
unsigned int numConstructors;
NeedInitialization needInitialization;
SpaceInfo * functionOf; // class/struct this function belongs to
Scope * functionOf; // class/struct this function belongs to
bool isClassOrStruct() const
{
return (type == Class || type == Struct);
return (type == eClass || type == eStruct);
}
/**
* @brief find if name is in nested list
* @param name name of nested space
*/
SpaceInfo * findInNestedList(const std::string & name);
Scope * findInNestedList(const std::string & name);
void addVar(const Token *token_, AccessControl access_, bool mutable_, bool static_, bool const_, bool class_, const SpaceInfo *type_)
void addVariable(const Token *token_, AccessControl access_, bool mutable_, bool static_, bool const_, bool class_, const Scope *type_)
{
varlist.push_back(Var(token_, varlist.size(), access_, mutable_, static_, const_, class_, type_));
varlist.push_back(Variable(token_, varlist.size(), access_, mutable_, static_, const_, class_, type_));
}
/** @brief initialize varlist */
void getVarList();
void getVariableList();
const Func *getDestructor() const;
const Function *getDestructor() const;
/**
* @brief get the number of nested spaces that are not functions
@ -197,7 +200,7 @@ public:
private:
/**
* @brief helper function for getVarList()
* @brief helper function for getVariableList()
* @param tok pointer to token to check
* @param vartok populated with pointer to the variable token, if found
* @param typetok populated with pointer to the type token, if found
@ -216,7 +219,7 @@ public:
~SymbolDatabase();
/** @brief Information about all namespaces/classes/structrues */
std::list<SpaceInfo *> spaceInfoList;
std::list<Scope *> spaceInfoList;
/**
* @brief find a variable type if it's a user defined type
@ -224,9 +227,9 @@ public:
* @param type token containing variable type
* @return pointer to type if found or NULL if not found
*/
const SpaceInfo *findVarType(const SpaceInfo *start, const Token *type) const;
const Scope *findVariableType(const Scope *start, const Token *type) const;
bool argsMatch(const SpaceInfo *info, const Token *first, const Token *second, const std::string &path, unsigned int depth) const;
bool argsMatch(const Scope *info, const Token *first, const Token *second, const std::string &path, unsigned int depth) const;
bool isClassOrStruct(const std::string &type) const
{
@ -236,11 +239,11 @@ public:
private:
// Needed by Borland C++:
friend class SpaceInfo;
friend class Scope;
void addFunction(SpaceInfo **info, const Token **tok, const Token *argStart);
void addNewFunction(SpaceInfo **info, const Token **tok);
const Token *initBaseInfo(SpaceInfo *info, const Token *tok);
void addFunction(Scope **info, const Token **tok, const Token *argStart);
void addNewFunction(Scope **info, const Token **tok);
const Token *initBaseInfo(Scope *info, const Token *tok);
bool isFunction(const Token *tok, const Token **funcStart, const Token **argStart) const;
/** class/struct types */

10
lib/tokenize.cpp
View File

@ -7954,16 +7954,16 @@ const Token *Tokenizer::getFunctionTokenByName(const char funcname[]) const
if (_symbolDatabase == NULL)
getSymbolDatabase();
std::list<SpaceInfo *>::const_iterator i;
std::list<Scope *>::const_iterator i;
for (i = _symbolDatabase->spaceInfoList.begin(); i != _symbolDatabase->spaceInfoList.end(); ++i)
{
const SpaceInfo *info = *i;
const Scope *scope = *i;
if (info->type == SpaceInfo::Function)
if (scope->type == Scope::eFunction)
{
if (info->classDef->str() == funcname)
return info->classDef;
if (scope->classDef->str() == funcname)
return scope->classDef;
}
}
return NULL;

3
test/testsymboldatabase.cpp
View File

@ -18,7 +18,6 @@
#include "testsuite.h"
#include "testutils.h"
#define private public
#include "symboldatabase.h"
class TestSymbolDatabase: public TestFixture
@ -32,7 +31,7 @@ public:
{}
private:
const SpaceInfo si;
const Scope si;
const Token* vartok;
const Token* typetok;
const Token* t;