/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2013 Daniel Marjamäki and Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

#include "checkother.h"

#include "mathlib.h"

#include "symboldatabase.h"

#include "templatesimplifier.h"

#include <cmath> // fabs()

#include <stack>

#include <algorithm> // find_if()

//---------------------------------------------------------------------------

// Register this check class (by creating a static instance of it)

namespace {

CheckOther instance;

}

//----------------------------------------------------------------------------------

// The return value of fgetc(), getc(), ungetc(), getchar() etc. is an integer value.

// If this return value is stored in a character variable and then compared

// to compared to EOF, which is an integer, the comparison maybe be false.

//

// Reference:

// - Ticket #160

// - http://www.cplusplus.com/reference/cstdio/fgetc/

// - http://www.cplusplus.com/reference/cstdio/getc/

// - http://www.cplusplus.com/reference/cstdio/getchar/

// - http://www.cplusplus.com/reference/cstdio/ungetc/ ...

//----------------------------------------------------------------------------------

void CheckOther::checkCastIntToCharAndBack()

{

if (!_settings->isEnabled("warning"))

return;

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

const std::size_t functions = symbolDatabase->functionScopes.size();

for (std::size_t i = 0; i < functions; ++i) {

const Scope * scope = symbolDatabase->functionScopes[i];

std::map<unsigned int, std::string> vars;

for (const Token* tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) {

if (Token::Match(tok, "%var% = fclose|fflush|fputc|fputs|fscanf|getchar|getc|fgetc|putchar|putc|puts|scanf|sscanf|ungetc (")) {

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

if (var && var->typeEndToken()->str() == "char" && !var->typeEndToken()->isSigned()) {

vars[tok->varId()] = tok->strAt(2);

}

} else if (Token::Match(tok, "EOF %comp% ( %var% = fclose|fflush|fputc|fputs|fscanf|getchar|getc|fgetc|putchar|putc|puts|scanf|sscanf|ungetc (")) {

tok = tok->tokAt(3);

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

if (var && var->typeEndToken()->str() == "char" && !var->typeEndToken()->isSigned()) {

checkCastIntToCharAndBackError(tok, tok->strAt(2));

}

} else if (Token::Match(tok, "EOF %comp% ( %var% = std :: cin . get (") || Token::Match(tok, "EOF %comp% ( %var% = cin . get (")) {

tok = tok->tokAt(3);

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

if (var && var->typeEndToken()->str() == "char" && !var->typeEndToken()->isSigned()) {

checkCastIntToCharAndBackError(tok, "cin.get");

}

} else if (Token::Match(tok, "%var% = std :: cin . get (") || Token::Match(tok, "%var% = cin . get (")) {

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

if (var && var->typeEndToken()->str() == "char" && !var->typeEndToken()->isSigned()) {

vars[tok->varId()] = "cin.get";

}

}

if (Token::Match(tok, "%var% %comp% EOF")) {

if (vars.find(tok->varId()) != vars.end()) {

checkCastIntToCharAndBackError(tok, vars[tok->varId()]);

}

} else if (Token::Match(tok, "EOF %comp% %var%")) {

tok = tok->tokAt(2);

if (vars.find(tok->varId()) != vars.end()) {

checkCastIntToCharAndBackError(tok, vars[tok->varId()]);

}

}

}

}

}

void CheckOther::checkCastIntToCharAndBackError(const Token *tok, const std::string &strFunctionName)

{

reportError(

tok,

Severity::warning,

"checkCastIntToCharAndBack",

"Storing "+ strFunctionName +"() return value in char variable and then comparing with EOF.\n"

"When saving "+ strFunctionName +"() return value in char variable there is loss of precision. "

" When "+ strFunctionName +"() returns EOF this value is truncated. Comparing the char "

"variable with EOF can have unexpected results. For instance a loop \"while (EOF != (c = "+ strFunctionName +"());\" "

"loops forever on some compilers/platforms and on other compilers/platforms it will stop "

"when the file contains a matching character."

);

}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

void CheckOther::clarifyCalculation()

{

if (!_settings->isEnabled("style"))

return;

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

const std::size_t functions = symbolDatabase->functionScopes.size();

for (std::size_t i = 0; i < functions; ++i) {

const Scope * scope = symbolDatabase->functionScopes[i];

for (const Token* tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) {

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

// condition

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

if (cond->isName() || cond->isNumber())

cond = cond->previous();

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

cond = cond->link()->previous();

else

continue;

if (cond && cond->str() == "!")

cond = cond->previous();

if (!cond)

continue;

// calculation

if (!cond->isArithmeticalOp())

continue;

const std::string &op = cond->str();

cond = cond->previous();

// skip previous multiplications..

while (cond && cond->previous()) {

if ((cond->isName() || cond->isNumber()) && cond->previous()->str() == "*")

cond = cond->tokAt(-2);

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

cond = cond->link()->previous();

else

break;

}

if (!cond)

continue;

// first multiplication operand

if (cond->str() == ")") {

clarifyCalculationError(cond, op);

} else if (cond->isName() || cond->isNumber()) {

if (Token::Match(cond->previous(),"return|=|+|-|,|(") || cond->strAt(-1) == op)

clarifyCalculationError(cond, op);

}

}

}

}

}

void CheckOther::clarifyCalculationError(const Token *tok, const std::string &op)

{

// suspicious calculation

const std::string calc("'a" + op + "b?c:d'");

// recommended calculation #1

const std::string s1("'(a" + op + "b)?c:d'");

// recommended calculation #2

const std::string s2("'a" + op + "(b?c:d)'");

reportError(tok,

Severity::style,

"clarifyCalculation",

"Clarify calculation precedence for '" + op + "' and '?'.\n"

"Suspicious calculation. Please use parentheses to clarify the code. "

"The code '" + calc + "' should be written as either '" + s1 + "' or '" + s2 + "'.");

}

//---------------------------------------------------------------------------

// Clarify condition '(x = a < 0)' into '((x = a) < 0)' or '(x = (a < 0))'

// Clarify condition '(a & b == c)' into '((a & b) == c)' or '(a & (b == c))'

//---------------------------------------------------------------------------

void CheckOther::clarifyCondition()

{

if (!_settings->isEnabled("style"))

return;

const bool isC = _tokenizer->isC();

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

const std::size_t functions = symbolDatabase->functionScopes.size();

for (std::size_t i = 0; i < functions; ++i) {

const Scope * scope = symbolDatabase->functionScopes[i];

for (const Token* tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) {

if (Token::Match(tok, "( %var% [=&|^]")) {

for (const Token *tok2 = tok->tokAt(3); tok2; tok2 = tok2->next()) {

if (tok2->str() == "(" || tok2->str() == "[")

tok2 = tok2->link();

else if (tok2->type() == Token::eComparisonOp) {

// This might be a template

if (!isC && tok2->link())

break;

clarifyConditionError(tok, tok->strAt(2) == "=", false);

break;

} else if (!tok2->isName() && !tok2->isNumber() && tok2->str() != ".")

break;

}

}

}

}

// using boolean result in bitwise operation ! x [&|^]

for (std::size_t i = 0; i < functions; ++i) {

const Scope * scope = symbolDatabase->functionScopes[i];

for (const Token* tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) {

if (Token::Match(tok, "%comp%|!")) {

if (tok->link()) // don't write false positives when templates are used

continue;

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

// Todo: There are false positives if '(' if encountered. It

// is assumed there is something like '(char *)&..' and therefore

// it bails out.

if (Token::Match(tok2, "(|&"))

continue;

while (tok2 && (tok2->isName() || tok2->isNumber() || Token::Match(tok2,".|(|["))) {

if (Token::Match(tok2, "(|["))

tok2 = tok2->link();

tok2 = tok2->next();

}

if (Token::Match(tok2, "[&|^]")) {

// don't write false positives when templates are used

if (Token::Match(tok2, "&|* ,|>") || Token::simpleMatch(tok2->previous(), "const &"))

continue;

// #3609 - CWinTraits<WS_CHILD|WS_VISIBLE>::..

if (!isC && Token::Match(tok->previous(), "%var% <")) {

const Token *tok3 = tok2;

while (Token::Match(tok3, "[&|^] %var%"))

tok3 = tok3->tokAt(2);

if (Token::Match(tok3, ",|>"))

continue;

}

clarifyConditionError(tok,false,true);

}

}

}

}

}

void CheckOther::clarifyConditionError(const Token *tok, bool assign, bool boolop)

{

std::string errmsg;

if (assign)

errmsg = "Suspicious condition (assignment + comparison); Clarify expression with parentheses.";

else if (boolop)

errmsg = "Boolean result is used in bitwise operation. Clarify expression with parentheses.\n"

"Suspicious expression. Boolean result is used in bitwise operation. The operator '!' "

"and the comparison operators have higher precedence than bitwise operators. "

"It is recommended that the expression is clarified with parentheses.";

else

errmsg = "Suspicious condition (bitwise operator + comparison); Clarify expression with parentheses.\n"

"Suspicious condition. Comparison operators have higher precedence than bitwise operators. "

"Please clarify the condition with parentheses.";

reportError(tok,

Severity::style,

"clarifyCondition",

errmsg);

}

//---------------------------------------------------------------------------

// Clarify (meaningless) statements like *foo++; with parentheses.

//---------------------------------------------------------------------------

void CheckOther::clarifyStatement()

{

if (!_settings->isEnabled("warning"))

return;

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

const std::size_t functions = symbolDatabase->functionScopes.size();

for (std::size_t i = 0; i < functions; ++i) {

const Scope * scope = symbolDatabase->functionScopes[i];

for (const Token* tok = scope->classStart; tok != scope->classEnd; tok = tok->next()) {

if (Token::Match(tok, "* %var%")) {

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

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

tok2=tok2->previous();

if (Token::Match(tok2, "[{};]")) {

tok = tok->tokAt(2);

for (;;) {

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

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

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

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

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

else

tok = tok->tokAt(2);

} else

break;

}

if (Token::Match(tok, "++|-- [;,]"))

clarifyStatementError(tok);

}

}

}

}

}

void CheckOther::clarifyStatementError(const Token *tok)

{

reportError(tok, Severity::warning, "clarifyStatement", "Ineffective statement similar to '*A++;'. Did you intend to write '(*A)++;'?\n"

"A statement like '*A++;' might not do what you intended. Postfix 'operator++' is executed before 'operator*'. "

"Thus, the dereference is meaningless. Did you intend to write '(*A)++;'?");

}

void CheckOther::checkSuspiciousSemicolon()

{

if (!_settings->inconclusive || !_settings->isEnabled("warning"))

return;

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

// Look for "if(); {}", "for(); {}" or "while(); {}"

for (std::list<Scope>::const_iterator i = symbolDatabase->scopeList.begin(); i != symbolDatabase->scopeList.end(); ++i) {

if (i->type == Scope::eIf || i->type == Scope::eElse || i->type == Scope::eElseIf || i->type == Scope::eWhile || i->type == Scope::eFor) {

// Ensure the semicolon is at the same line number as the if/for/while statement

// and the {..} block follows it without an extra empty line.

if (Token::simpleMatch(i->classStart, "{ ; } {") &&

i->classStart->previous()->linenr() == i->classStart->tokAt(2)->linenr()

&& i->classStart->linenr()+1 >= i->classStart->tokAt(3)->linenr()) {

SuspiciousSemicolonError(i->classDef);

}

}

}

}

void CheckOther::SuspiciousSemicolonError(const Token* tok)

{

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

"Suspicious use of ; at the end of '" + (tok ? tok->str() : std::string()) + "' statement.", true);

}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

void CheckOther::warningOldStylePointerCast()

{

// Only valid on C++ code

if (!_settings->isEnabled("style") || !_tokenizer->isCPP())

return;

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

// Old style pointer casting..

if (!Token::Match(tok, "( const| %type% * ) (| %var%") &&

!Token::Match(tok, "( const| %type% * ) (| new"))

continue;

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

tok = tok->next();

if (tok->strAt(4) == "const")

continue;

// Is "type" a class?

const std::string pattern("class|struct " + tok->strAt(1));

if (Token::findmatch(_tokenizer->tokens(), pattern.c_str(), tok))

cstyleCastError(tok);

}

}

void CheckOther::cstyleCastError(const Token *tok)

{

reportError(tok, Severity::style, "cstyleCast", "C-style pointer casting");

}

//---------------------------------------------------------------------------

// float* f; double* d = (double*)f; <-- Pointer cast to a type with an incompatible binary data representation

//---------------------------------------------------------------------------

static std::string analyzeType(const Token* tok)

{

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

if (tok->isLong())

return "long double";

else

return "double";

}

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

return "float";

if (Token::Match(tok, "int|long|short|char|size_t"))

return "integer";

return "";

}

void CheckOther::invalidPointerCast()

{

if (!_settings->isEnabled("warning") && !_settings->isEnabled("portability"))

return;

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

const std::size_t functions = symbolDatabase->functionScopes.size();

for (std::size_t i = 0; i < functions; ++i) {

const Scope * scope = symbolDatabase->functionScopes[i];

for (const Token* tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) {

const Token* toTok = 0;

const Token* nextTok = 0;

// Find cast

if (Token::Match(tok, "( const| %type% const| * )") ||

Token::Match(tok, "( const| %type% %type% const| * )")) {

toTok = tok->next();

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

if (nextTok && nextTok->str() == "(")

nextTok = nextTok->next();

} else if (Token::Match(tok, "reinterpret_cast < const| %type% const| * > (") ||

Token::Match(tok, "reinterpret_cast < const| %type% %type% const| * > (")) {

nextTok = tok->tokAt(5);

while (nextTok->str() != "(")

nextTok = nextTok->next();

nextTok = nextTok->next();

toTok = tok->tokAt(2);

}

if (toTok && toTok->str() == "const")

toTok = toTok->next();

if (!nextTok || !toTok || !toTok->isStandardType())

continue;

// Find casted variable

const Variable *var = 0;

bool allocation = false;

bool ref = false;

if (Token::Match(nextTok, "new %type%"))

allocation = true;

else if (Token::Match(nextTok, "%var% !!["))

var = nextTok->variable();

else if (Token::Match(nextTok, "& %var%") && !Token::Match(nextTok->tokAt(2), "(|[")) {

var = nextTok->next()->variable();

ref = true;

}

const Token* fromTok = 0;

if (allocation) {

fromTok = nextTok->next();

} else {

if (!var || (!ref && !var->isPointer() && !var->isArray()) || (ref && (var->isPointer() || var->isArray())))

continue;

fromTok = var->typeStartToken();

}

while (Token::Match(fromTok, "static|const"))

fromTok = fromTok->next();

if (!fromTok->isStandardType())

continue;

std::string fromType = analyzeType(fromTok);

std::string toType = analyzeType(toTok);

if (fromType != toType && !fromType.empty() && !toType.empty() && (toType != "integer" || _settings->isEnabled("portability")) && (toTok->str() != "char" || _settings->inconclusive))

invalidPointerCastError(tok, fromType, toType, toTok->str() == "char");

}

}

}

void CheckOther::invalidPointerCastError(const Token* tok, const std::string& from, const std::string& to, bool inconclusive)

{

if (to == "integer") { // If we cast something to int*, this can be useful to play with its binary data representation

if (!inconclusive)

reportError(tok, Severity::portability, "invalidPointerCast", "Casting from " + from + "* to integer* is not portable due to different binary data representations on different platforms.");

else

reportError(tok, Severity::portability, "invalidPointerCast", "Casting from " + from + "* to char* is not portable due to different binary data representations on different platforms.", true);

} else

reportError(tok, Severity::warning, "invalidPointerCast", "Casting between " + from + "* and " + to + "* which have an incompatible binary data representation.");

}

//---------------------------------------------------------------------------

// This check detects errors on POSIX systems, when a pipe command called

// with a wrong dimensioned file descriptor array. The pipe command requires

// exactly an integer array of dimension two as parameter.

//

// References:

// - http://linux.die.net/man/2/pipe

// - ticket #3521

//---------------------------------------------------------------------------

void CheckOther::checkPipeParameterSize()

{

if (!_settings->standards.posix)

return;

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

const std::size_t functions = symbolDatabase->functionScopes.size();

for (std::size_t i = 0; i < functions; ++i) {

const Scope * scope = symbolDatabase->functionScopes[i];

for (const Token* tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) {

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

Token::Match(tok, "pipe2 ( %var% ,")) {

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

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

MathLib::bigint dim;

if (var && var->isArray() && !var->isArgument() && ((dim=var->dimension(0U)) < 2)) {

const std::string strDim = MathLib::toString(dim);

checkPipeParameterSizeError(varTok,varTok->str(), strDim);

}

}

}

}

}

void CheckOther::checkPipeParameterSizeError(const Token *tok, const std::string &strVarName, const std::string &strDim)

{

reportError(tok, Severity::error,

"wrongPipeParameterSize", "Buffer '" + strVarName + "' must have size of 2 integers if used as parameter of pipe().\n"

"The pipe()/pipe2() system command takes an argument, which is an array of exactly two integers.\n"

"The variable '" + strVarName + "' is an array of size " + strDim + ", which does not match.");

}

//-----------------------------------------------------------------------------

// check usleep(), which is allowed to be called with in a range of [0,999999]

//

// Reference:

// - http://man7.org/linux/man-pages/man3/usleep.3.html

//-----------------------------------------------------------------------------

void CheckOther::checkSleepTimeInterval()

{

if (!_settings->standards.posix)

return;

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

const std::size_t functions = symbolDatabase->functionScopes.size();

for (std::size_t i = 0; i < functions; ++i) {

const Scope * scope = symbolDatabase->functionScopes[i];

for (const Token* tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) {

if (Token::Match(tok, "usleep ( %num% )")) {

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

MathLib::bigint value = MathLib::toLongNumber(numTok->str());

if (value > 999999) { // less than 1 million

checkSleepTimeError(numTok, numTok->str());

}

}

}

}

}

void CheckOther::checkSleepTimeError(const Token *tok, const std::string &strDim)

{

reportError(tok, Severity::error,

"tooBigSleepTime", "The argument of usleep must be less than 1000000.\n"

"The argument of usleep must be less than 1000000, but " + strDim + " is provided.");

}

//---------------------------------------------------------------------------

// Detect redundant assignments: x = 0; x = 4;

//---------------------------------------------------------------------------

static bool nonLocal(const Variable* var)

{

return !var || (!var->isLocal() && !var->isArgument()) || var->isStatic() || var->isReference();

}

static void eraseNotLocalArg(std::map<unsigned int, const Token*>& container, const SymbolDatabase* symbolDatabase)

{

for (std::map<unsigned int, const Token*>::iterator i = container.begin(); i != container.end();) {

const Variable* var = symbolDatabase->getVariableFromVarId(i->first);

if (!var || nonLocal(var)) {

container.erase(i++);

if (i == container.end())

break;

} else

++i;

}

}

void CheckOther::checkRedundantAssignment()

{

const bool performance = _settings->isEnabled("performance");

const bool warning = _settings->isEnabled("warning");

if (!warning && !performance)

return;

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

for (std::list<Scope>::const_iterator scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope) {

if (!scope->isExecutable())

continue;

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

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

std::set<unsigned int> initialized;

const Token* writtenArgumentsEnd = 0;

for (const Token* tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) {

if (tok == writtenArgumentsEnd)

writtenArgumentsEnd = 0;

if (tok->str() == "{" && tok->strAt(-1) != "{" && tok->strAt(-1) != "=" && tok->strAt(-4) != "case" && tok->strAt(-3) != "default") { // conditional or non-executable inner scope: Skip it and reset status

tok = tok->link();

varAssignments.clear();

memAssignments.clear();

} else if (Token::Match(tok, "for|if|while (")) {

tok = tok->linkAt(1);

} else if (Token::Match(tok, "break|return|continue|throw|goto")) {

varAssignments.clear();

memAssignments.clear();

} else if (tok->type() == Token::eVariable) {

// Set initialization flag

if (!Token::Match(tok, "%var% ["))

initialized.insert(tok->varId());

else {

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

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

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

if (tok2 && tok2->str() != ";")

initialized.insert(tok->varId());

}

const Token *startToken = tok;

while (Token::Match(startToken, "%var%|::|."))

startToken = startToken->previous();

std::map<unsigned int, const Token*>::iterator it = varAssignments.find(tok->varId());

if (tok->next()->isAssignmentOp() && Token::Match(startToken, "[;{}]")) { // Assignment

if (it != varAssignments.end()) {

bool error = true; // Ensure that variable is not used on right side

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

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

break;

else if (tok2->varId() == tok->varId())

error = false;

else if (Token::Match(tok2, "%var% (") && nonLocal(tok->variable())) { // Called function might use the variable

const Function* func = tok2->function();

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

if (!var || var->isGlobal() || var->isReference() || ((!func || func->nestedIn) && tok2->strAt(-1) != ".")) // Global variable, or member function

error = false;

}

}

if (error) {

if (scope->type == Scope::eSwitch && Token::findmatch(it->second, "default|case", tok) && warning)

redundantAssignmentInSwitchError(it->second, tok, tok->str());

else if (performance) {

const bool nonlocal = nonLocal(it->second->variable());

if (_settings->inconclusive || !nonlocal) // see #5089 - report inconclusive only when requested

redundantAssignmentError(it->second, tok, tok->str(), nonlocal); // Inconclusive for non-local variables

}

}

it->second = tok;

}

if (!Token::simpleMatch(tok->tokAt(2), "0 ;") || (tok->variable() && tok->variable()->nameToken() != tok->tokAt(-2)))

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

memAssignments.erase(tok->varId());

} else if (tok->next()->type() == Token::eIncDecOp || (tok->previous()->type() == Token::eIncDecOp && tok->strAt(1) == ";")) { // Variable incremented/decremented; Prefix-Increment is only suspicious, if its return value is unused

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

memAssignments.erase(tok->varId());

} else if (!Token::simpleMatch(tok->tokAt(-2), "sizeof (")) { // Other usage of variable

if (it != varAssignments.end())

varAssignments.erase(it);

if (!writtenArgumentsEnd) // Indicates that we are in the first argument of strcpy/memcpy/... function

memAssignments.erase(tok->varId());

}

} else if (Token::Match(tok, "%var% (")) { // Function call. Global variables might be used. Reset their status

bool memfunc = Token::Match(tok, "memcpy|memmove|memset|strcpy|strncpy|sprintf|snprintf|strcat|strncat|wcscpy|wcsncpy|swprintf|wcscat|wcsncat");

if (memfunc) {

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

writtenArgumentsEnd = param1->next();

if (param1->varId() && param1->strAt(1) == "," && !Token::Match(tok, "strcat|strncat|wcscat|wcsncat")) {

if (tok->str() == "memset" && initialized.find(param1->varId()) == initialized.end() && param1->variable() && param1->variable()->isLocal() && param1->variable()->isArray())

initialized.insert(param1->varId());

else if (memAssignments.find(param1->varId()) == memAssignments.end())

memAssignments[param1->varId()] = tok;

else {

const std::map<unsigned int, const Token*>::iterator it = memAssignments.find(param1->varId());

if (scope->type == Scope::eSwitch && Token::findmatch(it->second, "default|case", tok) && warning)

redundantCopyInSwitchError(it->second, tok, param1->str());

else if (performance)

redundantCopyError(it->second, tok, param1->str());

}

}

} else if (scope->type == Scope::eSwitch) { // Avoid false positives if noreturn function is called in switch

const Function* func = tok->function();

if (!func || !func->hasBody) {

varAssignments.clear();

memAssignments.clear();

continue;

}

const Token* funcEnd = func->functionScope->classEnd;

bool noreturn;

if (!_tokenizer->IsScopeNoReturn(funcEnd, &noreturn) && !noreturn) {

eraseNotLocalArg(varAssignments, symbolDatabase);

eraseNotLocalArg(memAssignments, symbolDatabase);

} else {

varAssignments.clear();

memAssignments.clear();

}

} else { // Noreturn functions outside switch don't cause problems

eraseNotLocalArg(varAssignments, symbolDatabase);

eraseNotLocalArg(memAssignments, symbolDatabase);

}

}

}

}

}

void CheckOther::redundantCopyError(const Token *tok1, const Token* tok2, const std::string& var)

{

std::list<const Token*> callstack;

callstack.push_back(tok1);

callstack.push_back(tok2);

reportError(callstack, Severity::performance, "redundantCopy",

"Buffer '" + var + "' is being written before its old content has been used.");

}

void CheckOther::redundantCopyInSwitchError(const Token *tok1, const Token* tok2, const std::string &var)

{

std::list<const Token*> callstack;

callstack.push_back(tok1);

callstack.push_back(tok2);

reportError(callstack, Severity::warning, "redundantCopyInSwitch",

"Buffer '" + var + "' is being written before its old content has been used. 'break;' missing?");

}

void CheckOther::redundantAssignmentError(const Token *tok1, const Token* tok2, const std::string& var, bool inconclusive)

{

std::list<const Token*> callstack;

callstack.push_back(tok1);

callstack.push_back(tok2);

if (inconclusive)

reportError(callstack, Severity::performance, "redundantAssignment",

"Variable '" + var + "' is reassigned a value before the old one has been used if variable is no semaphore variable.\n"

"Variable '" + var + "' is reassigned a value before the old one has been used. Make sure that this variable is not used like a semaphore in a threading environment before simplifying this code.", true);

else

reportError(callstack, Severity::performance, "redundantAssignment",

"Variable '" + var + "' is reassigned a value before the old one has been used.");

}

void CheckOther::redundantAssignmentInSwitchError(const Token *tok1, const Token* tok2, const std::string &var)

{

std::list<const Token*> callstack;

callstack.push_back(tok1);

callstack.push_back(tok2);

reportError(callstack, Severity::warning, "redundantAssignInSwitch",

"Variable '" + var + "' is reassigned a value before the old one has been used. 'break;' missing?");

}

//---------------------------------------------------------------------------

// switch (x)

// {

// case 2:

// y = a; // <- this assignment is redundant

// case 3:

// y = b; // <- case 2 falls through and sets y twice

// }

//---------------------------------------------------------------------------

static inline bool isFunctionOrBreakPattern(const Token *tok)

{

if (Token::Match(tok, "%var% (") || Token::Match(tok, "break|continue|return|exit|goto|throw"))

return true;

return false;

}

void CheckOther::checkRedundantAssignmentInSwitch()

{

if (!_settings->isEnabled("warning"))

return;

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

// Find the beginning of a switch. E.g.:

// switch (var) { ...

for (std::list<Scope>::const_iterator i = symbolDatabase->scopeList.begin(); i != symbolDatabase->scopeList.end(); ++i) {

if (i->type != Scope::eSwitch || !i->classStart)

continue;

// Check the contents of the switch statement

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

std::map<unsigned int, std::string> bitOperations;

for (const Token *tok2 = i->classStart->next(); tok2 != i->classEnd; tok2 = tok2->next()) {

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

// Inside a conditional or loop. Don't mark variable accesses as being redundant. E.g.:

// case 3: b = 1;

// case 4: if (a) { b = 2; } // Doesn't make the b=1 redundant because it's conditional

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

const Token* endOfConditional = tok2->link();

for (const Token* tok3 = tok2; tok3 != endOfConditional; tok3 = tok3->next()) {

if (tok3->varId() != 0) {

varsWithBitsSet.erase(tok3->varId());

bitOperations.erase(tok3->varId());

} else if (isFunctionOrBreakPattern(tok3)) {

varsWithBitsSet.clear();

bitOperations.clear();

}

}

tok2 = endOfConditional;

}

}

// Variable assignment. Report an error if it's assigned to twice before a break. E.g.:

// case 3: b = 1; // <== redundant

// case 4: b = 2;

if (Token::Match(tok2->previous(), ";|{|}|: %var% = %any% ;") && tok2->varId() != 0) {

varsWithBitsSet.erase(tok2->varId());

bitOperations.erase(tok2->varId());

}

// Bitwise operation. Report an error if it's performed twice before a break. E.g.:

// case 3: b |= 1; // <== redundant

// case 4: b |= 1;

else if (Token::Match(tok2->previous(), ";|{|}|: %var% = %var% %or%|& %num% ;") &&

tok2->varId() != 0 && tok2->varId() == tok2->tokAt(2)->varId()) {

std::string bitOp = tok2->strAt(3) + tok2->strAt(4);

std::map<unsigned int, const Token*>::iterator i2 = varsWithBitsSet.find(tok2->varId());

// This variable has not had a bit operation performed on it yet, so just make a note of it

if (i2 == varsWithBitsSet.end()) {

varsWithBitsSet[tok2->varId()] = tok2;

bitOperations[tok2->varId()] = bitOp;

}

// The same bit operation has been performed on the same variable twice, so report an error

else if (bitOperations[tok2->varId()] == bitOp)

redundantBitwiseOperationInSwitchError(i2->second, i2->second->str());

// A different bit operation was performed on the variable, so clear it

else {

varsWithBitsSet.erase(tok2->varId());

bitOperations.erase(tok2->varId());

}

}

// Not a simple assignment so there may be good reason if this variable is assigned to twice. E.g.:

// case 3: b = 1;

// case 4: b++;

else if (tok2->varId() != 0 && tok2->strAt(1) != "|" && tok2->strAt(1) != "&") {

varsWithBitsSet.erase(tok2->varId());

bitOperations.erase(tok2->varId());

}

// Reset our record of assignments if there is a break or function call. E.g.:

// case 3: b = 1; break;

if (isFunctionOrBreakPattern(tok2)) {

varsWithBitsSet.clear();

bitOperations.clear();

}

}

}

}

void CheckOther::redundantBitwiseOperationInSwitchError(const Token *tok, const std::string &varname)

{

reportError(tok, Severity::warning,

"redundantBitwiseOperationInSwitch", "Redundant bitwise operation on '" + varname + "' in 'switch' statement. 'break;' missing?");

}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

void CheckOther::checkSwitchCaseFallThrough()

{

if (!(_settings->isEnabled("style") && _settings->experimental))

return;

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

for (std::list<Scope>::const_iterator i = symbolDatabase->scopeList.begin(); i != symbolDatabase->scopeList.end(); ++i) {

if (i->type != Scope::eSwitch || !i->classStart) // Find the beginning of a switch

continue;

// Check the contents of the switch statement

std::stack<std::pair<Token *, bool> > ifnest;

std::stack<Token *> loopnest;

std::stack<Token *> scopenest;

bool justbreak = true;

bool firstcase = true;

for (const Token *tok2 = i->classStart; tok2 != i->classEnd; tok2 = tok2->next()) {

if (Token::simpleMatch(tok2, "if (")) {

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

if (tok2->link() == NULL) {

std::ostringstream errmsg;

errmsg << "unmatched if in switch: " << tok2->linenr();

reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());

break;

}

ifnest.push(std::make_pair(tok2->link(), false));

justbreak = false;

} else if (Token::simpleMatch(tok2, "while (")) {

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

// skip over "do { } while ( ) ;" case

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

if (tok2->link() == NULL) {

std::ostringstream errmsg;

errmsg << "unmatched while in switch: " << tok2->linenr();

reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());

break;

}

loopnest.push(tok2->link());

}

justbreak = false;

} else if (Token::simpleMatch(tok2, "do {")) {

tok2 = tok2->next();

if (tok2->link() == NULL) {

std::ostringstream errmsg;

errmsg << "unmatched do in switch: " << tok2->linenr();

reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());

break;

}

loopnest.push(tok2->link());

justbreak = false;

} else if (Token::simpleMatch(tok2, "for (")) {

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

if (tok2->link() == NULL) {

std::ostringstream errmsg;

errmsg << "unmatched for in switch: " << tok2->linenr();

reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());

break;

}

loopnest.push(tok2->link());

justbreak = false;

} else if (Token::simpleMatch(tok2, "switch (")) {

// skip over nested switch, we'll come to that soon

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

} else if (Token::Match(tok2, "break|continue|return|exit|goto|throw")) {

if (loopnest.empty()) {

justbreak = true;

}

tok2 = Token::findsimplematch(tok2, ";");

} else if (Token::Match(tok2, "case|default")) {

if (!justbreak && !firstcase) {

switchCaseFallThrough(tok2);

}

tok2 = Token::findsimplematch(tok2, ":");

justbreak = true;

firstcase = false;

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

scopenest.push(tok2->link());

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

if (!ifnest.empty() && tok2 == ifnest.top().first) {

if (tok2->next()->str() == "else") {

tok2 = tok2->tokAt(2);

ifnest.pop();

if (tok2->link() == NULL) {

std::ostringstream errmsg;

errmsg << "unmatched if in switch: " << tok2->linenr();

reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());

break;

}

ifnest.push(std::make_pair(tok2->link(), justbreak));

justbreak = false;

} else {

justbreak &= ifnest.top().second;

ifnest.pop();

}

} else if (!loopnest.empty() && tok2 == loopnest.top()) {

loopnest.pop();

} else if (!scopenest.empty() && tok2 == scopenest.top()) {

scopenest.pop();

} else {

if (!ifnest.empty() || !loopnest.empty() || !scopenest.empty()) {

std::ostringstream errmsg;

errmsg << "unexpected end of switch: ";

errmsg << "ifnest=" << ifnest.size();

if (!ifnest.empty())

errmsg << "," << ifnest.top().first->linenr();

errmsg << ", loopnest=" << loopnest.size();

if (!loopnest.empty())

errmsg << "," << loopnest.top()->linenr();

errmsg << ", scopenest=" << scopenest.size();

if (!scopenest.empty())

errmsg << "," << scopenest.top()->linenr();

reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());

}

// end of switch block

break;

}

} else if (tok2->str() != ";") {