{

const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();

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

for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {

if (!Token::simpleMatch(tok, "Token :: Match (") && !Token::simpleMatch(tok, "Token :: findmatch ("))

continue;

const std::string& funcname = tok->strAt(2);

// Get pattern string

const Token *patternTok = tok->tokAt(4)->nextArgument();

if (!patternTok || patternTok->tokType() != Token::eString)

continue;

const std::string pattern = patternTok->strValue();

if (pattern.empty()) {

simplePatternError(tok, pattern, funcname);

continue;

}

if (pattern.find("||") != std::string::npos || pattern.find(" | ") != std::string::npos || pattern[0] == '|' || (pattern[pattern.length() - 1] == '|' && pattern[pattern.length() - 2] == ' '))

orInComplexPattern(tok, pattern, funcname);

// Check for signs of complex patterns

if (pattern.find_first_of("[|") != std::string::npos)

continue;

else if (pattern.find("!!") != std::string::npos)

continue;

bool complex = false;

size_t index = pattern.find('%');

while (index != std::string::npos) {

if (pattern.length() <= index + 2) {

complex = true;

break;

}

if (pattern[index + 1] == 'o' && pattern[index + 2] == 'r') // %or% or %oror%

index = pattern.find('%', index + 1);

else {

complex = true;

break;

}

index = pattern.find('%', index + 1);

}

if (!complex)

simplePatternError(tok, pattern, funcname);

}

}

{

for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {

if (Token::Match(tok, "&& Token :: simpleMatch|Match|findsimplematch|findmatch (")) {

// in code like

// if (tok->previous() && Token::match(tok->previous(), "bla")) {}

// the first tok->previous() check is redundant

const Token *astOp1 = tok->astOperand1();

const Token *astOp2 = getArguments(tok->tokAt(3))[0];

if (Token::simpleMatch(astOp1, "&&")) {

astOp1 = astOp1->astOperand2();

}

if (astOp1->expressionString() == astOp2->expressionString()) {

checkRedundantTokCheckError(astOp2);

}

// if (!tok || !Token::match(tok, "foo"))

} else if (Token::Match(tok, "%oror% ! Token :: simpleMatch|Match|findsimplematch|findmatch (")) {

const Token *negTok = tok->next()->astParent()->astOperand1();

if (Token::simpleMatch(negTok, "||")) {

negTok = negTok->astOperand2();

}

// the first tok condition is negated

if (Token::simpleMatch(negTok, "!")) {

const Token *astOp1 = negTok->astOperand1();

const Token *astOp2 = getArguments(tok->tokAt(4))[0];

if (astOp1->expressionString() == astOp2->expressionString()) {

checkRedundantTokCheckError(astOp2);

}

}

}

}

{

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

"Unnecessary check of \"" + (tok? tok->expressionString(): emptyString) + "\", match-function already checks if it is null.");

{

const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();

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

for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {

if (!Token::simpleMatch(tok, "Token :: simpleMatch (") && !Token::simpleMatch(tok, "Token :: findsimplematch ("))

continue;

const std::string& funcname = tok->strAt(2);

// Get pattern string

const Token *patternTok = tok->tokAt(4)->nextArgument();

if (!patternTok || patternTok->tokType() != Token::eString)

continue;

const std::string pattern = patternTok->strValue();

if (pattern.empty()) {

complexPatternError(tok, pattern, funcname);

continue;

}

// Check for [xyz] usage - but exclude standalone square brackets

unsigned int char_count = 0;

for (char c : pattern) {

if (c == ' ') {

char_count = 0;

} else if (c == ']') {

if (char_count > 0) {

complexPatternError(tok, pattern, funcname);

continue;

}

} else {

++char_count;

}

}

// Check | usage: Count characters before the symbol

char_count = 0;

for (char c : pattern) {

if (c == ' ') {

char_count = 0;

} else if (c == '|') {

if (char_count > 0) {

complexPatternError(tok, pattern, funcname);

continue;

}

} else {

++char_count;

}

}

// Check for real errors

if (pattern.length() > 1) {

for (size_t j = 0; j < pattern.length() - 1; j++) {

if (pattern[j] == '%' && pattern[j + 1] != ' ')

complexPatternError(tok, pattern, funcname);

else if (pattern[j] == '!' && pattern[j + 1] == '!')

complexPatternError(tok, pattern, funcname);

}

}

}

}

{

const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();

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

for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {

if (!Token::simpleMatch(tok, "Token :: Match (") && !Token::simpleMatch(tok, "Token :: findmatch ("))

continue;

const std::string& funcname = tok->strAt(2);

// Get pattern string

const Token *patternTok = tok->tokAt(4)->nextArgument();

if (!patternTok || patternTok->tokType() != Token::eString)

continue;

const std::string pattern = patternTok->strValue();

std::set<std::string>::const_iterator knownPattern, knownPatternsEnd = knownPatterns.end();

for (knownPattern = knownPatterns.begin(); knownPattern != knownPatternsEnd; ++knownPattern) {

const std::string brokenPattern = (*knownPattern).substr(0, (*knownPattern).size() - 1);

std::string::size_type pos = 0;

while ((pos = pattern.find(brokenPattern, pos)) != std::string::npos) {

// Check if it's the full pattern

if (pattern.find(*knownPattern, pos) != pos) {

// Known whitelist of substrings

if ((brokenPattern == "%var" && pattern.find("%varid%", pos) == pos) ||

(brokenPattern == "%or" && pattern.find("%oror%", pos) == pos)) {

++pos;

continue;

}

missingPercentCharacterError(tok, pattern, funcname);

}

++pos;

}

}

}

}

{

const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();

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

for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {

if (!Token::simpleMatch(tok, "Token :: Match (") && !Token::simpleMatch(tok, "Token :: findmatch ("))

continue;

// Get pattern string

const Token *patternTok = tok->tokAt(4)->nextArgument();

if (!patternTok || patternTok->tokType() != Token::eString)

continue;

const std::string pattern = patternTok->strValue();

bool inBrackets = false;

for (std::string::size_type j = 0; j < pattern.length() - 1; j++) {

if (pattern[j] == '[' && (j == 0 || pattern[j - 1] == ' '))

inBrackets = true;

else if (pattern[j] == ']')

inBrackets = false;

else if (pattern[j] == '%' && pattern[j + 1] != ' ' && pattern[j + 1] != '|' && !inBrackets) {

const std::string::size_type end = pattern.find('%', j + 1);

if (end != std::string::npos) {

const std::string s = pattern.substr(j, end - j + 1);

if (knownPatterns.find(s) == knownPatterns.end())

unknownPatternError(tok, s);

}

}

}

}

}

{

const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();

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

for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {

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

continue;

tok = tok->next();

if (Token::Match(tok, "previous ( ) . next|tokAt|strAt|linkAt (") || Token::Match(tok, "next ( ) . previous|tokAt|strAt|linkAt (") ||

(Token::simpleMatch(tok, "tokAt (") && Token::Match(tok->linkAt(1), ") . previous|next|tokAt|strAt|linkAt|str|link ("))) {

const std::string& func1 = tok->str();

const std::string& func2 = tok->linkAt(1)->strAt(2);

if ((func2 == "previous" || func2 == "next" || func2 == "str" || func2 == "link") && tok->linkAt(1)->strAt(4) != ")")

continue;

redundantNextPreviousError(tok, func1, func2);

} else if (Token::Match(tok, "next|previous ( ) . next|previous ( ) . next|previous|linkAt|strAt|link|str (")) {

const std::string& func1 = tok->str();

const std::string& func2 = tok->strAt(8);

if ((func2 == "previous" || func2 == "next" || func2 == "str" || func2 == "link") && tok->strAt(10) != ")")

continue;

redundantNextPreviousError(tok, func1, func2);

}

}

}

{

const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();

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

for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {

if (!Token::Match(tok, "Token :: simpleMatch|findsimplematch|Match|findmatch ("))

continue;

const std::string& funcname = tok->strAt(2);

// Get pattern string

const Token *patternTok = tok->tokAt(4)->nextArgument();

if (!patternTok || patternTok->tokType() != Token::eString)

continue;

const std::string pattern = patternTok->strValue();

if (!pattern.empty() && (pattern[0] == ' ' || *pattern.rbegin() == ' '))

extraWhitespaceError(tok, pattern, funcname);

// two whitespaces or more

if (pattern.find(" ") != std::string::npos)

extraWhitespaceError(tok, pattern, funcname);

}

}

{

const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();

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

for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {

if (Token::simpleMatch(tok, ". emplace ("))

reportError(tok, Severity::error, "internalStlUsage", "The 'emplace' function shall be avoided for now. It is not available e.g. in Slackware 14.0. 'emplace_back' is fine.");

//if (Token::simpleMatch(tok, ". back ( )") && tok->astOperand1() && tok->astOperand1()->valueType() && tok->astOperand1()->valueType()->container && Token::simpleMatch(tok->astOperand1()->valueType()->container, "std :: string"))

// reportError(tok, Severity::error, "internalStlUsage", "The 'std::string::back()' function shall be avoided for now.");

}

}

{

reportError(tok, Severity::error, "multiComparePatternError",

"Bad multicompare pattern (a %cmd% must be first unless it is %or%,%op%,%cop%,%name%,%oror%) inside Token::" + funcname + "() call: \"" + pattern + "\""

);

{

reportError(tok, Severity::warning, "simplePatternError",

"Found simple pattern inside Token::" + funcname + "() call: \"" + pattern + "\""

);

{

reportError(tok, Severity::error, "complexPatternError",

"Found complex pattern inside Token::" + funcname + "() call: \"" + pattern + "\""

);

{

reportError(tok, Severity::error, "missingPercentCharacter",

"Missing percent end character in Token::" + funcname + "() pattern: \"" + pattern + "\""

);

{

reportError(tok, Severity::error, "unknownPattern",

"Unknown pattern used: \"" + pattern + "\"");

{

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

"Call to 'Token::" + func1 + "()' followed by 'Token::" + func2 + "()' can be simplified.");

{

reportError(tok, Severity::error, "orInComplexPattern",

"Token::" + funcname + "() pattern \"" + pattern + "\" contains \"||\" or \"|\". Replace it by \"%oror%\" or \"%or%\".");

{

reportError(tok, Severity::warning, "extraWhitespaceError",

"Found extra whitespace inside Token::" + funcname + "() call: \"" + pattern + "\""

);