std::map<unsigned int, MathLib::bigint> intvalues;

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

void setValue(unsigned int varid, const ValueFlow::Value &value) {

if (value.tokvalue) {

intvalues.erase(varid);

tokvalues[varid] = value.tokvalue;

} else {

intvalues[varid] = value.intvalue;

tokvalues.erase(varid);

}

}

bool getIntValue(unsigned int varid, MathLib::bigint* result) const {

const std::map<unsigned int, MathLib::bigint>::const_iterator it = intvalues.find(varid);

if (it != intvalues.end())

*result = it->second;

return (it != intvalues.end());

}

void setIntValue(unsigned int varid, MathLib::bigint value) {

intvalues[varid] = value;

tokvalues.erase(varid);

}

bool hasValue(unsigned int varid) {

return intvalues.find(varid) != intvalues.end() ||

tokvalues.find(varid) != tokvalues.end();

}

void swap(ProgramMemory &pm) {

intvalues.swap(pm.intvalues);

tokvalues.swap(pm.tokvalues);

}

void clear() {

intvalues.clear();

tokvalues.clear();

}

bool empty() const {

return intvalues.empty() && tokvalues.empty();

}

{

std::list<ErrorLogger::ErrorMessage::FileLocation> callstack;

callstack.push_back(ErrorLogger::ErrorMessage::FileLocation(tok,tokenlist));

ErrorLogger::ErrorMessage errmsg(callstack, Severity::debug, "ValueFlow bailout: " + what, "valueFlowBailout", false);

errorLogger->reportErr(errmsg);

{

if (!tok)

return false;

// address of variable

const bool addressOf = tok && Token::simpleMatch(tok->previous(), "&");

// passing variable to subfunction?

if (Token::Match(tok->tokAt(-2), ") & %name% [,)]") && Token::Match(tok->linkAt(-2)->previous(), "[,(] ("))

;

else if (Token::Match(tok->tokAt(addressOf?-2:-1), "[(,] &| %name% [,)]"))

;

else

return false;

// reinterpret_cast etc..

if (Token::Match(tok->tokAt(-3), "> ( & %name% ) [,)]") &&

tok->linkAt(-3) &&

Token::Match(tok->linkAt(-3)->tokAt(-2), "[,(] %type% <"))

tok = tok->linkAt(-3);

// goto start of function call and get argnr

unsigned int argnr = 0;

while (tok && tok->str() != "(") {

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

++argnr;

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

tok = tok->link();

tok = tok->previous();

}

tok = tok ? tok->previous() : nullptr;

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

return false; // not a function => do not bailout

if (!tok->function()) {

// if value is 0 and the library says 0 is invalid => do not bailout

if (value.intvalue==0 && settings->library.isnullargbad(tok, 1+argnr))

return false;

// addressOf => inconclusive

if (!addressOf) {

*inconclusive = true;

return false;

}

return true;

}

const Variable *arg = tok->function()->getArgumentVar(argnr);

if (addressOf && !(arg && arg->isConst()))

return true;

return arg && !arg->isConst() && arg->isReference();

{

if (!condition)

return false;

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

const bool result1 = conditionIsFalse(condition->astOperand1(), programMemory);

const bool result2 = result1 ? true : conditionIsFalse(condition->astOperand2(), programMemory);

return result2;

}

ProgramMemory progmem(programMemory);

MathLib::bigint result = 0;

bool error = false;

execute(condition, &progmem, &result, &error);

return !error && result == 0;

{

if (!condition)

return false;

if (condition->str() == "||") {

const bool result1 = conditionIsTrue(condition->astOperand1(), programMemory);

const bool result2 = result1 ? true : conditionIsTrue(condition->astOperand2(), programMemory);

return result2;

}

ProgramMemory progmem(programMemory);

bool error = false;

MathLib::bigint result = 0;

execute(condition, &progmem, &result, &error);

return !error && result == 1;

{

ProgramMemory programMemory;

programMemory.setValue(varid, value);

if (value.varId)

programMemory.setIntValue(value.varId, value.varvalue);

const ProgramMemory programMemory1(programMemory);

int indentlevel = 0;

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

if (Token::Match(tok2, "[;{}] %varid% = %var% ;", varid)) {

const Token *vartok = tok2->tokAt(3);

programMemory.setValue(vartok->varId(), value);

}

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

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

if (!programMemory.hasValue(vartok->varId())) {

MathLib::bigint result = 0;

bool error = false;

execute(tok2->tokAt(2)->astOperand2(), &programMemory, &result, &error);

if (!error)

programMemory.setIntValue(vartok->varId(), result);

}

}

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

if (indentlevel <= 0)

break;

--indentlevel;

}

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

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

cond = Token::simpleMatch(cond->previous(), ") {") ? cond->linkAt(-1) : nullptr;

if (cond && conditionIsFalse(cond->astOperand2(), programMemory1))

tok2 = cond->previous();

else if (cond && conditionIsTrue(cond->astOperand2(), programMemory1)) {

++indentlevel;

continue;

} else

break;

}

}

return programMemory;

{

const Token *parent = tok;

while (parent) {

const Token *op = parent;

parent = parent->astParent();

// Assignment where lhs variable exists in rhs => return true

if (parent != nullptr &&

parent->astOperand2() == op &&

parent->astOperand1() != nullptr &&

parent->str() == "=") {

for (const Token *lhs = parent->astOperand1(); lhs; lhs = lhs->astOperand1()) {

if (lhs->varId() == tok->varId())

return true;

if (lhs->astOperand2() && lhs->astOperand2()->varId() == tok->varId())

return true;

}

}

}

return false;

{

if (!tok)

return false;

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

if (prev && Token::simpleMatch(prev->previous(), "} ;"))

prev = prev->previous();

if (Token::simpleMatch(prev, "}")) {

if (Token::simpleMatch(prev->link()->tokAt(-2), "} else {"))

return isReturn(prev) && isReturn(prev->link()->tokAt(-2));

if (Token::simpleMatch(prev->link()->previous(), ") {") &&

Token::simpleMatch(prev->link()->linkAt(-1)->previous(), "switch (") &&

!Token::findsimplematch(prev->link(), "break", prev)) {

return true;

}

} else if (Token::simpleMatch(prev, ";")) {

// noreturn function

if (Token::simpleMatch(prev->previous(), ") ;") && Token::Match(prev->linkAt(-1)->tokAt(-2), "[;{}] %name% ("))

return true;

// return/goto statement

prev = prev->previous();

while (prev && !Token::Match(prev, ";|{|}|return|goto|throw|continue|break"))

prev = prev->previous();

return prev && prev->isName();

}

return false;

{

for (const Token *tok = start; tok != end; tok = tok->next()) {

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

if (Token::Match(tok, "%name% =|++|--"))

return true;

if (Token::Match(tok->previous(), "++|-- %name%"))

return true;

if (Token::Match(tok->tokAt(-2), "[(,] & %var% [,)]"))

return true; // TODO: check if function parameter is const

if (Token::Match(tok->previous(), "[(,] %var% [,)]")) {

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

while (parent && parent->str() == ",")

parent = parent->astParent();

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

if (parent->astOperand1() && parent->astOperand1()->isName() && !parent->astOperand1()->function())

return true;

// TODO: check if function parameter is non-const reference etc..

}

}

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

while (Token::Match(parent, ".|::"))

parent = parent->astParent();

if (parent && parent->tokType() == Token::eIncDecOp)

return true;

}

}

return false;

{

if (value.isKnown()) {

// Clear all other values since value is known

tok->values.clear();

}

// Don't handle more than 10 values for performance reasons

// TODO: add setting?

if (tok->values.size() >= 10U)

return false;

// if value already exists, don't add it again

std::list<ValueFlow::Value>::iterator it;

for (it = tok->values.begin(); it != tok->values.end(); ++it) {

// different intvalue => continue

if (it->intvalue != value.intvalue)

continue;

// different tokvalue => continue

if ((it->tokvalue == nullptr) != (value.tokvalue == nullptr))

continue;

if ((value.tokvalue != nullptr) && (it->tokvalue != value.tokvalue) && (it->tokvalue->str() != value.tokvalue->str()))

continue;

// same value, but old value is inconclusive so replace it

if (it->inconclusive && !value.inconclusive) {

*it = value;

if (it->varId == 0)

it->varId = tok->varId();

break;

}

// Same value already exists, don't add new value

return false;

}

// Add value

if (it == tok->values.end()) {

ValueFlow::Value v(value);

if (v.varId == 0)

v.varId = tok->varId();

tok->values.push_back(v);

}

return true;

{

if (!addValue(tok,value))

return;

Token *parent = const_cast<Token*>(tok->astParent());

if (!parent)

return;

// Cast..

if (parent->str() == "(" && tok == parent->link()->next()) {

setTokenValue(parent,value);

}

else if (parent->str() == ":") {

setTokenValue(parent,value);

}

else if (parent->str() == "?" && tok->str() == ":" && tok == parent->astOperand2()) {

// is condition only depending on 1 variable?

std::stack<const Token*> tokens;

tokens.push(parent->astOperand1());

unsigned int varId = 0;

while (!tokens.empty()) {

const Token *t = tokens.top();

tokens.pop();

if (!t)

continue;

tokens.push(t->astOperand1());

tokens.push(t->astOperand2());

if (t->varId()) {

if (varId > 0 || value.varId != 0U)

return;

varId = t->varId();

} else if (t->str() == "(" && Token::Match(t->previous(), "%name%"))

return; // function call

}

ValueFlow::Value v(value);

v.conditional = true;

v.changeKnownToPossible();

if (varId)

v.varId = varId;

setTokenValue(parent, v);

}

// Calculations..

else if ((parent->isArithmeticalOp() || parent->isComparisonOp() || (parent->tokType() == Token::eBitOp)) &&

parent->astOperand1() &&

parent->astOperand2()) {

const bool known = ((parent->astOperand1()->values.size() == 1U &&

parent->astOperand1()->values.front().isKnown()) ||

(parent->astOperand2()->values.size() == 1U &&

parent->astOperand2()->values.front().isKnown()));

std::list<ValueFlow::Value>::const_iterator value1, value2;

for (value1 = parent->astOperand1()->values.begin(); value1 != parent->astOperand1()->values.end(); ++value1) {

if (value1->tokvalue && (!parent->isComparisonOp() || value1->tokvalue->tokType() != Token::eString))

continue;

for (value2 = parent->astOperand2()->values.begin(); value2 != parent->astOperand2()->values.end(); ++value2) {

if (value2->tokvalue && (!parent->isComparisonOp() || value2->tokvalue->tokType() != Token::eString || value1->tokvalue))

continue;

if (known || value1->varId == 0U || value2->varId == 0U ||

(value1->varId == value2->varId && value1->varvalue == value2->varvalue && !value1->tokvalue && !value2->tokvalue)) {

ValueFlow::Value result(0);

result.condition = value1->condition ? value1->condition : value2->condition;

result.inconclusive = value1->inconclusive | value2->inconclusive;

result.varId = (value1->varId != 0U) ? value1->varId : value2->varId;

result.varvalue = (result.varId == value1->varId) ? value1->intvalue : value2->intvalue;

if (value1->valueKind == value2->valueKind)

result.valueKind = value1->valueKind;

switch (parent->str()[0]) {

case '+':

result.intvalue = value1->intvalue + value2->intvalue;

setTokenValue(parent, result);

break;

case '-':

result.intvalue = value1->intvalue - value2->intvalue;

setTokenValue(parent, result);

break;

case '*':

result.intvalue = value1->intvalue * value2->intvalue;

setTokenValue(parent, result);

break;

case '/':

if (value2->intvalue == 0)

break;

result.intvalue = value1->intvalue / value2->intvalue;

setTokenValue(parent, result);

break;

case '%':

if (value2->intvalue == 0)

break;

result.intvalue = value1->intvalue % value2->intvalue;

setTokenValue(parent, result);

break;

case '=':

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

if (value1->tokvalue || value2->tokvalue)

result.intvalue = 0;

else

result.intvalue = value1->intvalue == value2->intvalue;

setTokenValue(parent, result);

}

break;

case '!':

if (parent->str() == "!=") {

if (value1->tokvalue || value2->tokvalue)

result.intvalue = 1;

else

result.intvalue = value1->intvalue != value2->intvalue;

setTokenValue(parent, result);

}

break;

case '>':

if (value1->tokvalue || value2->tokvalue)

break;

if (parent->str() == ">")

result.intvalue = value1->intvalue > value2->intvalue;

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

result.intvalue = value1->intvalue >= value2->intvalue;

else

break;

setTokenValue(parent, result);

break;

case '<':

if (value1->tokvalue || value2->tokvalue)

break;

if (parent->str() == "<")

result.intvalue = value1->intvalue < value2->intvalue;

else if (parent->str() == "<=")

result.intvalue = value1->intvalue <= value2->intvalue;

else

break;

setTokenValue(parent, result);

break;

case '&':

result.intvalue = value1->intvalue & value2->intvalue;

setTokenValue(parent, result);

break;

case '|':

result.intvalue = value1->intvalue | value2->intvalue;

setTokenValue(parent, result);

break;

case '^':

result.intvalue = value1->intvalue ^ value2->intvalue;

setTokenValue(parent, result);

break;

default:

// unhandled operator, do nothing

break;

}

}

}

}

}

// !

else if (parent->str() == "!") {

std::list<ValueFlow::Value>::const_iterator it;

for (it = tok->values.begin(); it != tok->values.end(); ++it) {

if (it->tokvalue)

continue;

ValueFlow::Value v(*it);

v.intvalue = !v.intvalue;

setTokenValue(parent, v);

}

}

// Array element

else if (parent->str() == "[" && parent->astOperand1() && parent->astOperand2()) {

std::list<ValueFlow::Value>::const_iterator value1, value2;

for (value1 = parent->astOperand1()->values.begin(); value1 != parent->astOperand1()->values.end(); ++value1) {

if (!value1->tokvalue)

continue;

for (value2 = parent->astOperand2()->values.begin(); value2 != parent->astOperand2()->values.end(); ++value2) {

if (value2->tokvalue)

continue;

if (value1->varId == 0U || value2->varId == 0U ||

(value1->varId == value2->varId && value1->varvalue == value2->varvalue)) {

ValueFlow::Value result(0);

result.condition = value1->condition ? value1->condition : value2->condition;

result.inconclusive = value1->inconclusive | value2->inconclusive;

result.varId = (value1->varId != 0U) ? value1->varId : value2->varId;

result.varvalue = (result.varId == value1->varId) ? value1->intvalue : value2->intvalue;

if (value1->tokvalue->tokType() == Token::eString) {

const std::string s = value1->tokvalue->strValue();

const MathLib::bigint index = value2->intvalue;

if (index >= 0 && index < s.size()) {

result.intvalue = s[index];

setTokenValue(parent, result);

}

} else if (value1->tokvalue->str() == "{") {

MathLib::bigint index = value2->intvalue;

const Token *element = value1->tokvalue->next();

while (index > 0 && element->str() != "}") {

if (element->str() == ",")

--index;

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

break;

element = element->next();

}

if (Token::Match(element, "%num% [,}]")) {

result.intvalue = MathLib::toLongNumber(element->str());

setTokenValue(parent, result);

}

}

}

}

}

}

{

for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {

if (tok->isNumber() && MathLib::isInt(tok->str())) {

ValueFlow::Value value(MathLib::toLongNumber(tok->str()));

value.setKnown();

setTokenValue(tok, value);

}

}

if (tokenlist->isCPP()) {

for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {

if (tok->isName() && !tok->varId() && Token::Match(tok, "false|true")) {

ValueFlow::Value value(tok->str() == "true");

value.setKnown();

setTokenValue(tok, value);

}

}

}

{

for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {

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

ValueFlow::Value strvalue;

strvalue.tokvalue = tok;

strvalue.setKnown();

setTokenValue(tok, strvalue);

}

}

{

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

for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {

if (tok->varId() > 0U) {

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

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

ValueFlow::Value value;

value.tokvalue = it->second;

setTokenValue(tok, value);

}

continue;

}

if (Token::Match(tok, "const %type% %var% [ %num%| ] = {")) {

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

const Token *rhstok = vartok->next()->link()->tokAt(2);

constantArrays[vartok->varId()] = rhstok;

tok = rhstok->link();

continue;

}

if (Token::Match(tok, "const char %var% [ %num%| ] = %str% ;")) {

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

const Token *strtok = vartok->next()->link()->tokAt(2);

constantArrays[vartok->varId()] = strtok;

tok = strtok->next();

continue;

}

}

{

for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {

// not address of

if (tok->str() != "&" || tok->astOperand2())

continue;

// parent should be a '='

if (!Token::simpleMatch(tok->astParent(), "="))

continue;

// child should be some buffer or variable

if (!Token::Match(tok->astOperand1(), "%name%|.|[|;"))

continue;

ValueFlow::Value value;

value.tokvalue = tok;

setTokenValue(tok, value);

}

{

for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {

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

continue;

if (!tok->astOperand1() || !tok->astOperand2())

continue;

MathLib::bigint number;

if (MathLib::isInt(tok->astOperand1()->str()))

number = MathLib::toLongNumber(tok->astOperand1()->str());

else if (MathLib::isInt(tok->astOperand2()->str()))

number = MathLib::toLongNumber(tok->astOperand2()->str());

else

continue;

int bit = 0;

while (bit <= 60 && ((1LL<<bit) < number))

++bit;

if ((1LL<<bit) == number) {

setTokenValue(tok, ValueFlow::Value(0));

setTokenValue(tok, ValueFlow::Value(number));

}

}

Token *tok,

const Token * const varToken,

ValueFlow::Value val,

ValueFlow::Value val2,

ErrorLogger *errorLogger,

const Settings *settings)

{

const MathLib::bigint num = val.intvalue;

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

const unsigned int varid = varToken->varId();

const Token * const startToken = var->nameToken();

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

if (!tok2 ||

tok2 == startToken ||

(tok2->str() == "{" && tok2->scope()->type == Scope::ScopeType::eFunction)) {

break;

}

if (tok2->varId() == varid) {

// bailout: assignment

if (Token::Match(tok2->previous(), "!!* %name% =")) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "assignment of " + tok2->str());

break;

}

// increment/decrement

if (Token::Match(tok2->previous(), "[;{}] %name% ++|-- ;"))

val.intvalue += (tok2->strAt(1)=="++") ? -1 : 1;

else if (Token::Match(tok2->tokAt(-2), "[;{}] ++|-- %name% ;"))

val.intvalue += (tok2->strAt(-1)=="++") ? -1 : 1;

else if (Token::Match(tok2->previous(), "++|-- %name%") || Token::Match(tok2, "%name% ++|--")) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "increment/decrement of " + tok2->str());

break;

}

// bailout: variable is used in rhs in assignment to itself

if (bailoutSelfAssignment(tok2)) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "variable " + tok2->str() + " is used in rhs in assignment to itself");

break;

}

if (Token::Match(tok2->previous(), "sizeof|.")) {

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

while (Token::Match(prev,"%name%|.") && prev->str() != "sizeof")

prev = prev->previous();

if (prev && prev->str() == "sizeof")

continue;

}

// assigned by subfunction?

bool inconclusive = false;

if (bailoutFunctionPar(tok2,val2.condition ? val2 : val, settings, &inconclusive)) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "possible assignment of " + tok2->str() + " by subfunction");

break;

}

val.inconclusive |= inconclusive;

val2.inconclusive |= inconclusive;

// skip if variable is conditionally used in ?: expression

if (const Token *parent = skipValueInConditionalExpression(tok2)) {

if (settings->debugwarnings)

bailout(tokenlist,

errorLogger,

tok2,

"no simplification of " + tok2->str() + " within " + (Token::Match(parent,"[?:]") ? "?:" : parent->str()) + " expression");

continue;

}

setTokenValue(tok2, val);

if (val2.condition)

setTokenValue(tok2,val2);

if (var && tok2 == var->nameToken())

break;

}

// skip sizeof..

if (tok2->str() == ")" && Token::Match(tok2->link()->previous(), "typeof|sizeof ("))

tok2 = tok2->link();

// goto label

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

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2->next(), "variable " + var->name() + " stopping on goto label");

break;

}

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

const Token *vartok = Token::findmatch(tok2->link(), "%varid%", tok2, varid);

while (Token::Match(vartok, "%name% = %num% ;") && !vartok->tokAt(2)->getValue(num))

vartok = Token::findmatch(vartok->next(), "%varid%", tok2, varid);

if (vartok) {

if (settings->debugwarnings) {

std::string errmsg = "variable ";

if (var)

errmsg += var->name() + " ";

errmsg += "stopping on }";

bailout(tokenlist, errorLogger, tok2, errmsg);

}

break;

} else {

tok2 = tok2->link();

}

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

// if variable is assigned in loop don't look before the loop

if (tok2->previous() &&

(Token::simpleMatch(tok2->previous(), "do") ||

(tok2->strAt(-1) == ")" && Token::Match(tok2->linkAt(-1)->previous(), "for|while (")))) {

const Token *start = tok2;

const Token *end = start->link();

if (isVariableChanged(start,end,varid)) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " is assigned in loop. so valueflow analysis bailout when start of loop is reached.");

break;

}

}

// Global variable : stop when leaving the function scope

if (!var->isLocal()) {

if (!Token::Match(tok2->previous(), ")|else|do {"))

break;

if ((tok2->previous()->str() == ")") &&

!Token::Match(tok2->linkAt(-1)->previous(), "if|for|while ("))

break;

}

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

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

while (parent && !Token::Match(parent, "return|break|continue|goto"))

parent = parent->astParent();

// reaching a break/continue/return

if (parent) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " stopping on " + parent->str());

break;

}

}

}

{

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

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

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

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

MathLib::bigint num = 0;

const Token *vartok = nullptr;

if (tok->isComparisonOp() && tok->astOperand1() && tok->astOperand2()) {

if (tok->astOperand1()->isName() && tok->astOperand2()->isNumber()) {

vartok = tok->astOperand1();

num = MathLib::toLongNumber(tok->astOperand2()->str());

} else if (tok->astOperand1()->isNumber() && tok->astOperand2()->isName()) {

vartok = tok->astOperand2();

num = MathLib::toLongNumber(tok->astOperand1()->str());

} else {

continue;

}

} else if (Token::Match(tok->previous(), "if|while ( %name% %oror%|&&|)") ||

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

vartok = tok->next();

num = 0;

} else if (tok->str() == "!" && tok->astOperand1() && tok->astOperand1()->isName()) {

vartok = tok->astOperand1();

num = 0;

} else {

continue;

}

unsigned int varid = vartok->varId();

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

if (varid == 0U || !var)

continue;

// bailout: global non-const variables

if (!(var->isLocal() || var->isArgument()) && !var->isConst()) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok, "global variable " + var->name());

continue;

}

// bailout: for/while-condition, variable is changed in while loop

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

if (tok2->astParent() || tok2->str() != "(" || !Token::simpleMatch(tok2->link(), ") {"))

continue;

// Variable changed in 3rd for-expression

if (Token::simpleMatch(tok2->previous(), "for (")) {

if (tok2->astOperand2() && tok2->astOperand2()->astOperand2() && isVariableChanged(tok2->astOperand2()->astOperand2(), tok2->link(), varid)) {

varid = 0U;

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok, "variable " + var->name() + " used in loop");

}

}

// Variable changed in loop code

if (Token::Match(tok2->previous(), "for|while (")) {

const Token * const start = tok2->link()->next();

const Token * const end = start->link();

if (isVariableChanged(start,end,varid)) {

varid = 0U;

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok, "variable " + var->name() + " used in loop");

}

}

// if,macro => bailout

else if (Token::simpleMatch(tok2->previous(), "if (") && tok2->previous()->isExpandedMacro()) {

varid = 0U;

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok, "variable " + var->name() + ", condition is defined in macro");

}

}

if (varid == 0U)

continue;

// extra logic for unsigned variables 'i>=1' => possible value can also be 0

ValueFlow::Value val(tok, num);

val.varId = varid;

if (Token::Match(tok, "<|>")) {

if (num != 0)

continue;

if (!var->typeStartToken()->isUnsigned())

continue;

}

ValueFlow::Value val2;

if (num==1U && Token::Match(tok,"<=|>=")) {

if (var->typeStartToken()->isUnsigned()) {

val2 = ValueFlow::Value(tok,0);

val2.varId = varid;

}

}

valueFlowReverse(tokenlist,

tok,

vartok,

val,

val2,

errorLogger,

settings);

}

}

{

for (std::list<ValueFlow::Value>::iterator it = values.begin(); it != values.end();) {

bool found = false;

for (std::list<ValueFlow::Value>::const_iterator it2 = valuesToRemove.begin(); it2 != valuesToRemove.end(); ++it2) {

if (it->intvalue == it2->intvalue) {

found = true;

break;

}

}

if (found)

values.erase(it++);