Skip to content

Commit 2b61c9e

Browse files
firewavefirewave
authored
Tokenizer: moved VariableMap into anonymous namespace (#5686)
1 parent f5630e7 commit 2b61c9e

5 files changed

Lines changed: 69 additions & 92 deletions

File tree

‎lib/symboldatabase.cpp‎

Lines changed: 9 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -206,7 +206,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
206206
// skip variable declaration
207207
else if (Token::Match(tok2, "*|&|>"))
208208
continue;
209-
else if (Token::Match(tok2, "%name% (") && mTokenizer.isFunctionHead(tok2->next(), "{;"))
209+
else if (Token::Match(tok2, "%name% (") && Tokenizer::isFunctionHead(tok2->next(), "{;"))
210210
continue;
211211
else if (Token::Match(tok2, "%name% [|="))
212212
continue;
@@ -531,7 +531,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
531531
// class function?
532532
else if (isFunction(tok, scope, &funcStart, &argStart, &declEnd)) {
533533
if (tok->previous()->str() != "::" || tok->strAt(-2) == scope->className) {
534-
Function function(&mTokenizer, tok, scope, funcStart, argStart);
534+
Function function(tok, scope, funcStart, argStart);
535535

536536
// save the access type
537537
function.access = access[scope];
@@ -547,7 +547,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
547547
function.arg = function.argDef;
548548

549549
// out of line function
550-
if (const Token *endTok = mTokenizer.isFunctionHead(end, ";")) {
550+
if (const Token *endTok = Tokenizer::isFunctionHead(end, ";")) {
551551
tok = endTok;
552552
scope->addFunction(function);
553553
}
@@ -1864,7 +1864,7 @@ bool SymbolDatabase::isFunction(const Token *tok, const Scope* outerScope, const
18641864
const Token* tok1 = tok->previous();
18651865
const Token* tok2 = tok->next()->link()->next();
18661866

1867-
if (!mTokenizer.isFunctionHead(tok->next(), ";:{"))
1867+
if (!Tokenizer::isFunctionHead(tok->next(), ";:{"))
18681868
return false;
18691869

18701870
// skip over destructor "~"
@@ -2418,8 +2418,7 @@ static bool isOperator(const Token *tokenDef)
24182418
return name.size() > 8 && startsWith(name,"operator") && std::strchr("+-*/%&|~^<>!=[(", name[8]);
24192419
}
24202420

2421-
Function::Function(const Tokenizer *mTokenizer,
2422-
const Token *tok,
2421+
Function::Function(const Token *tok,
24232422
const Scope *scope,
24242423
const Token *tokDef,
24252424
const Token *tokArgDef)
@@ -2520,7 +2519,7 @@ Function::Function(const Tokenizer *mTokenizer,
25202519
tok = tok->next();
25212520
}
25222521

2523-
if (mTokenizer->isFunctionHead(end, ":{")) {
2522+
if (Tokenizer::isFunctionHead(end, ":{")) {
25242523
// assume implementation is inline (definition and implementation same)
25252524
token = tokenDef;
25262525
arg = argDef;
@@ -3168,7 +3167,7 @@ Function* SymbolDatabase::addGlobalFunction(Scope*& scope, const Token*& tok, co
31683167

31693168
Function* SymbolDatabase::addGlobalFunctionDecl(Scope*& scope, const Token *tok, const Token *argStart, const Token* funcStart)
31703169
{
3171-
Function function(&mTokenizer, tok, scope, funcStart, argStart);
3170+
Function function(tok, scope, funcStart, argStart);
31723171
scope->addFunction(std::move(function));
31733172
return &scope->functionList.back();
31743173
}
@@ -3232,7 +3231,7 @@ void SymbolDatabase::addClassFunction(Scope **scope, const Token **tok, const To
32323231
if (!func->hasBody()) {
32333232
const Token *closeParen = (*tok)->next()->link();
32343233
if (closeParen) {
3235-
const Token *eq = mTokenizer.isFunctionHead(closeParen, ";");
3234+
const Token *eq = Tokenizer::isFunctionHead(closeParen, ";");
32363235
if (eq && Token::simpleMatch(eq->tokAt(-2), "= default ;")) {
32373236
func->isDefault(true);
32383237
return;
@@ -3305,7 +3304,7 @@ void SymbolDatabase::addClassFunction(Scope **scope, const Token **tok, const To
33053304
if (func->argsMatch(scope1, func->argDef, (*tok)->next(), path, path_length)) {
33063305
const Token *closeParen = (*tok)->next()->link();
33073306
if (closeParen) {
3308-
const Token *eq = mTokenizer.isFunctionHead(closeParen, ";");
3307+
const Token *eq = Tokenizer::isFunctionHead(closeParen, ";");
33093308
if (eq && Token::simpleMatch(eq->tokAt(-2), "= default ;")) {
33103309
func->isDefault(true);
33113310
return;

‎lib/symboldatabase.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -749,7 +749,7 @@ class CPPCHECKLIB Function {
749749
public:
750750
enum Type { eConstructor, eCopyConstructor, eMoveConstructor, eOperatorEqual, eDestructor, eFunction, eLambda };
751751

752-
Function(const Tokenizer *mTokenizer, const Token *tok, const Scope *scope, const Token *tokDef, const Token *tokArgDef);
752+
Function(const Token *tok, const Scope *scope, const Token *tokDef, const Token *tokArgDef);
753753
Function(const Token *tokenDef, const std::string &clangType);
754754

755755
const std::string &name() const {
@@ -1438,7 +1438,7 @@ class CPPCHECKLIB SymbolDatabase {
14381438
void debugSymbolDatabase() const;
14391439

14401440
void addClassFunction(Scope **scope, const Token **tok, const Token *argStart);
1441-
Function *addGlobalFunctionDecl(Scope*& scope, const Token* tok, const Token *argStart, const Token* funcStart);
1441+
static Function *addGlobalFunctionDecl(Scope*& scope, const Token* tok, const Token *argStart, const Token* funcStart);
14421442
Function *addGlobalFunction(Scope*& scope, const Token*& tok, const Token *argStart, const Token* funcStart);
14431443
void addNewFunction(Scope **scope, const Token **tok);
14441444
bool isFunction(const Token *tok, const Scope* outerScope, const Token **funcStart, const Token **argStart, const Token** declEnd) const;

‎lib/templatesimplifier.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1422,14 +1422,14 @@ bool TemplateSimplifier::getTemplateNamePositionTemplateFunction(const Token *to
14221422
} else if (Token::Match(tok->next(), "%type% <")) {
14231423
const Token *closing = tok->tokAt(2)->findClosingBracket();
14241424
if (closing) {
1425-
if (closing->strAt(1) == "(" && Tokenizer::isFunctionHead(closing->next(), ";|{|:", true))
1425+
if (closing->strAt(1) == "(" && Tokenizer::isFunctionHead(closing->next(), ";|{|:"))
14261426
return true;
14271427
while (tok->next() && tok->next() != closing) {
14281428
tok = tok->next();
14291429
namepos++;
14301430
}
14311431
}
1432-
} else if (Token::Match(tok->next(), "%type% (") && Tokenizer::isFunctionHead(tok->tokAt(2), ";|{|:", true)) {
1432+
} else if (Token::Match(tok->next(), "%type% (") && Tokenizer::isFunctionHead(tok->tokAt(2), ";|{|:")) {
14331433
return true;
14341434
}
14351435
tok = tok->next();
@@ -1934,7 +1934,7 @@ void TemplateSimplifier::expandTemplate(
19341934
const Token *tok4 = tok3->next()->findClosingBracket();
19351935
while (tok4 && tok4->str() != "(")
19361936
tok4 = tok4->next();
1937-
if (!Tokenizer::isFunctionHead(tok4, ":{", true))
1937+
if (!Tokenizer::isFunctionHead(tok4, ":{"))
19381938
continue;
19391939
// find function return type start
19401940
tok5 = tok5->next()->findClosingBracket();

‎lib/tokenize.cpp‎

Lines changed: 46 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -93,12 +93,7 @@ static void skipEnumBody(T **tok)
9393
*tok = defStart->link()->next();
9494
}
9595

96-
const Token * Tokenizer::isFunctionHead(const Token *tok, const std::string &endsWith) const
97-
{
98-
return Tokenizer::isFunctionHead(tok, endsWith, isCPP());
99-
}
100-
101-
const Token * Tokenizer::isFunctionHead(const Token *tok, const std::string &endsWith, bool cpp)
96+
const Token * Tokenizer::isFunctionHead(const Token *tok, const std::string &endsWith)
10297
{
10398
if (!tok)
10499
return nullptr;
@@ -113,7 +108,7 @@ const Token * Tokenizer::isFunctionHead(const Token *tok, const std::string &end
113108
}
114109
return (tok && endsWith.find(tok->str()) != std::string::npos) ? tok : nullptr;
115110
}
116-
if (cpp && tok->str() == ")") {
111+
if (tok->isCpp() && tok->str() == ")") {
117112
tok = tok->next();
118113
while (Token::Match(tok, "const|noexcept|override|final|volatile|mutable|&|&& !!(") ||
119114
(Token::Match(tok, "%name% !!(") && tok->isUpperCaseName()))
@@ -2791,7 +2786,7 @@ namespace {
27912786
}
27922787
} // namespace
27932788

2794-
bool Tokenizer::isMemberFunction(const Token *openParen) const
2789+
bool Tokenizer::isMemberFunction(const Token *openParen)
27952790
{
27962791
return (Token::Match(openParen->tokAt(-2), ":: %name% (") ||
27972792
Token::Match(openParen->tokAt(-3), ":: ~ %name% (")) &&
@@ -3901,7 +3896,7 @@ const Token * Tokenizer::startOfExecutableScope(const Token * tok)
39013896
if (tok->str() != ")")
39023897
return nullptr;
39033898

3904-
tok = isFunctionHead(tok, ":{", true);
3899+
tok = Tokenizer::isFunctionHead(tok, ":{");
39053900

39063901
if (Token::Match(tok, ": %name% [({]")) {
39073902
while (Token::Match(tok, "[:,] %name% [({]"))
@@ -4088,32 +4083,31 @@ void Tokenizer::simplifyTemplates()
40884083
//---------------------------------------------------------------------------
40894084

40904085

4091-
/** Class used in Tokenizer::setVarIdPass1 */
4092-
class VariableMap {
4093-
private:
4094-
std::unordered_map<std::string, nonneg int> mVariableId;
4095-
std::unordered_map<std::string, nonneg int> mVariableId_global;
4096-
std::stack<std::vector<std::pair<std::string, nonneg int>>> mScopeInfo;
4097-
mutable nonneg int mVarId{};
4098-
public:
4099-
VariableMap() = default;
4100-
void enterScope();
4101-
bool leaveScope();
4102-
void addVariable(const std::string& varname, bool globalNamespace);
4103-
bool hasVariable(const std::string& varname) const {
4104-
return mVariableId.find(varname) != mVariableId.end();
4105-
}
4086+
namespace {
4087+
/** Class used in Tokenizer::setVarIdPass1 */
4088+
class VariableMap {
4089+
private:
4090+
std::unordered_map<std::string, nonneg int> mVariableId;
4091+
std::unordered_map<std::string, nonneg int> mVariableId_global;
4092+
std::stack<std::vector<std::pair<std::string, nonneg int>>> mScopeInfo;
4093+
mutable nonneg int mVarId{};
4094+
public:
4095+
VariableMap() = default;
4096+
void enterScope();
4097+
bool leaveScope();
4098+
void addVariable(const std::string& varname, bool globalNamespace);
4099+
bool hasVariable(const std::string& varname) const {
4100+
return mVariableId.find(varname) != mVariableId.end();
4101+
}
41064102

4107-
const std::unordered_map<std::string, nonneg int>& map(bool global) const {
4108-
return global ? mVariableId_global : mVariableId;
4109-
}
4110-
nonneg int getVarId() const {
4111-
return mVarId;
4112-
}
4113-
nonneg int& getVarId() {
4114-
return mVarId;
4115-
}
4116-
};
4103+
const std::unordered_map<std::string, nonneg int>& map(bool global) const {
4104+
return global ? mVariableId_global : mVariableId;
4105+
}
4106+
nonneg int& getVarId() {
4107+
return mVarId;
4108+
}
4109+
};
4110+
}
41174111

41184112

41194113
void VariableMap::enterScope()
@@ -4298,9 +4292,9 @@ static bool setVarIdParseDeclaration(Token** tok, const VariableMap& variableMap
42984292
}
42994293

43004294

4301-
void Tokenizer::setVarIdStructMembers(Token **tok1,
4302-
std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers,
4303-
nonneg int &varId) const
4295+
static void setVarIdStructMembers(Token **tok1,
4296+
std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers,
4297+
nonneg int &varId)
43044298
{
43054299
Token *tok = *tok1;
43064300

@@ -4334,7 +4328,7 @@ void Tokenizer::setVarIdStructMembers(Token **tok1,
43344328
while (Token::Match(tok->next(), ")| . %name% !!(")) {
43354329
// Don't set varid for trailing return type
43364330
if (tok->strAt(1) == ")" && (tok->linkAt(1)->previous()->isName() || tok->linkAt(1)->strAt(-1) == "]") &&
4337-
isFunctionHead(tok->linkAt(1), "{|;")) {
4331+
Tokenizer::isFunctionHead(tok->linkAt(1), "{|;")) {
43384332
tok = tok->tokAt(3);
43394333
continue;
43404334
}
@@ -4363,10 +4357,10 @@ void Tokenizer::setVarIdStructMembers(Token **tok1,
43634357
*tok1 = tok;
43644358
}
43654359

4366-
void Tokenizer::setVarIdClassDeclaration(Token* const startToken,
4367-
VariableMap& variableMap,
4368-
const nonneg int scopeStartVarId,
4369-
std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers)
4360+
static bool setVarIdClassDeclaration(Token* const startToken,
4361+
VariableMap& variableMap,
4362+
const nonneg int scopeStartVarId,
4363+
std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers)
43704364
{
43714365
// end of scope
43724366
const Token* const endToken = startToken->link();
@@ -4389,7 +4383,7 @@ void Tokenizer::setVarIdClassDeclaration(Token* const startToken,
43894383
const Token *initListArgLastToken = nullptr;
43904384
for (Token *tok = startToken->next(); tok != endToken; tok = tok->next()) {
43914385
if (!tok)
4392-
syntaxError(nullptr);
4386+
return false;
43934387
if (initList) {
43944388
if (tok == initListArgLastToken)
43954389
initListArgLastToken = nullptr;
@@ -4416,7 +4410,7 @@ void Tokenizer::setVarIdClassDeclaration(Token* const startToken,
44164410
if (Token::Match(tok->previous(), "::|.") && tok->strAt(-2) != "this" && !Token::simpleMatch(tok->tokAt(-5), "( * this ) ."))
44174411
continue;
44184412
if (!tok->next())
4419-
syntaxError(nullptr);
4413+
return false;
44204414
if (tok->next()->str() == "::") {
44214415
if (tok->str() == className)
44224416
tok = tok->tokAt(2);
@@ -4435,6 +4429,7 @@ void Tokenizer::setVarIdClassDeclaration(Token* const startToken,
44354429
} else if (indentlevel == 0 && tok->str() == ":" && !initListArgLastToken)
44364430
initList = true;
44374431
}
4432+
return true;
44384433
}
44394434

44404435

@@ -4602,10 +4597,12 @@ void Tokenizer::setVarIdPass1()
46024597
}
46034598
// Set variable ids in class declaration..
46044599
if (!initlist && !isC() && !scopeStack.top().isExecutable && tok->link() && !isNamespace) {
4605-
setVarIdClassDeclaration(tok->link(),
4606-
variableMap,
4607-
scopeStack.top().startVarid,
4608-
structMembers);
4600+
if (!setVarIdClassDeclaration(tok->link(),
4601+
variableMap,
4602+
scopeStack.top().startVarid,
4603+
structMembers)) {
4604+
syntaxError(nullptr);
4605+
}
46094606
}
46104607

46114608
if (!scopeStack.top().isStructInit) {
@@ -9883,7 +9880,7 @@ void Tokenizer::createSymbolDatabase()
98839880
mSymbolDatabase->validate();
98849881
}
98859882

9886-
bool Tokenizer::operatorEnd(const Token * tok) const
9883+
bool Tokenizer::operatorEnd(const Token * tok)
98879884
{
98889885
if (tok && tok->str() == ")") {
98899886
if (isFunctionHead(tok, "{|;|?|:|["))

‎lib/tokenize.h‎

Lines changed: 9 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,6 @@ class Token;
3838
class TemplateSimplifier;
3939
class ErrorLogger;
4040
class Preprocessor;
41-
class VariableMap;
4241
enum class Severity;
4342

4443
namespace simplecpp {
@@ -269,7 +268,7 @@ class CPPCHECKLIB Tokenizer {
269268

270269
/**
271270
*/
272-
bool isMemberFunction(const Token *openParen) const;
271+
static bool isMemberFunction(const Token *openParen);
273272

274273
/**
275274
*/
@@ -366,16 +365,7 @@ class CPPCHECKLIB Tokenizer {
366365
* @param endsWith string after function head
367366
* @return token matching with endsWith if syntax seems to be a function head else nullptr
368367
*/
369-
const Token * isFunctionHead(const Token *tok, const std::string &endsWith) const;
370-
371-
/**
372-
* is token pointing at function head?
373-
* @param tok A '(' or ')' token in a possible function head
374-
* @param endsWith string after function head
375-
* @param cpp c++ code
376-
* @return token matching with endsWith if syntax seems to be a function head else nullptr
377-
*/
378-
static const Token * isFunctionHead(const Token *tok, const std::string &endsWith, bool cpp);
368+
static const Token * isFunctionHead(const Token *tok, const std::string &endsWith);
379369

380370
const Preprocessor *getPreprocessor() const {
381371
assert(mPreprocessor);
@@ -580,21 +570,12 @@ class CPPCHECKLIB Tokenizer {
580570

581571
void unsupportedTypedef(const Token *tok) const;
582572

583-
void setVarIdClassDeclaration(Token* const startToken, // cppcheck-suppress functionConst // has side effects
584-
VariableMap& variableMap,
585-
const nonneg int scopeStartVarId,
586-
std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers);
587-
588-
void setVarIdStructMembers(Token **tok1,
589-
std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers,
590-
nonneg int &varId) const;
591-
592-
void setVarIdClassFunction(const std::string &classname, // cppcheck-suppress functionConst // has side effects
593-
Token * const startToken,
594-
const Token * const endToken,
595-
const std::map<std::string, nonneg int> &varlist,
596-
std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers,
597-
nonneg int &varId_);
573+
static void setVarIdClassFunction(const std::string &classname,
574+
Token * const startToken,
575+
const Token * const endToken,
576+
const std::map<std::string, nonneg int> &varlist,
577+
std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers,
578+
nonneg int &varId_);
598579

599580
/**
600581
* Output list of unknown types.
@@ -604,7 +585,7 @@ class CPPCHECKLIB Tokenizer {
604585
/** Find end of SQL (or PL/SQL) block */
605586
static const Token *findSQLBlockEnd(const Token *tokSQLStart);
606587

607-
bool operatorEnd(const Token * tok) const;
588+
static bool operatorEnd(const Token * tok);
608589

609590
public:
610591
const SymbolDatabase *getSymbolDatabase() const {

0 commit comments

Comments
 (0)