/*

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

* Copyright (C) 2007-2023 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 "checkunusedvar.h"

#include "astutils.h"

#include "errortypes.h"

#include "fwdanalysis.h"

#include "library.h"

#include "preprocessor.h"

#include "settings.h"

#include "symboldatabase.h"

#include "token.h"

#include "tokenize.h"

#include "tokenlist.h"

#include "utils.h"

#include "valueflow.h"

#include <algorithm>

#include <list>

#include <set>

#include <utility>

#include <vector>

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

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

namespace {

CheckUnusedVar instance;

}

static const CWE CWE563(563U); // Assignment to Variable without Use ('Unused Variable')

static const CWE CWE665(665U); // Improper Initialization

/** Is scope a raii class scope */

static bool isRaiiClassScope(const Scope *classScope)

{

return classScope && classScope->getDestructor() != nullptr;

}

/** Is ValueType a raii class? */

static bool isRaiiClass(const ValueType *valueType, bool cpp, bool defaultReturn = true)

{

if (!cpp)

return false;

if (!valueType)

return defaultReturn;

if ((valueType->smartPointerType && isRaiiClassScope(valueType->smartPointerType->classScope)) || (!valueType->smartPointerType && valueType->type == ValueType::Type::SMART_POINTER))

return true;

switch (valueType->type) {

case ValueType::Type::UNKNOWN_TYPE:

case ValueType::Type::NONSTD:

return defaultReturn;

case ValueType::Type::RECORD:

if (isRaiiClassScope(valueType->typeScope))

return true;

return defaultReturn;

case ValueType::Type::POD:

case ValueType::Type::SMART_POINTER:

case ValueType::Type::CONTAINER:

case ValueType::Type::ITERATOR:

case ValueType::Type::VOID:

case ValueType::Type::BOOL:

case ValueType::Type::CHAR:

case ValueType::Type::SHORT:

case ValueType::Type::WCHAR_T:

case ValueType::Type::INT:

case ValueType::Type::LONG:

case ValueType::Type::LONGLONG:

case ValueType::Type::UNKNOWN_INT:

case ValueType::Type::FLOAT:

case ValueType::Type::DOUBLE:

case ValueType::Type::LONGDOUBLE:

return false;

}

return defaultReturn;

}

/**

* @brief This class is used create a list of variables within a function.

*/

class Variables {

public:

enum VariableType { standard, array, pointer, reference, pointerArray, referenceArray, pointerPointer, none };

/** Store information about variable usage */

class VariableUsage {

public:

explicit VariableUsage(const Variable *var = nullptr,

VariableType type = standard,

bool read = false,

bool write = false,

bool modified = false,

bool allocateMemory = false) :

_var(var),

_lastAccess(var ? var->nameToken() : nullptr),

mType(type),

_read(read),

_write(write),

_modified(modified),

_allocateMemory(allocateMemory) {}

/** variable is used.. set both read+write */

void use() {

_read = true;

_write = true;

}

/** is variable unused? */

bool unused() const {

return (!_read && !_write);

}

std::set<nonneg int> _aliases;

std::set<const Scope*> _assignments;

const Variable* _var;

const Token* _lastAccess;

VariableType mType;

bool _read;

bool _write;

bool _modified; // read/modify/write

bool _allocateMemory;

};

void clear() {

mVarUsage.clear();

}

const std::map<nonneg int, VariableUsage> &varUsage() const {

return mVarUsage;

}

void addVar(const Variable *var, VariableType type, bool write_);

void allocateMemory(nonneg int varid, const Token* tok);

void read(nonneg int varid, const Token* tok);

void readAliases(nonneg int varid, const Token* tok);

void readAll(nonneg int varid, const Token* tok);

void write(nonneg int varid, const Token* tok);

void writeAliases(nonneg int varid, const Token* tok);

void writeAll(nonneg int varid, const Token* tok);

void use(nonneg int varid, const Token* tok);

void modified(nonneg int varid, const Token* tok);

VariableUsage *find(nonneg int varid);

void alias(nonneg int varid1, nonneg int varid2, bool replace);

void erase(nonneg int varid) {

mVarUsage.erase(varid);

}

void eraseAliases(nonneg int varid);

void eraseAll(nonneg int varid);

void clearAliases(nonneg int varid);

private:

std::map<nonneg int, VariableUsage> mVarUsage;

};

/**

* Alias the 2 given variables. Either replace the existing aliases if

* they exist or merge them. You would replace an existing alias when this

* assignment is in the same scope as the previous assignment. You might

* merge the aliases when this assignment is in a different scope from the

* previous assignment depending on the relationship of the 2 scopes.

*/

void Variables::alias(nonneg int varid1, nonneg int varid2, bool replace)

{

VariableUsage *var1 = find(varid1);

VariableUsage *var2 = find(varid2);

if (!var1 || !var2)

return;

// alias to self

if (varid1 == varid2) {

var1->use();

return;

}

if (replace) {

// remove var1 from all aliases

for (std::set<nonneg int>::const_iterator i = var1->_aliases.cbegin(); i != var1->_aliases.cend(); ++i) {

VariableUsage *temp = find(*i);

if (temp)

temp->_aliases.erase(var1->_var->declarationId());

}

// remove all aliases from var1

var1->_aliases.clear();

}

// var1 gets all var2s aliases

for (std::set<nonneg int>::const_iterator i = var2->_aliases.cbegin(); i != var2->_aliases.cend(); ++i) {

if (*i != varid1)

var1->_aliases.insert(*i);

}

// var2 is an alias of var1

var2->_aliases.insert(varid1);

var1->_aliases.insert(varid2);

if (var2->mType == Variables::pointer) {

var2->_read = true;

}

}

void Variables::clearAliases(nonneg int varid)

{

VariableUsage *usage = find(varid);

if (usage) {

// remove usage from all aliases

for (std::set<nonneg int>::const_iterator i = usage->_aliases.cbegin(); i != usage->_aliases.cend(); ++i) {

VariableUsage *temp = find(*i);

if (temp)

temp->_aliases.erase(usage->_var->declarationId());

}

// remove all aliases from usage

usage->_aliases.clear();

}

}

void Variables::eraseAliases(nonneg int varid)

{

VariableUsage *usage = find(varid);

if (usage) {

for (std::set<nonneg int>::const_iterator aliases = usage->_aliases.cbegin(); aliases != usage->_aliases.cend(); ++aliases)

erase(*aliases);

}

}

void Variables::eraseAll(nonneg int varid)

{

eraseAliases(varid);

erase(varid);

}

void Variables::addVar(const Variable *var,

VariableType type,

bool write_)

{

if (var->declarationId() > 0) {

mVarUsage.insert(std::make_pair(var->declarationId(), VariableUsage(var, type, false, write_, false)));

}

}

void Variables::allocateMemory(nonneg int varid, const Token* tok)

{

VariableUsage *usage = find(varid);

if (usage) {

usage->_allocateMemory = true;

usage->_lastAccess = tok;

}

}

void Variables::read(nonneg int varid, const Token* tok)

{

VariableUsage *usage = find(varid);

if (usage) {

usage->_read = true;

if (tok)

usage->_lastAccess = tok;

}

}

void Variables::readAliases(nonneg int varid, const Token* tok)

{

const VariableUsage *usage = find(varid);

if (usage) {

for (nonneg int const aliases : usage->_aliases) {

VariableUsage *aliased = find(aliases);

if (aliased) {

aliased->_read = true;

aliased->_lastAccess = tok;

}

}

}

}

void Variables::readAll(nonneg int varid, const Token* tok)

{

read(varid, tok);

readAliases(varid, tok);

}

void Variables::write(nonneg int varid, const Token* tok)

{

VariableUsage *usage = find(varid);

if (usage) {

usage->_write = true;

if (!usage->_var->isStatic() && !Token::simpleMatch(tok->next(), "= 0 ;"))

usage->_read = false;

usage->_lastAccess = tok;

}

}

void Variables::writeAliases(nonneg int varid, const Token* tok)

{

VariableUsage *usage = find(varid);

if (usage) {

for (std::set<nonneg int>::const_iterator aliases = usage->_aliases.cbegin(); aliases != usage->_aliases.cend(); ++aliases) {

VariableUsage *aliased = find(*aliases);

if (aliased) {

aliased->_write = true;

aliased->_lastAccess = tok;

}

}

}

}

void Variables::writeAll(nonneg int varid, const Token* tok)

{

write(varid, tok);

writeAliases(varid, tok);

}

void Variables::use(nonneg int varid, const Token* tok)

{

VariableUsage *usage = find(varid);

if (usage) {

usage->use();

usage->_lastAccess = tok;

for (std::set<nonneg int>::const_iterator aliases = usage->_aliases.cbegin(); aliases != usage->_aliases.cend(); ++aliases) {

VariableUsage *aliased = find(*aliases);

if (aliased) {

aliased->use();

aliased->_lastAccess = tok;

}

}

}

}

void Variables::modified(nonneg int varid, const Token* tok)

{

VariableUsage *usage = find(varid);

if (usage) {

if (!usage->_var->isStatic())

usage->_read = false;

usage->_modified = true;

usage->_lastAccess = tok;

for (std::set<nonneg int>::const_iterator aliases = usage->_aliases.cbegin(); aliases != usage->_aliases.cend(); ++aliases) {

VariableUsage *aliased = find(*aliases);

if (aliased) {

aliased->_modified = true;

aliased->_lastAccess = tok;

}

}

}

}

Variables::VariableUsage *Variables::find(nonneg int varid)

{

if (varid) {

const std::map<nonneg int, VariableUsage>::iterator i = mVarUsage.find(varid);

if (i != mVarUsage.end())

return &i->second;

}

return nullptr;

}

static const Token* doAssignment(Variables &variables, const Token *tok, bool dereference, const Scope *scope)

{

// a = a + b;

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

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

if (tok->varId() == rhsVarTok->varId()) {

return rhsVarTok;

}

}

if (Token::Match(tok, "%var% %assign%") && tok->strAt(1) != "=")

return tok->next();

const Token* const tokOld = tok;

// check for aliased variable

const nonneg int varid1 = tok->varId();

Variables::VariableUsage *var1 = variables.find(varid1);

if (var1) {

// jump behind '='

tok = tok->next();

while (!tok->isAssignmentOp()) {

if (tok->varId())

variables.read(tok->varId(), tok);

tok = tok->next();

}

tok = tok->next();

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

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

if (Token::Match(tok, "( [(<] const| struct|union| %type% *| [>)]"))

tok = tok->next();

if (Token::Match(tok, "(| &| %name%") ||

(Token::Match(tok->next(), "< const| struct|union| %type% *| > ( &| %name%"))) {

bool addressOf = false;

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

variables.use(tok->varId(), tok); // use = read + write

// check for C style cast

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

tok = tok->next();

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

tok = tok->next();

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

tok = tok->next();

while ((tok->isName() && tok->varId() == 0) || (tok->str() == "*") || (tok->str() == ")"))

tok = tok->next();

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

addressOf = true;

tok = tok->next();

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

tok = tok->next();

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

addressOf = true;

tok = tok->next();

}

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

variables.read(tok->next()->varId(), tok);

}

}

// check for C++ style cast

else if (tok->str().find("cast") != std::string::npos &&

tok->strAt(1) == "<") {

tok = tok->tokAt(2);

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

tok = tok->next();

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

tok = tok->next();

tok = tok->next();

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

tok = tok->next();

tok = tok->tokAt(2);

if (!tok)

return tokOld;

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

addressOf = true;

tok = tok->next();

}

}

// no cast, no ?

else if (!Token::Match(tok, "%name% ?")) {

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

addressOf = true;

tok = tok->next();

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

return tokOld;

}

// check if variable is local

const nonneg int varid2 = tok->varId();

const Variables::VariableUsage* var2 = variables.find(varid2);

if (var2) { // local variable (alias or read it)

if (var1->mType == Variables::pointer || var1->mType == Variables::pointerArray) {

if (dereference)

variables.read(varid2, tok);

else {

if (addressOf ||

var2->mType == Variables::array ||

var2->mType == Variables::pointer) {

bool replace = true;

// pointerArray => don't replace

if (var1->mType == Variables::pointerArray)

replace = false;

// check if variable declared in same scope

else if (scope == var1->_var->scope())

replace = true;

// not in same scope as declaration

else {

// no other assignment in this scope

if (var1->_assignments.find(scope) == var1->_assignments.end() ||

scope->type == Scope::eSwitch) {

// nothing to replace

// cppcheck-suppress duplicateBranch - remove when TODO below is address

if (var1->_assignments.empty())

replace = false;

// this variable has previous assignments

else {

// TODO: determine if existing aliases should be replaced or merged

replace = false;

}

}

// assignment in this scope

else {

// replace when only one other assignment, merge them otherwise

replace = (var1->_assignments.size() == 1);

}

}

variables.alias(varid1, varid2, replace);

} else if (tok->strAt(1) == "?") {

if (var2->mType == Variables::reference)

variables.readAliases(varid2, tok);

else

variables.read(varid2, tok);

} else {

variables.readAll(varid2, tok);

}

}

} else if (var1->mType == Variables::reference) {

variables.alias(varid1, varid2, true);

} else if (var1->mType == Variables::standard && addressOf) {

variables.alias(varid1, varid2, true);

} else {

if ((var2->mType == Variables::pointer || var2->mType == Variables::pointerArray) && tok->strAt(1) == "[")

variables.readAliases(varid2, tok);

variables.read(varid2, tok);

}

} else { // not a local variable (or an unsupported local variable)

if (var1->mType == Variables::pointer && !dereference) {

// check if variable declaration is in this scope

if (var1->_var->scope() == scope) {

// If variable is used in RHS then "use" variable

for (const Token *rhs = tok; rhs && rhs->str() != ";"; rhs = rhs->next()) {

if (rhs->varId() == varid1) {

variables.use(varid1, tok);

break;

}

}

variables.clearAliases(varid1);

} else {

// no other assignment in this scope

if (var1->_assignments.find(scope) == var1->_assignments.end()) {

/**

* @todo determine if existing aliases should be discarded

*/

}

// this assignment replaces the last assignment in this scope

else {

// aliased variables in a larger scope are not supported

// remove all aliases

variables.clearAliases(varid1);

}

}

}

}

} else

tok = tokOld;

var1->_assignments.insert(scope);

}

// check for alias to struct member

// char c[10]; a.b = c;

else if (Token::Match(tok->tokAt(-2), "%name% .")) {

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

if (rhsVarTok && rhsVarTok->varId()) {

const nonneg int varid2 = rhsVarTok->varId();

const Variables::VariableUsage *var2 = variables.find(varid2);

// struct member aliased to local variable

if (var2 && (var2->mType == Variables::array ||

var2->mType == Variables::pointer)) {

// erase aliased variable and all variables that alias it

// to prevent false positives

variables.eraseAll(varid2);

}

}

}

// Possible pointer alias

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

const nonneg int varid2 = tok->tokAt(2)->varId();

const Variables::VariableUsage *var2 = variables.find(varid2);

if (var2 && (var2->mType == Variables::array ||

var2->mType == Variables::pointer)) {

variables.use(varid2,tok);

}

}

return tok;

}

static bool isPartOfClassStructUnion(const Token* tok)

{

for (; tok; tok = tok->previous()) {

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

tok = tok->link();

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

return false;

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

return (tok->strAt(-1) == "struct" || tok->strAt(-2) == "struct" || tok->strAt(-1) == "class" || tok->strAt(-2) == "class" || tok->strAt(-1) == "union" || tok->strAt(-2) == "union");

}

}

return false;

}

static bool isVarDecl(const Token *tok)

{

return tok && tok->variable() && tok->variable()->nameToken() == tok;

}

// Skip [ .. ]

static const Token * skipBrackets(const Token *tok)

{

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

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

return tok;

}

// Skip [ .. ] . x

static const Token * skipBracketsAndMembers(const Token *tok)

{

while (tok) {

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

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

else if (Token::Match(tok, ". %name%"))

tok = tok->tokAt(2);

else

break;

}

return tok;

}

static void useFunctionArgs(const Token *tok, Variables& variables)

{

// TODO: Match function args to see if they are const or not. Assume that const data is not written.

if (!tok)

return;

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

useFunctionArgs(tok->astOperand1(), variables);

useFunctionArgs(tok->astOperand2(), variables);

} else if (Token::Match(tok, "[+:]") && (!tok->valueType() || tok->valueType()->pointer)) {

useFunctionArgs(tok->astOperand1(), variables);

useFunctionArgs(tok->astOperand2(), variables);

} else if (tok->variable() && tok->variable()->isArray()) {

variables.use(tok->varId(), tok);

}

}

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

// Usage of function variables

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

void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const scope, Variables& variables)

{

// Find declarations if the scope is executable..

if (scope->isExecutable()) {

// Find declarations

for (std::list<Variable>::const_iterator i = scope->varlist.cbegin(); i != scope->varlist.cend(); ++i) {

if (i->isThrow() || i->isExtern())

continue;

Variables::VariableType type = Variables::none;

if (i->isArray() && (i->nameToken()->previous()->str() == "*" || i->nameToken()->strAt(-2) == "*"))

type = Variables::pointerArray;

else if (i->isArray() && i->nameToken()->previous()->str() == "&")

type = Variables::referenceArray;

else if (i->isArray())

type = Variables::array;

else if (i->isReference() && !(i->valueType() && i->valueType()->type == ValueType::UNKNOWN_TYPE && Token::simpleMatch(i->typeStartToken(), "auto")))

type = Variables::reference;

else if (i->nameToken()->previous()->str() == "*" && i->nameToken()->strAt(-2) == "*")

type = Variables::pointerPointer;

else if (i->isPointerToArray())

type = Variables::pointerPointer;

else if (i->isPointer())

type = Variables::pointer;

else if (mTokenizer->isC() ||

i->typeEndToken()->isStandardType() ||

isRecordTypeWithoutSideEffects(i->type()) ||

mSettings->library.detectContainer(i->typeStartToken()) ||

i->isStlType())

type = Variables::standard;

if (type == Variables::none || isPartOfClassStructUnion(i->typeStartToken()))

continue;

const Token* defValTok = i->nameToken()->next();

if (Token::Match(i->nameToken()->previous(), "* %var% ) (")) // function pointer. Jump behind parameter list.

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

for (; defValTok; defValTok = defValTok->next()) {

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

defValTok = defValTok->link();

else if (defValTok->str() == "(" || defValTok->str() == "{" || defValTok->str() == "=" || defValTok->str() == ":") {

variables.addVar(&*i, type, true);

break;

} else if (defValTok->str() == ";" || defValTok->str() == "," || defValTok->str() == ")") {

variables.addVar(&*i, type, i->isStatic() && i->scope()->type != Scope::eFunction);

break;

}

}

if (i->isArray() && i->isClass() && // Array of class/struct members. Initialized by ctor except for std::array

!(i->isStlType() && i->valueType() && i->valueType()->containerTypeToken && i->valueType()->containerTypeToken->isStandardType()))

variables.write(i->declarationId(), i->nameToken());

if (i->isArray() && Token::Match(i->nameToken(), "%name% [ %var% ]")) // Array index variable read.

variables.read(i->nameToken()->tokAt(2)->varId(), i->nameToken());

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

// simple assignment "var = 123"

if (defValTok->str() == "=" && defValTok->next()->str() != "{") {

doAssignment(variables, i->nameToken(), false, scope);

} else {

// could be "var = {...}" OR "var{...}" (since C++11)

const Token* tokBraceStart = nullptr;

if (Token::simpleMatch(defValTok, "= {")) {

// "var = {...}"

tokBraceStart = defValTok->next();

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

// "var{...}"

tokBraceStart = defValTok;

}

if (tokBraceStart) {

for (const Token* tok = tokBraceStart->next(); tok && tok != tokBraceStart->link(); tok = tok->next()) {

if (tok->varId()) {

// Variables used to initialize the array read.

variables.read(tok->varId(), i->nameToken());

}

}

}

}

}

}

}

// Check variable usage

const Token *tok;

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

tok = scope->bodyStart->next();

else

tok = scope->classDef->next();

for (; tok && tok != scope->bodyEnd; tok = tok->next()) {

if (tok->str() == "{" && tok != scope->bodyStart && !tok->previous()->varId()) {

if (std::any_of(scope->nestedList.cbegin(), scope->nestedList.cend(), [&](const Scope* s) {

return s->bodyStart == tok;

})) {

checkFunctionVariableUsage_iterateScopes(tok->scope(), variables); // Scan child scope

tok = tok->link();

}

if (!tok)

break;

}

if (Token::Match(tok, "asm ( %str% )")) {

variables.clear();

break;

}

// templates

if (tok->isName() && endsWith(tok->str(), '>')) {

// TODO: This is a quick fix to handle when constants are used

// as template parameters. Try to handle this better, perhaps

// only remove constants.

variables.clear();

}

else if (Token::Match(tok->previous(), "[;{}]")) {

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

if (tok2->varId()) {

// Is this a variable declaration?

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

if (!var || var->nameToken() != tok2)

continue;

// Mark template parameters used in declaration as use..

if (tok2->strAt(-1) == ">") {

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

if (tok3->varId())

variables.use(tok3->varId(), tok3);

}

}

// Skip variable declaration..

tok = tok2->next();

if (Token::Match(tok, "( %name% )")) // Simple initialization through copy ctor

tok = tok->next();

else if (Token::Match(tok, "= %var% ;")) { // Simple initialization

tok = tok->next();

if (!var->isReference())

variables.read(tok->varId(), tok);

} else if (tok->str() == "[" && Token::simpleMatch(skipBrackets(tok),"= {")) {

const Token * const rhs1 = skipBrackets(tok)->next();

for (const Token *rhs = rhs1->link(); rhs != rhs1; rhs = rhs->previous()) {

if (rhs->varId())

variables.readAll(rhs->varId(), rhs);

}

} else if (var->typeEndToken()->str() == ">") // Be careful with types like std::vector

tok = tok->previous();

break;

}

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

break;

}

}

// Freeing memory (not considered "using" the pointer if it was also allocated in this function)

if ((Token::Match(tok, "%name% ( %var% )") && mSettings->library.getDeallocFuncInfo(tok)) ||

(mTokenizer->isCPP() && (Token::Match(tok, "delete %var% ;") || Token::Match(tok, "delete [ ] %var% ;")))) {

nonneg int varid = 0;

if (tok->str() != "delete") {

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

varid = varTok->varId();

tok = varTok->next();

} else if (tok->strAt(1) == "[") {

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

varid = varTok->varId();

tok = varTok;

} else {

varid = tok->next()->varId();

tok = tok->next();

}

const Variables::VariableUsage *const var = variables.find(varid);

if (var) {

if (!var->_aliases.empty())

variables.use(varid, tok);

else if (!var->_allocateMemory)

variables.readAll(varid, tok);

}

}

else if (Token::Match(tok, "return|throw")) {

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

if (tok2->varId())

variables.readAll(tok2->varId(), tok);

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

break;

}

}

// assignment

else if (Token::Match(tok, "*| ++|--| %name% ++|--| %assign%") ||

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

bool dereference = false;

bool pre = false;

bool post = false;

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

dereference = true;

tok = tok->next();

}

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

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

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

tok = tok->next();

if (tok->tokType() == Token::eIncDecOp) {

pre = true;

tok = tok->next();

}

if (tok->next()->tokType() == Token::eIncDecOp)

post = true;

const nonneg int varid1 = tok->varId();

const Token * const start = tok;

// assignment in while head..

bool inwhile = false;

{

const Token *parent = tok->astParent();

while (parent) {

if (Token::simpleMatch(parent->previous(), "while (")) {

inwhile = true;

break;

}

parent = parent->astParent();

}

}

tok = doAssignment(variables, tok, dereference, scope);

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

variables.use(varid1, tok);

if (Token::Match(tok, "%assign% %name%")) {

tok = tok->next();

variables.read(tok->varId(), tok);

}

}

if (pre || post)

variables.use(varid1, tok);

if (dereference) {

const Variables::VariableUsage *const var = variables.find(varid1);

if (var && var->mType == Variables::array)

variables.write(varid1, tok);

variables.writeAliases(varid1, tok);

variables.read(varid1, tok);

} else {

const Variables::VariableUsage *const var = variables.find(varid1);

if (var && (inwhile || start->strAt(-1) == ",")) {

variables.use(varid1, tok);

} else if (var && var->mType == Variables::reference) {

variables.writeAliases(varid1, tok);

variables.read(varid1, tok);

}

// Consider allocating memory separately because allocating/freeing alone does not constitute using the variable

else if (var && var->mType == Variables::pointer &&

Token::Match(start, "%name% =") &&

findAllocFuncCallToken(start->next()->astOperand2(), mSettings->library)) {

const Token *allocFuncCallToken = findAllocFuncCallToken(start->next()->astOperand2(), mSettings->library);

const Library::AllocFunc *allocFunc = mSettings->library.getAllocFuncInfo(allocFuncCallToken);

bool allocateMemory = !allocFunc || Library::ismemory(allocFunc->groupId);

if (allocFuncCallToken->str() == "new") {

const Token *type = allocFuncCallToken->next();

// skip nothrow

if (mTokenizer->isCPP() && (Token::simpleMatch(type, "( nothrow )") ||

Token::simpleMatch(type, "( std :: nothrow )")))

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

// is it a user defined type?

if (!type->isStandardType()) {

const Variable *variable = start->variable();

if (!variable || !isRecordTypeWithoutSideEffects(variable->type()))

allocateMemory = false;

}

}

if (allocateMemory)

variables.allocateMemory(varid1, tok);

else

variables.write(varid1, tok);

} else if (varid1 && Token::Match(tok, "%varid% .", varid1)) {

variables.read(varid1, tok);

variables.write(varid1, start);

} else {

variables.write(varid1, tok);

}

}

const Variables::VariableUsage * const var2 = variables.find(tok->varId());

if (var2) {

if (var2->mType == Variables::reference) {

variables.writeAliases(tok->varId(), tok);

variables.read(tok->varId(), tok);

} else if (tok->varId() != varid1 && Token::Match(tok, "%name% .|["))

variables.read(tok->varId(), tok);

else if (tok->varId() != varid1 &&

var2->mType == Variables::standard &&

tok->strAt(-1) != "&")

variables.use(tok->varId(), tok);

}

const Token * const equal = skipBracketsAndMembers(tok->next());

// checked for chained assignments

if (tok != start && equal && equal->str() == "=") {

const nonneg int varId = tok->varId();

const Variables::VariableUsage * const var = variables.find(varId);

if (var && var->mType != Variables::reference) {