{

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;

}

std::map<unsigned int, MathLib::bigint> 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;

}

std::map<unsigned int, MathLib::bigint> progmem(programMemory);

bool error = false;

MathLib::bigint result = 0;

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

return !error && result == 1;

{

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

programMemory[varid] = value.intvalue;

if (value.varId)

programMemory[value.varId] = value.varvalue;

const std::map<unsigned int, MathLib::bigint> 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[vartok->varId()] = value.intvalue;

}

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

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

if (programMemory.find(vartok->varId()) == programMemory.end()) {

MathLib::bigint result = 0;

bool error = false;

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

if (!error)

programMemory[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"))

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;

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

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

parent = parent->astParent();

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

return true;

}

}

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;

break;

}

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

return;

}

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

tok->values.push_back(value);

it = tok->values.end();

--it;

if (it->varId == 0)

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

}

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

if (!parent)

return;

// Cast..

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

setTokenValue(parent,value);

}

// Calculations..

else if (parent->isArithmeticalOp() && parent->astOperand1() && parent->astOperand2()) {

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

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

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

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;

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;

}

}

}

}

}

// 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->type() == 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()))

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

}

{

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

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

ValueFlow::Value strvalue;

strvalue.tokvalue = tok;

setTokenValue(tok, strvalue);

}

}

{

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

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

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();

}

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();

}

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);

}

}

}

{

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));

}

}

{

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()) {

unsigned int varid=0;

MathLib::bigint num=0;

const Variable *var=0;

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

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

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

var = tok->astOperand1()->variable();

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

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

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

var = tok->astOperand2()->variable();

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

} else {

continue;

}

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

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

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

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

num = 0;

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

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

var = tok->astOperand1()->variable();

num = 0;

} else {

continue;

}

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 (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;

}

}

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

if (!tok2 || tok2->next() == scope->classStart) {

if (settings->debugwarnings) {

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

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

ErrorLogger::ErrorMessage errmsg(callstack, Severity::debug, "iterated too far", "debugValueFlowBeforeCondition", false);

errorLogger->reportErr(errmsg);

}

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 (Token::simpleMatch(tok2->previous(), ") {") &&

!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;

}

}

}

}

}

{

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++);

else

++it;

}

{

if (!tok)

return;

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

setTokenValue(tok, value);

valueFlowAST(const_cast<Token*>(tok->astOperand1()), varid, value);

valueFlowAST(const_cast<Token*>(tok->astOperand2()), varid, value);

const Token * const endToken,

const Variable * const var,

const unsigned int varid,

std::list<ValueFlow::Value> values,

const bool constValue,

TokenList * const tokenlist,

ErrorLogger * const errorLogger,

const Settings * const settings)

{

int indentlevel = 0;

unsigned int number_of_if = 0;

int varusagelevel = -1;

bool returnStatement = false; // current statement is a return, stop analysis at the ";"

bool read = false; // is variable value read?

for (Token *tok2 = startToken; tok2 && tok2 != endToken; tok2 = tok2->next()) {

if (indentlevel >= 0 && tok2->str() == "{")

++indentlevel;

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

--indentlevel;

if (indentlevel <= 0 && isReturn(tok2) && Token::Match(tok2->link()->previous(), "else|) {")) {

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

const bool iselse = Token::simpleMatch(condition->tokAt(-2), "} else {");

if (iselse)

condition = condition->linkAt(-2);

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

condition = condition->linkAt(-1)->astOperand2();

else

condition = nullptr;

if (!condition) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " valueFlowForward, bailing out since it's unknown if conditional return is executed");

return false;

}

bool bailoutflag = false;

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

if (!iselse && conditionIsTrue(condition, getProgramMemory(condition->astParent(), varid, *it))) {

bailoutflag = true;

break;

}

if (iselse && conditionIsFalse(condition, getProgramMemory(condition->astParent(), varid, *it))) {

bailoutflag = true;

break;

}

}

if (bailoutflag) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " valueFlowForward, conditional return is assumed to be executed");

return false;

}

}

}

if (Token::Match(tok2, "sizeof|typeof|typeid ("))

tok2 = tok2->linkAt(1);

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

// Should scope be skipped because variable value is checked?

bool skipelse = false;

const Token *condition = tok2->linkAt(-1);

condition = condition ? condition->linkAt(-1) : nullptr;

condition = condition ? condition->astOperand2() : nullptr;

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

if (conditionIsTrue(condition, getProgramMemory(tok2, varid, *it))) {

skipelse = true;

break;

}

}

if (skipelse) {

tok2 = tok2->linkAt(1);

continue;

}

}

// conditional block of code that assigns variable..

else if (Token::Match(tok2, "%name% (") && Token::simpleMatch(tok2->linkAt(1), ") {")) {

// is variable changed in condition?

if (isVariableChanged(tok2->next(), tok2->next()->link(), varid)) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " valueFlowForward, assignment in condition");

return false;

}

// Set values in condition

for (Token* tok3 = tok2->tokAt(2); tok3 != tok2->next()->link(); tok3 = tok3->next()) {

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

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

setTokenValue(tok3, *it);

break;

}

}

// Should scope be skipped because variable value is checked?

std::list<ValueFlow::Value> truevalues;

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

if (!conditionIsFalse(tok2->next()->astOperand2(), getProgramMemory(tok2, varid, *it)))

truevalues.push_back(*it);

}

if (truevalues.size() != values.size()) {

// '{'

Token * const startToken1 = tok2->linkAt(1)->next();

valueFlowForward(startToken1->next(),

startToken1->link(),

var,

varid,

truevalues,

constValue,

tokenlist,

errorLogger,

settings);

if (isVariableChanged(startToken1, startToken1->link(), varid))

removeValues(values, truevalues);

// goto '}'

tok2 = startToken1->link();

continue;

}

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

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

bool varusage = (indentlevel >= 0 && constValue && number_of_if == 0U) ?

isVariableChanged(start,end,varid) :

(nullptr != Token::findmatch(start, "%varid%", end, varid));

if (!read) {

read = bool(nullptr != Token::findmatch(tok2, "%varid% !!=", end, varid));

}

if (varusage) {

varusagelevel = indentlevel;

if (indentlevel < 0 && tok2->str() == "switch")

return false;

// TODO: don't check noreturn scopes

if (read && (number_of_if > 0U || Token::findmatch(tok2, "%varid%", start, varid))) {

// Set values in condition

const Token * const condend = tok2->linkAt(1);

for (Token *condtok = tok2; condtok != condend; condtok = condtok->next()) {

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

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

for (it = values.begin(); it != values.end(); ++it)

setTokenValue(condtok, *it);

}

if (Token::Match(condtok, "%oror%|&&"))

break;

}

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " is assigned in conditional code");

return false;

}

if (var->isStatic()) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " bailout when conditional code that contains var is seen");

return false;

}

// Remove conditional values

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

for (it = values.begin(); it != values.end();) {

if (it->condition || it->conditional)

values.erase(it++);

else

++it;

}

}

// stop after conditional noreturn scopes that are executed

if (isReturn(end)) {

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

for (it = values.begin(); it != values.end();) {

if (conditionIsTrue(tok2->next()->astOperand2(), getProgramMemory(tok2, varid, *it)))

values.erase(it++);

else

++it;

}

if (values.empty())

return false;

}

// noreturn scopes..

if ((number_of_if > 0 || Token::findmatch(tok2, "%varid%", start, varid)) &&

(Token::findmatch(start, "return|continue|break|throw", end) ||

(Token::simpleMatch(end,"} else {") && Token::findmatch(end, "return|continue|break|throw", end->linkAt(2))))) {

if (settings->debugwarnings)

bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + ". noreturn conditional scope.");

return false;

}

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

if ((!read || number_of_if == 0) &&

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

!(Token::simpleMatch(end, "} else {") &&

(Token::findmatch(end, "%varid%", end->linkAt(2), varid) ||

Token::findmatch(end, "return|continue|break|throw", end->linkAt(2))))) {

++number_of_if;

tok2 = end;

} else {

bool bail = true;

// loop that conditionally set variable and then break => either loop condition is

// redundant or the variable can be unchanged after the loop.

bool loopCondition = false;

if (Token::simpleMatch(tok2, "while (") && Token::Match(tok2->next()->astOperand2(), "%op%"))

loopCondition = true;

else if (Token::simpleMatch(tok2, "for (") &&

Token::simpleMatch(tok2->next()->astOperand2(), ";") &&

Token::simpleMatch(tok2->next()->astOperand2()->astOperand2(), ";") &&

Token::Match(tok2->next()->astOperand2()->astOperand2()->astOperand1(), "%op%"))

loopCondition = true;

if (loopCondition) {

const Token *tok3 = Token::findmatch(start, "%varid%", end, varid);

if (Token::Match(tok3, "%varid% =", varid) &&

tok3->scope()->classEnd &&

Token::Match(tok3->scope()->classEnd->tokAt(-3), "[;}] break ;") &&

!Token::findmatch(tok3->next(), "%varid%", end, varid)) {

bail = false;

tok2 = end;

}

}