22699人阅读
杂七杂八（17）
最通俗的理解：表示使目标函数取最小值时的变量值
From&Wikipedia
In&,&arg max&(or&argmax)
stands for the&argument of the maximum, that is to say, the set of points of the given&&for
which the value of the given expression attains its&&value:
In other words,
is the set of values of&x&for which&f(x) has the largest value&M.&For example, if&f(x) is 1-|x|, then it attains
its maximum value of 1 at&x&= 0 and only there, so&.
Equivalently, if&M&is the maximum of&f,&then the arg max is the&&of the maximum:
If the maximum is reached at a single value, then one refers to the point as&the&arg max, meaning we define the arg max as a point, not a set of points. So, for example,
(rather than the&&set&{5}),
since the maximum value of&x(10&-&x) is 25, which happens when&x&= 5.
However, in case the maximum is reached at many values,&arg max&is a&set&of points.
Then, we have for example
since the maximum value of cos(x) is 1, which happens on this interval when&x&= 0, 2π or 4π. On the whole real line, the arg max is&
arg min&(or&argmin) is defined analogously.
Note also that functions do not in general attain a maximum value, and hence will in general not have an arg max:&&is
undefined, as&xis&&on
the real line. However, by the&&(or
the classical&), a continuous function
a maximum, and thus an arg max.
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：308134次
积分：3330
积分：3330
排名：第8214名
原创：50篇
转载：48篇
评论：44条
(2)(1)(1)(1)(1)(1)(3)(1)(1)(1)(3)(1)(3)(7)(7)(4)(2)(3)(1)(7)(2)(4)(1)(1)(3)(6)(5)(6)(3)(5)(3)(2)(3)(1)(3)(1)Lisp｜LOFTER（乐乎） - 记录生活，发现同好
LOFTER for ipad —— 记录生活，发现同好
记录生活，发现同好
73位喜爱 #Lisp 的小伙伴邀你来玩
查看高清大图
喜欢并收藏内容
关注达人获取动态
评论私信与同好交流
10秒注册，查看更多优质内容
网易公司版权所有　&　ICP备：浙B2-增值电信业务经营许可证：浙B2-
{if x.type==1}
{if !!x.title}${x.title}{/if}
{if !!x.digest}${x.digest}{/if}
{if x.type==2}
{if x.type==3}
{if x.type==4}
加入 LOFTER 开通功能特权
查看高清大图
喜欢并收藏内容
关注达人获取动态
评论私信与同好交流23 #include &&
25 #include &&
26 #include &&
27 #include &&
28 #include &&
30 #include &algorithm&
31 #include &sstream&
32 #include &list&
33 #include &cstdlib&
34 #include &stack&
39 namespace {
46 static const
47 static const
48 static const
49 static const
50 static const
51 static const
52 static const
 static void (std::ostream& oss, const
&arrayInfo, const std::vector&MathLib::bigint& &index)
oss && &Array '& && arrayInfo.();
for (std::size_t i = 0; i & arrayInfo.().size(); ++i)
oss && &[& && arrayInfo.(i) && &]&;
if (index.size() == 1)
oss && &' accessed at index & && index[0] && &, which is&;
oss && &' index & && arrayInfo.();
for (std::size_t i = 0; i & index.size(); ++i)
oss && &[& && index[i] && &]&;
oss && & out of bounds.&;
 void (const
*tok, const
&arrayInfo, const std::vector&MathLib::bigint& &index)
(oss, arrayInfo, index);
(tok, , &arrayIndexOutOfBounds&, oss.str(), , false);
 void (const
*tok, const
&arrayInfo, const std::vector&ValueFlow::Value& &index)
*condition = nullptr;
for (std::size_t i = 0; i & index.size(); ++i) {
if (condition == nullptr)
condition = index[i].
if (condition != nullptr) {
if (!-&(&warning&))
errmsg && (condition) && & or the array '& && arrayInfo.();
for (std::size_t i = 0; i & arrayInfo.().size(); ++i)
errmsg && &[& && arrayInfo.(i) && &]&;
if (index.size() == 1)
errmsg && &' is accessed at index & && index[0].intvalue && &, which is out of bounds.&;
errmsg && &' index & && arrayInfo.();
for (std::size_t i = 0; i & index.size(); ++i)
errmsg && &[& && index[i].intvalue && &]&;
errmsg && & is out of bounds.&;
std::list&const Token *&
callstack.push_back(tok);
callstack.push_back(condition);
(callstack, , &arrayIndexOutOfBoundsCond&, errmsg.str(), , false);
errmsg && &Array '& && arrayInfo.();
for (std::size_t i = 0; i & arrayInfo.().size(); ++i)
errmsg && &[& && arrayInfo.(i) && &]&;
if (index.size() == 1)
errmsg && &' accessed at index & && index[0].intvalue && &, which is out of bounds.&;
errmsg && &' index & && arrayInfo.();
for (std::size_t i = 0; i & index.size(); ++i)
errmsg && &[& && index[i].intvalue && &]&;
errmsg && & out of bounds.&;
(tok, , &arrayIndexOutOfBounds&, errmsg.str(), , false);
122 }
 void (const std::list&const Token *& &callstack, const
&arrayInfo, const std::vector&MathLib::bigint& &index)
125 {
(oss, arrayInfo, index);
(callstack, , &arrayIndexOutOfBounds&, oss.str());
129 }
 static std::string (std::string varnames)
132 {
varnames.erase(std::remove(varnames.begin(), varnames.end(), ' '), varnames.end());
std::string errmsg(&Buffer is accessed out of bounds&);
if (!varnames.empty())
errmsg += &: & +
errmsg += &.&;
142 }
 void (const
*tok, const std::string &varnames)
145 {
(tok, , &bufferAccessOutOfBounds&, (varnames), , false);
147 }
 void (const std::list&const Token *& &callstack, const std::string &varnames)
151 {
(callstack, , &bufferAccessOutOfBounds&, (varnames));
153 }
 void (const
*tok, const std::string &src, const std::string &dst, bool cat)
156 {
(tok, , &possibleBufferAccessOutOfBounds&,
&Possible buffer overflow if strlen(& + src + &) is larger than sizeof(& + dst + &)-strlen(& + dst +&).\n&
&Possible buffer overflow if strlen(& + src + &) is larger than sizeof(& + dst + &)-strlen(& + dst +&). &
&The source buffer is larger than the destination buffer so there is the potential for overflowing the destination buffer.&, , false);
(tok, , &possibleBufferAccessOutOfBounds&,
&Possible buffer overflow if strlen(& + src + &) is larger than or equal to sizeof(& + dst + &).\n&
&Possible buffer overflow if strlen(& + src + &) is larger than or equal to sizeof(& + dst + &). &
&The source buffer is larger than the destination buffer so there is the potential for overflowing the destination buffer.&, , false);
167 }
 void (const
170 {
if ( && !-&(&warning&))
(tok, , &strncatUsage&,
&Dangerous usage of strncat - 3rd parameter is the maximum number of characters to append.\n&
&At most, strncat appends the 3rd parameter's amount of characters and adds a terminating null byte.\n&
&The safe way to use strncat is to subtract one from the remaining space in the buffer and use it as 3rd parameter.&
&Source: /reference/cstring/strncat/\n&
&Source: http://www./source/Libc/Libc-167/gen.subproj/i386.subproj/strncat.c&, , false);
180 }
 void (const
*tok, const std::string &what, const bool show_size_info, const
&supplied_size, const
&actual_size)
183 {
oss && what && & is out of bounds&;
if (show_size_info)
oss && &: Supplied size & && supplied_size && & is larger than actual size & && actual_
oss && '.';
(tok, , &outOfBounds&, oss.str(), , false);
191 }
 void (const
*tok, const
*index, const
indexvalue)
194 {
const std::string expr(tok ? tok-&() : std::string(&&));
if (index && !index-&()) {
errmsg = &Undefined behaviour, when '& +
index-&() +
&' is & +
(indexvalue) +
& the pointer arithmetic '& + expr + &' is out of bounds&;
errmsg = &Undefined behaviour, pointer arithmetic '& + expr + &' is out of bounds&;
std::string verbosemsg(errmsg + &. From chapter 6.5.6 in the C specification:\n&
&\&When an expression that has integer type is added to or subtracted from a pointer, ..\& and then \&If both the pointer operand and the result point to elements of the same array object, or one past the last element of the array object, the evaluation shall not otherwise, the behavior is undefined.\&&);
(tok, , &pointerOutOfBounds&, errmsg + &.\n& + verbosemsg, , false);
218 }
 void (const
221 {
if ( && !-&(&warning&))
(tok, , &sizeArgumentAsChar&, &The size argument is given as a char constant.&, , false);
225 }
 void (const
*tok, const std::string &varname)
229 {
(tok, , &terminateStrncpy&,
&The buffer '& + varname + &' may not be null-terminated after the call to strncpy().\n&
&If the source string's size fits or exceeds the given size, strncpy() does not add a &
&zero at the end of the buffer. This causes bugs later in the code if the code &
&assumes buffer is null-terminated.&, , true);
235 }
 void (const
238 {
(tok, , &insecureCmdLineArgs&, &Buffer overrun possible for long command line arguments.&, , false);
240 }
 void (const
*tok, const std::string &varname, const std::string &function)
243 {
const std::string errmsg = &The buffer '& + varname + &' is not null-terminated after the call to & + function + &().\n&
&The buffer '& + varname + &' is not null-terminated after the call to & + function + &(). &
&This will cause bugs later in the code if the code assumes the buffer is null-terminated.&;
(tok, , &bufferNotZeroTerminated&, errmsg, , true);
249 }
 void (const
*tok, const std::string &functionName, const std::string &varname)
252 {
(tok, , &argumentSize&, &The array '& + varname + &' is too small, the function '& + functionName + &' expects a bigger one.&, , false);
254 }
 void (const
257 {
(tok, , &negativeMemoryAllocationSize&,
&Memory allocation size is negative.\n&
&Memory allocation size is negative.&
&Negative allocation size has no specified behaviour.&, , false);
262 }
 static bool (const
273 {
*tok2 = tok-&();
while ((tok2, &%name%|.|::|[&))
tok2 = tok2-&();
return tok2 && tok2-&() == &&& && !(tok2-&() && tok2-&());
278 }
 static bool (const
*tok, const unsigned int varid)
287 {
const * end = tok-&(1)-&(1);
if ((end, &} else {&))
end = end-&(2);
if ((end, &{&))
return true;
const bool is_if = tok-&() == &if&;
for (; tok && tok != tok = tok-&()) {
if (is_if && (tok-&() == &break& || tok-&() == &continue&))
return true;
else if (tok-&() == &return&)
return true;
else if (tok-&() == varid)
return true;
return false;
313 }
 static bool (const std::list&Library::ArgumentChecks::MinSize& &minsizes, const
* const ftok, const
arraySize, const
**charSizeToken, const
* const settings)
317 {
if (charSizeToken)
*charSizeToken = nullptr;
if (minsizes.empty())
return false;
bool error = true;
for (std::list&Library::ArgumentChecks::MinSize&::const_iterator minsize = minsizes.begin(); minsize != minsizes.end(); ++minsize) {
if (!error)
return false;
error = false;
*argtok = ftok-&(2);
for (int argnum = 1; argtok && argnum & minsize-& argnum++)
argtok = argtok-&();
if (!argtok)
return false;
switch (minsize-&type) {
if ((argtok, &%num% ,|)&)) {
sz = (argtok-&());
if (sz & arraySize)
error = true;
} else if (argtok-&() ==
&& (argtok-&(), &,|)&) && charSizeToken)
*charSizeToken =
if (minsize-&arg2 == minsize-&arg+1 && (argtok, &%num% , %num% ,|)&)) {
sz = (argtok-&()) * (argtok-&(2));
if (sz & arraySize)
error = true;
if (settings-&.(ftok,minsize-&arg)) {
std::list&const Token *&
const std::string &formatstr(argtok-&());
*argtok2 =
while ((argtok2 = argtok2-&nextArgument()) != nullptr) {
if ((argtok2, &%num%|%str% [,)]&))
parameters.push_back(argtok2);
parameters.push_back(nullptr);
len = (formatstr, parameters);
if (len & arraySize + 2U)
error = true;
*strtoken = argtok-&();
if (strtoken && (strtoken) &= arraySize)
error = true;
if (argtok-&() ==
&& (argtok) &= arraySize)
error = true;
return false;
382 }
 void (const
&ftok, unsigned int paramIndex, const
&arrayInfo, const std::list&const Token *&& callstack)
385 {
const std::list&Library::ArgumentChecks::MinSize& * const minsizes = -&.(&ftok, paramIndex);
if (minsizes) {
arraySize = arrayInfo.();
if (arraySize == 0)
for (std::size_t i = 0; i & arrayInfo.().size(); ++i)
arraySize *= arrayInfo.(i);
if (arraySize == 0)
*charSizeToken = nullptr;
if ((*minsizes, &ftok, arraySize, &charSizeToken, ))
(callstack, arrayInfo.());
if (charSizeToken)
(charSizeToken);
else if (arrayInfo.().size() == 1) {
const * const func = ftok.();
if (func && func-&()) {
const * const parameter = func-&(paramIndex-1);
if (!parameter || (parameter-&()) != arrayInfo.())
if (parameter-&() == 0)
for (const * ftok2 = func-&-&; ftok2 != func-&-&; ftok2 = ftok2-&()) {
if ((ftok2, &if|for|switch|while (&)) {
if ((ftok2, parameter-&())) {
ftok2 = ftok2-&linkAt(1)-&linkAt(1);
if ((ftok2, &} else {&))
ftok2 = ftok2-&linkAt(2);
if (!ftok2)
if (ftok2-&str() == &}&)
if (ftok2-&varId() == parameter-&()) {
if ((ftok2-&previous(), &-- %name%&) ||
(ftok2, &%name% --&))
if ((ftok2-&previous(), &;|{|}|%op% %name% [ %num% ]&)) {
index = (ftok2-&strAt(2));
if (index &= 0 && arrayInfo.(0) & 0 && index &= arrayInfo.(0)) {
std::list&const Token *& callstack2(callstack);
callstack2.push_back(ftok2);
std::vector&MathLib::bigint&
indexes.push_back(index);
(callstack2, arrayInfo, indexes);
if ((ftok2, &%name% (&)) {
ai(arrayInfo);
ai.(parameter-&());
(ftok2, ai, callstack);
if (-&(&warning&)) {
const * const func = ftok.();
if (func) {
const * const argument = func-&(paramIndex-1);
if (argument && (argument-&(), &%type% %var% [ %num% ] [,)[]&)
&& (nameToken = argument-&()) != nullptr) {
*tok2 = nameToken-&();
argsize = (argument-&());
if (argsize == 100)
argsize = 0;
argsize *= (tok2-&(1));
tok2 = tok2-&(3);
} while ((tok2, &[ %num% ] [,)[]&));
arraysize = arrayInfo.();
if (arraysize == 100)
arraysize = 0;
for (std::size_t i = 0; i & arrayInfo.().size(); i++)
arraysize *= arrayInfo.(i);
if ((tok2, &[,)]&) && arraysize & 0 && argsize & arraysize)
(&ftok, ftok.(), arrayInfo.());
508 }
 void (const
*tok, const
&arrayInfo, std::list&const Token *& callstack)
512 {
if (callstack.size() &= 2)
for (std::list&const Token*&::const_iterator it = callstack.cbegin(); it != callstack.cend(); ++it) {
if (tok-&() == (*it)-&str())
callstack.push_back(tok);
const unsigned int declarationId = arrayInfo.();
*argtok = tok-&(2);
unsigned int argnr = 1U;
while (argtok) {
if ((argtok, &%varid% ,|)&, declarationId))
(*tok, argnr, arrayInfo, callstack);
else if ((argtok, &%varid% + %num% ,|)&, declarationId)) {
ai(arrayInfo.((argtok-&(2))));
(*tok, argnr, ai, callstack);
argtok = argtok-&();
541 }
 void (const
*tok, const std::vector&std::string& &varname, const
&arrayInfo)
544 {
size = arrayInfo.(0);
if (size &= 0)
if (tok-&() == &return&) {
tok = tok-&();
const bool printInconclusive = -&;
total_size = arrayInfo.() *
const unsigned int declarationId = arrayInfo.();
for (std::size_t i = 0; i & varname.size(); ++i)
varnames += (i == 0 ? && : & . &) + varname[i];
const int varcount = varname.empty() ? 0 : static_cast&int&((varname.size() - 1) * 2U);
if ((declarationId & 0 && (tok, &%varid% [&, declarationId)) ||
(declarationId == 0 && (tok, (varnames + & [&).c_str()))) {
*tok2 = tok-&();
while (tok2-&() != &[&)
tok2 = tok2-&();
(tok2, arrayInfo);
bool pointerIsOutOfBounds = false;
const bool printPortability = -&(&portability&);
for (const * const end = tok-&()-&classE tok && tok != tok = tok-&()) {
if (declarationId != 0 && (tok, &%varid% = new|malloc|realloc&, declarationId)) {
if (declarationId & 0 && (tok, &[;{}] %varid% = %any%&, declarationId)) {
if (tok-&(3)-&() != declarationId)
pointerIsOutOfBounds = false;
if ((declarationId & 0 && ((tok-&() == &return& || (!tok-&() && !(tok, &[.&]&))) && (tok-&(), &%varid% [&, declarationId))) ||
(declarationId == 0 && ((tok-&() == &return& || (!tok-&() && !(tok, &[.&]&))) && ((tok-&(), (varnames + & [&).c_str()) || (tok-&(), (varname[0] +& [ %num% ] . & + varname[1] + & [ %num% ]&).c_str()))))) {
std::vector&MathLib::bigint&
*tok2 = tok-&(2 + varcount);
for (; (tok2, &[ %num% ]&); tok2 = tok2-&(3)) {
index = (tok2-&(1));
indexes.push_back(index);
for (; (tok2-&(3), &[ %num% ]&); tok2 = tok2-&(3)) {
index = (tok2-&strAt(4));
indexes.push_back(index);
if (indexes.empty() && arrayInfo.().size() == 1U && (tok2, &[&) && tok2-&astOperand2()) {
*value = tok2-&astOperand2()-&getMaxValue(false);
if (value) {
indexes.push_back(value-&);
if (indexes.size() == arrayInfo.().size()) {
totalElements = 1;
totalIndex = 0;
for (std::size_t i = 0; i & indexes.size(); ++i) {
const std::size_t ri = indexes.size() - 1 -
totalIndex += indexes[ri] * totalE
totalElements *= arrayInfo.(ri);
if (arrayInfo.(ri) == -1) {
totalElements = 0;
if (totalElements == 0)
*tok3 = tok-&();
while (tok3 && (tok3-&(), &%name% .&))
tok3 = tok3-&(-2);
if (totalIndex == totalElements) {
const bool addr = (tok3 && (tok3-&() == &&& ||
(tok3-&(), && (&)));
if (totalIndex & totalElements || totalIndex & 0) {
(tok-&(1 + varcount), arrayInfo, indexes);
for (std::size_t i = 0; i & indexes.size(); ++i) {
if (indexes[i] &= arrayInfo.(i)) {
if (indexes.size() == 1U) {
(tok-&(1 + varcount), arrayInfo, indexes);
else if (printInconclusive) {
(tok-&(1 + varcount), arrayInfo, indexes);
tok = tok2;
if (declarationId == 0 && size & 0 && (tok, &%name% ( !!)&)) {
std::list&const Token *&
callstack.push_back(tok);
const * tok2 = tok-&(2);
if ((tok2, (varnames + & ,&).c_str()))
(*tok, 1, arrayInfo, callstack);
tok2 = tok2-&();
if ((tok2, (varnames + & ,&).c_str()))
(*tok, 2, arrayInfo, callstack);
if (total_size & 0) {
if ((declarationId & 0 && (tok, &strcpy|strcat ( %varid% , %str%|%var% )&, declarationId)) ||
(declarationId == 0 && (tok, (&strcpy|strcat ( & + varnames + & , %str%|%var% )&).c_str()))) {
const * lastParamTok = tok-&(varcount + 4);
if (lastParamTok-&() == Token::Type::eString) {
const std::size_t len = (lastParamTok);
if (len &= total_size) {
(tok, declarationId & 0 ?
: varnames);
*var = lastParamTok-&();
if (var && var-&() && var-&().size() == 1) {
len = var-&(0);
if (len & total_size) {
if (printInconclusive)
(tok, tok-&(4), tok-&(2), tok-&() == &strcat&);
const std::string strcatPattern = declarationId & 0 ? std::string(&strcat ( %varid% , %str% ) ;&) : (&strcat ( & + varnames + & , %str% ) ;&);
if ((tok, strcatPattern.c_str(), declarationId)) {
std::size_t charactersAppend = 0;
charactersAppend += (tok2-&(4 + varcount));
if (charactersAppend &= static_cast&std::size_t&(total_size)) {
tok2 = tok2-&(7 + varcount);
} while ((tok2, strcatPattern.c_str(), declarationId));
if ((tok, &%name% (&)) {
if (declarationId == 0)
arrayInfo1(declarationId, varnames, total_size / size, size);
const std::list&const Token *&
(tok, arrayInfo1, callstack);
if (declarationId && (tok, &= %varid% + %num% ;&, declarationId)) {
index = (tok-&(3));
if (printPortability && index & size)
(tok-&(2));
if (index &= size && (tok-&(-2), &[;{}] %varid% =&, declarationId))
pointerIsOutOfBounds = true;
else if (pointerIsOutOfBounds && (tok, &[;{}=] * %varid% [;=]&, declarationId)) {
(tok-&(2), tok-&(2), false, 0, 0);
760 }
 static std::vector&ValueFlow::Value& (const
* const tok, bool conditional, std::size_t dimensions)
763 {
unsigned int indexvarid = 0;
const std::vector&ValueFlow::Value&
std::vector&ValueFlow::Value&
for (const
*tok2 = indexes.size() & dimensions && (tok2, &[&); tok2 = tok2-&link()-&next()) {
if (!tok2-&astOperand2())
*index = tok2-&astOperand2()-&getMaxValue(conditional);
if (!index)
if (indexvarid == 0U)
indexvarid = index-&;
if (index-& & 0 && indexvarid != index-&)
if (index-& & 0)
indexes.push_back(*index);
784 }
 void (const
* const tok, const
&arrayInfo)
788 {
if (tok-&()-&type ==
|| tok-&()-&type == )
const bool printInconclusive = -&;
const bool addressOf = (tok);
for (int warn = 0; warn == 0 || warn == 1; ++warn) {
for (const
*tok2 = tok2 && tok2-&() == &[&; tok2 = tok2-&link()-&next()) {
*index = tok2-&();
if (!index)
*value = index-&(-1LL,);
if (value)
(index, *value);
const std::vector&ValueFlow::Value& indexes((tok, warn==1, arrayInfo.().size()));
if (indexes.size() != arrayInfo.().size())
totalElements = arrayInfo.();
totalIndex = arrayInfo.(indexes);
if (totalElements &= 0)
if (addressOf && totalIndex == totalElements)
if (totalIndex &= totalElements) {
(tok, arrayInfo, indexes);
if (printInconclusive) {
for (std::size_t i = 0; i & indexes.size(); ++i) {
if (indexes[i].intvalue &= arrayInfo.(i)) {
(tok, arrayInfo, indexes);
859 }
 void (const
*tok, const
&arrayInfo)
864 {
bool reassigned = false;
for (const * const end = tok-&()-&classE tok != tok = tok-&()) {
if (reassigned && tok-&() == &;&)
if (tok-&() != arrayInfo.())
if (tok-&(1) == &=&) {
reassigned = true;
(tok, arrayInfo);
880 }
 void (const
*tok, std::map&unsigned int, ArrayInfo& arrayInfos)
883 {
unsigned int reassigned = 0;
for (const * const end = tok-&()-&classE tok != tok = tok-&()) {
if (reassigned && tok-&() == &;&) {
arrayInfos.erase(reassigned);
reassigned = 0;
if (!tok-&() || tok-&()-&nameToken() == tok)
std::map&unsigned int, ArrayInfo&::const_iterator arrayInfo = arrayInfos.find(tok-&());
if (arrayInfo == arrayInfos.cend())
if (tok-&(1) == &=&) {
reassigned = tok-&();
(tok, arrayInfo-&second);
905 }
 void (const
*tok, const
&arrayInfo)
908 {
const bool printPortability = -&(&portability&);
const bool printWarning = -&(&warning&);
const bool printInconclusive = -&;
if (tok-&(1) == &[&) {
(tok-&(), arrayInfo);
else if (printPortability && !tok-&() && tok-&() && tok-&()-&() == &+&) {
if (tok == tok-&()-&())
index = tok-&()-&();
index = tok-&()-&();
if (index) {
*value = index-&(arrayInfo.(0) + 1U, );
if (!value)
value = index-&(-1, );
if (value)
(tok-&(), index, value-&);
else if (printPortability && tok-&() && tok-&()-&() == &-&) {
*var = -&(arrayInfo.());
if (var && var-&()) {
*index = tok-&()-&();
*value = index ? index-&(1,) : nullptr;
if (index && !value)
value = index-&(-1 - arrayInfo.(0), );
if (value)
(tok-&(), index, value-&);
if (!tok-&()-&isExecutable())
const * tok2 = tok-&();
if (tok2) {
while (tok2-&() && !(tok2-&(), &[,(]&))
tok2 = tok2-&();
while (tok2-&() && tok2-&()-&() == &,&)
tok2 = tok2-&();
if (tok2-&() && tok2-&()-&() == &(&)
tok2 = tok2-&();
if (tok2-&() != &(&)
tok2 = tok2-&();
(tok2, arrayInfo, std::list&const Token*&());
total_size = arrayInfo.(0) * arrayInfo.();
if (printWarning && printInconclusive && (tok2, &strncpy|memcpy|memmove ( %varid% , %str% , %num% )&, arrayInfo.())) {
if ((tok2-&(4)) &= total_size) {
num = (tok2-&(6));
if (total_size == num)
(tok2, tok2-&(2), tok2-&());
if (printWarning && (tok2, &strncpy|strncat ( %varid% ,&, arrayInfo.()) && (tok2-&(1)-&(-2), &, %num% )&)) {
const * param3 = tok2-&(1)-&();
if (tok2-&() == &strncpy&) {
num = (param3-&());
if (printInconclusive && num &= total_size) {
*tok4 = tok2-&()-&()-&next();
for (; tok4; tok4 = tok4-&()) {
const * tok3 = tok2-&(2);
if (tok4-&() == tok3-&()) {
*eq = nullptr;
if ((tok4, &%varid% [&, tok3-&()) && (tok4-&(1), &] =&))
eq = tok4-&(1)-&();
*rhs = eq ? eq-&() : nullptr;
if (!(rhs && rhs-&() && rhs-&(0)))
(tok2, tok3-&());
1000 
1001 
1002 
else if (tok2-&() == &strncat&) {
1003 
n = (param3-&());
1004 
if (n &= total_size)
1005 
1006 
1007 
1008 
1009 
if ((param3-&(2), &; strncat ( %varid% ,&, arrayInfo.()) && (param3-&(4)-&(-2), &, %num% )&)) {
1010 
n = (param3-&()) + (param3-&(4)-&(-1));
1011 
if (n & total_size)
1012 
(param3-&(3));
1013 
1014 
1015 
1016 
1017 
if (total_size & 0) {
1018 
if ((tok2, &strcpy ( %varid% , %str% )&, arrayInfo.())) {
1019 
const std::size_t len = (tok2-&(4));
1020 
if (len &= total_size) {
1021 
(tok2, arrayInfo.());
1022 
1023 
1024 
1025 
1026 
1027 
charactersAppend = 0;
1028 
*tok3 = tok2;
1029 
1030 
while ((tok3, &strcat ( %varid% , %str% ) ;&, arrayInfo.())) {
1031 
charactersAppend += (tok3-&(4));
1032 
if (charactersAppend &= total_size) {
1033 
(tok3, arrayInfo.());
1034 
1035 
1036 
tok3 = tok3-&(7);
1037 
1038 
1039 
1040 }
1041 
1042 
1043 
1044 
1045 
 static bool (const
1047 {
1048 
std::stack&const Token *&
1049 
tokens.push(index);
1050 
while (!tokens.empty()) {
1051 
*tok = tokens.top();
1052 
tokens.pop();
1053 
1054 
1055 
if (tok-&() != 0U)
1056 
return true;
1057 
if (tok-&() == &?&) {
1058 
1059 
if (tok-&() &&
1060 
tok-&()-&str() == &:& &&
1061 
(tok-&()-&astOperand1()) &&
1062 
(tok-&()-&astOperand2()))
1063 
return true;
1064 
1065 
1066 
tokens.push(tok-&());
1067 
tokens.push(tok-&());
1068 
1069 
return false;
1070 }
1071 
 void ()
1073 {
1074 
for (unsigned int i = 1; i &= -&(); i++) {
1075 
* const var = -&(i);
1076 
if (!var || !var-&())
1077 
1078 
* const nameToken = var-&();
1079 
if (!(nameToken, &%var% [&) || !nameToken-&()-&())
1080 
1081 
*sz = nameToken-&()-&()-&getValueLE(-1,);
1082 
1083 
if (sz && (nameToken-&()-&()))
1084 
(nameToken);
1085 
1086 }
1087 
 void (const
1089 {
1090 
(tok, , &negativeArraySize&,
1091 
&Declaration of array '& + (tok ? tok-&() : std::string()) + &' with negative size is undefined behaviour&, , false);
1092 }
1093 
1094 
1095 
1096 
 bool (const * tok, int &position)
1098 {
1099 
if ((tok-&(), &%name% [ %num% ]&)) {
1100 
tok = tok-&(4);
1101 
int i = 1;
1102 
for (;;) {
1103 
if ((tok-&(), &[ %num% ]&)) {
1104 
1105 
tok = tok-&(4);
1106 
1107 
1108 
1109 
if ((tok-&(),&;&)) {
1110 
position =
1111 
return true;
1112 
1113 
1114 
return false;
1115 }
1116 
1117 
1118 
1119 
1120 
 void ()
1122 {
1123 
1124 
for (const
*tok = -&(); tok = tok-&()) {
1125 
if ((tok, &%str% [&) && tok-&next()-&astOperand2()) {
1126 
const std::size_t size = (tok);
1127 
*value = tok-&next()-&astOperand2()-&getMaxValue(false);
1128 
if (value && value-& &= ((tok) ? size + 1U : size))
1129 
(tok, tok-&str());
1130 
1131 
1132 
if ((tok, &%var% [&) && tok-&next()-&astOperand2() && tok-&variable() && tok-&variable()-&isPointer()) {
1133 
*value = tok-&next()-&astOperand2()-&getMaxValue(false);
1134 
if (!value)
1135 
1136 
1137 
for (std::list&ValueFlow::Value&::const_iterator it = tok-&values.begin(); it != tok-&values.end(); ++it) {
1138 
if (!it-&isTokValue() || !it-&tokvalue)
1139 
1140 
*var = it-&tokvalue-&variable();
1141 
if (var && var-&()) {
1142 
if ((tok) != (it-&tokvalue))
1143 
1144 
1145 
arrayInfo(var, );
1146 
elements = arrayInfo.();
1147 
if (elements &= 0)
1148 
1149 
1150 
const std::vector&ValueFlow::Value& indexes((tok-&next(), false, var-&().size()));
1151 
if (indexes.size() != var-&().size())
1152 
1153 
1154 
index = arrayInfo.(indexes);
1155 
if (index & ((tok) ? elements + 1U : elements))
1156 
1157 
1158 
std::list&const Token *&
1159 
callstack.push_back(it-&tokvalue);
1160 
callstack.push_back(tok);
1161 
1162 
std::vector&MathLib::bigint& indexes2;
1163 
for (unsigned int i = 0; i & indexes.size(); ++i)
1164 
indexes2.push_back(indexes[i].intvalue);
1165 
1166 
(callstack, arrayInfo, indexes2);
1167 
1168 
1169 
1170 
1171 
1172 
1173 
for (std::list&Scope&::const_iterator scope = -&.cbegin(); scope != -&.cend(); ++scope) {
1174 
std::map&unsigned int, ArrayInfo& arrayI
1175 
for (std::list&Variable&::const_iterator var = scope-&varlist.cbegin(); var != scope-&varlist.cend(); ++var) {
1176 
if (var-&isArray() && var-&dimension(0) & 0) {
1177 
1178 
&Check (BufferOverrun::checkGlobalAndLocalVariable 1)&,
1179 
var-&nameToken()-&progressValue());
1180 
1181 
1182 
1183 
1184 
*tok = var-&nameToken();
1185 
1186 
if (tok-&() == &{&) {
1187 
if ((tok-&(), &= {&))
1188 
tok = tok-&();
1189 
1190 
1191 
1192 
tok = tok-&();
1193 
} while (tok && tok-&() != &;&);
1194 
1195 
1196 
if (tok-&() == &{&)
1197 
tok = tok-&();
1198 
arrayInfos[var-&declarationId()] = (&*var, , var-&declarationId());
1199 
1200 
1201 
if (!arrayInfos.empty())
1202 
(scope-&classStart ? scope-&classStart : -&(), arrayInfos);
1203 
1204 
1205 
1206 
const std::size_t functions = -&.size();
1207 
for (std::size_t i = 0; i & ++i) {
1208 
* scope = -&[i];
1209 
1210 
for (const
*tok = scope-&; tok != scope-&; tok = tok-&()) {
1211 
1212 
if (tok-&previous() && !tok-&previous()-&isName() && !(tok-&previous(), &[;{}]&))
1213 
1214 
1215 
1216 
1217 
1218 
1219 
*var = nullptr;
1220 
1221 
1222 
* nextTok =
1223 
1224 
1225 
&Check (BufferOverrun::checkGlobalAndLocalVariable 2)&,
1226 
tok-&progressValue());
1227 
1228 
1229 
1230 
1231 
if (-&() && (tok, &[*;{}] %var% = new %type% [&)) {
1232 
if (tok-&tokAt(5)-&astOperand2() == nullptr || tok-&tokAt(5)-&astOperand2()-&getMaxValue(false) == nullptr)
1233 
1234 
size = tok-&tokAt(5)-&astOperand2()-&getMaxValue(false)-&
1235 
var = tok-&next()-&variable();
1236 
nextTok = tok-&(5)-&();
1237 
if (size & 0) {
1238 
(tok-&next()-&next());
1239 
1240 
} else if (-&() && (tok, &[*;{}] %var% = new %type% (|;&)) {
1241 
1242 
var = tok-&next()-&variable();
1243 
if (tok-&strAt(5) == &;&)
1244 
nextTok = tok-&(6);
1245 
1246 
nextTok = tok-&(5)-&();
1247 
} else if ((tok, &[*;{}] %var% = malloc|alloca (&) && (tok-&linkAt(4), &) ;&)) {
1248 
if (tok-&tokAt(4)-&astOperand2() == nullptr || tok-&tokAt(4)-&astOperand2()-&getMaxValue(false) == nullptr)
1249 
1250 
size = tok-&(4)-&()-&getMaxValue(false)-&
1251 
var = tok-&next()-&variable();
1252 
nextTok = tok-&(4)-&(2);
1253 
1254 
if (size & 0) {
1255 
(tok-&next()-&next());
1256 
1257 
1258 
1259 
if (!var || !var-&() || var-&()-&() != var-&())
1260 
1261 
1262 
1263 
1264 
1265 
const unsigned int typeSize = (var-&());
1266 
if (typeSize & 0) {
1267 
size /= static_cast&int&(typeSize);
1268 
1269 
if (size & 0) {
1270 
(tok-&next()-&next());
1271 
1272 
1273 
1274 
1275 
1276 
if (var == 0)
1277 
1278 
1279 
totalSize = size * static_cast&int&((var-&()));
1280 
if (totalSize == 0)
1281 
1282 
1283 
std::vector&std::string&
1284 
temp(var-&(), tok-&next()-&str(), totalSize / size, size);
1285 
(nextTok, v, temp);
1286 
1287 
1288 }
1289 
1290 
1291 
1292 
1293 
1294 
1295 
 void ()
1297 {
1298 
1299 
const std::size_t classes = -&.size();
1300 
for (std::size_t i = 0; i & ++i) {
1301 
* scope = -&[i];
1302 
1303 
1304 
std::list&Variable&::const_
1305 
for (var = scope-&.begin(); var != scope-&.end(); ++var) {
1306 
if (var-&isArray()) {
1307 
1308 
arrayInfo(&*var, );
1309 
1310 
1311 
const std::size_t functions = -&.size();
1312 
for (std::size_t j = 0; j & ++j) {
1313 
* func_scope = -&[j];
1314 
1315 
1316 
1317 
if (scope-&-& ==
1318 
scope-& != func_scope) {
1319 
1320 
1321 
1322 
1323 
if (func_scope-& == scope) {
1324 
1325 
if (func_scope-&-&() != func_scope-&) {
1326 
1327 
*tok = func_scope-&-&();
1328 
(tok, arrayInfo);
1329 
1330 
1331 
1332 
1333 
1334 
if (scope-&-&())
1335 
1336 
1337 
std::vector&std::string&
1338 
varname.push_back(&&);
1339 
varname.push_back(arrayInfo.());
1340 
1341 
1342 
for (const
*tok3 = func_scope-&; tok3 && tok3 != func_scope-&; tok3 = tok3-&()) {
1343 
1344 
if (tok3-&str() != scope-&)
1345 
1346 
1347 
1348 
int posOfSemicolon = -1;
1349 
1350 
1351 
if ((tok3-&next(), &%var% ;&))
1352 
varname[0] = tok3-&strAt(1);
1353 
1354 
else if ((tok3,posOfSemicolon)) {
1355 
varname[0] = tok3-&strAt(1);
1356 
1357 
int pos = 2;
1358 
for (int k = 0 ; k & posOfS k++) {
1359 
for (int index = index & (pos + 3); index++)
1360 
tok3-&strAt(index);
1361 
1362 
1363 
1364 
1365 
1366 
else if ((tok3-&next(), &*|& %var% [,);=]&))
1367 
varname[0] = tok3-&strAt(2);
1368 
1369 
1370 
1371 
1372 
1373 
if (scope-& ==
&& var-&isPublic()) {
1374 
1375 
if (var-&dimensions().size() == 1 && var-&dimension(0) & 2 &&
1376 
var-&index() == (scope-&.size() - 1)) {
1377 
1378 
if (tok3-&next()-&str() == &*&) {
1379 
1380 
if (((tok3-&tokAt(3), &; %name% = malloc ( %num% ) ;&) ||
1381 
((tok3-&tokAt(3), &; %name% = (&) &&
1382 
(tok3-&linkAt(6), &) malloc ( %num% ) ;&))) &&
1383 
(tok3-&strAt(4) == tok3-&strAt(2))) {
1384 
1385 
1386 
1387 
if (tok3-&strAt(3) == &(&)
1388 
size = (tok3-&linkAt(6)-&strAt(3));
1389 
1390 
size = (tok3-&strAt(8));
1391 
1392 
1393 
1394 
1395 
1396 
1397 
1398 
1399 
1400 
1401 
if (size != 100) {
1402 
1403 
1404 
if (size & 100 || arrayInfo.() == 0)
1405 
1406 
1407 
1408 
elements = (size - 100) / arrayInfo.();
1409 
arrayInfo.(0, arrayInfo.(0) + elements);
1410 
1411 
1412 
1413 
1414 
1415 
1416 
1417 
1418 
1419 
1420 
1421 
*checkTok = nullptr;
1422 
while (tok3 && tok3 != func_scope-&) {
1423 
1424 
if (tok3-&str() == &;&) {
1425 
checkTok = tok3;
1426 
1427 
1428 
1429 
1430 
if ((tok3, &) ;&))
1431 
1432 
1433 
1434 
if ((tok3, &) {&)) {
1435 
checkTok = tok3-&(2);
1436 
1437 
1438 
1439 
tok3 = tok3-&();
1440 
1441 
1442 
if (!tok3)
1443 
1444 
1445 
if (!checkTok)
1446 
1447 
1448 
1449 
temp = arrayI
1450 
1451 
1452 
for (std::size_t k = 0; k & varname.size(); ++k)
1453 
varnames += (k == 0 ? && : &.&) + varname[k];
1454 
1455 
temp.(varnames);
1456 
(checkTok, varname, temp);
1457 
1458 
1459 
1460 
1461 
1462 }
1463 
1464 
1465 
 void ()
1467 {
1468 
1469 
for (const
*tok = -&(); tok = tok-&()) {
1470 
1471 
if (!(tok, &%name% [&))
1472 
1473 
1474 
1475 
*index = tok-&()-&();
1476 
if (index && index-&(-1LL,))
1477 
1478 
1479 
1480 
1481 
if (tok-&astParent() && tok-&astParent()-&str() == &.&) {
1482 
*parent = tok-&();
1483 
while (parent-&() && parent-&()-&() == &.&)
1484 
parent = parent-&();
1485 
varname = parent-&();
1486 
1487 
varname = tok-&str();
1488 
1489 
1490 
* const var = tok-&variable();
1491 
1492 
1493 
1494 
* const strtoken = tok-&();
1495 
if (strtoken && !var-&()) {
1496 
1497 
1498 
1499 
1500 
arrayInfo(tok-&varId(), varname, 1U, (strtoken));
1501 
(tok-&next(), arrayInfo);
1502 
1503 
if (var-&() == tok || !var-&())
1504 
1505 
1506 
1507 
bool known = true;
1508 
for (unsigned int i = 0; i & var-&().size(); ++i) {
1509 
known &= (var-&(i) &= 1);
1510 
known &= var-&(i);
1511 
1512 
if (!known)
1513 
1514 
1515 
1516 
if (var-&(0) &= 1 && (var-&()-&(1),&] ; }&))
1517 
1518 
1519 
if (var-&() && var-&()-& == )
1520 
1521 
1522 
arrayInfo(var, );
1523 
arrayInfo.(varname);
1524 
1525 
(tok-&next(), arrayInfo);
1526 
1527 
1528 }
1529 
1530 
  (const std::string &input_string, const std::list&const Token*& &parameters)
1532 {
1533 
bool percentCharFound = false;
1534 
std::size_t input_string_size = 1;
1535 
bool handleNextParameter = false;
1536 
std::string digits_
1537 
bool i_d_x_f_found = false;
1538 
std::list&const Token*&::const_iterator paramIter = parameters.begin();
1539 
std::size_t parameterLength = 0;
1540 
for (std::string::size_type i = 0; i & input_string.length(); ++i) {
1541 
if (input_string[i] == '\\') {
1542 
if (i & input_string.length() - 1 && input_string[i + 1] == '0')
1543 
1544 
1545 
++input_string_
1546 
1547 
1548 
1549 
1550 
if (percentCharFound) {
1551 
switch (input_string[i]) {
1552 
case 'f':
1553 
case 'x':
1554 
case 'X':
1555 
case 'i':
1556 
i_d_x_f_found = true;
1557 
handleNextParameter = true;
1558 
1559 
case 'c':
1560 
case 'e':
1561 
case 'E':
1562 
case 'g':
1563 
case 'o':
1564 
case 'u':
1565 
case 'p':
1566 
case 'n':
1567 
handleNextParameter = true;
1568 
1569 
case 'd':
1570 
i_d_x_f_found = true;
1571 
if (paramIter != parameters.end() && *paramIter && (*paramIter)-&tokType() != )
1572 
parameterLength = (*paramIter)-&str().length();
1573 
1574 
handleNextParameter = true;
1575 
1576 
case 's':
1577 
if (paramIter != parameters.end() && *paramIter && (*paramIter)-&tokType() == )
1578 
parameterLength = (*paramIter);
1579 
1580 
handleNextParameter = true;
1581 
1582 
1583 
1584 
1585 
if (input_string[i] == '%')
1586 
percentCharFound = !percentCharF
1587 
else if (percentCharFound) {
1588 
digits_string.append(1, input_string[i]);
1589 
1590 
1591 
if (!percentCharFound)
1592 
input_string_size++;
1593 
1594 
if (handleNextParameter) {
1595 
unsigned int tempDigits = static_cast&unsigned int&(std::abs(std::atoi(digits_string.c_str())));
1596 
if (i_d_x_f_found)
1597 
tempDigits = std::max(static_cast&unsigned int&(tempDigits), 1U);
1598 
1599 
if (digits_string.find('.') != std::string::npos) {
1600 
const std::string endStr = digits_string.substr(digits_string.find('.') + 1);
1601 
const unsigned int maxLen = std::max(static_cast&unsigned int&(std::abs(std::atoi(endStr.c_str()))), 1U);
1602 
1603 
if (input_string[i] == 's') {
1604 
1605 
1606 
if (parameterLength & maxLen)
1607 
parameterLength = maxL
1608 
1609 
1610 
1611 
if (tempDigits & maxLen)
1612 
tempDigits = maxL
1613 
1614 
1615 
1616 
if (tempDigits & parameterLength)
1617 
input_string_size += parameterL
1618 
1619 
input_string_size += tempD
1620 
1621 
parameterLength = 0;
1622 
digits_string = &&;
1623 
i_d_x_f_found = false;
1624 
percentCharFound = false;
1625 
handleNextParameter = false;
1626 
if (paramIter != parameters.end())
1627 
1628 
1629 
1630 
1631 
return input_string_
1632 }
1633 
1634 
1635 
1636 
1637 
1638 
1639 
1640 
1641 
1642 
1643 
 void ()
1645 {
1646 
const std::size_t functions = -&.size();
1647 
for (std::size_t i = 0; i & ++i) {
1648 
* scope = -&[i];
1649 
for (const
*tok = scope-&-&(); tok && tok != scope-&; tok = tok-&()) {
1650 
unsigned int dstVarId;
1651 
unsigned int srcVarId;
1652 
1653 
1654 
if ((tok, &%var% = malloc|g_malloc|g_try_malloc ( strlen ( %name% ) )&)) {
1655 
dstVarId = tok-&varId();
1656 
srcVarId = tok-&tokAt(6)-&varId();
1657 
= tok-&tokAt(8);
1658 
} else if (-&() && (tok, &%var% = new char [ strlen ( %name% ) ]&)) {
1659 
dstVarId = tok-&varId();
1660 
srcVarId = tok-&tokAt(7)-&varId();
1661 
= tok-&tokAt(9);
1662 
} else if ((tok, &%var% = realloc|g_realloc|g_try_realloc ( %name% , strlen ( %name% ) )&)) {
1663 
dstVarId = tok-&varId();
1664 
srcVarId = tok-&tokAt(8)-&varId();
1665 
= tok-&tokAt(10);
1666 
1667 
1668 
1669 
1670 
1671 
for (const * const end = tok-&()-&classE tok && tok-&next() && tok != tok = tok-&next()) {
1672 
1673 
if (tok-&varId() == srcVarId || tok-&varId() == dstVarId)
1674 
1675 
1676 
if ((tok, &strcpy ( %varid% , %var% )&, dstVarId) &&
1677 
tok-&tokAt(4)-&varId() == srcVarId) {
1678 
1679 
1680 
1681 
1682 
1683 
1684 
1685 }
1686 
1687 
1688 
1689 
 void ()
1691 {
1692 
const std::size_t functions = -&.size();
1693 
for (std::size_t functionIndex = 0; functionIndex & ++functionIndex) {
1694 
* const scope = -&[functionIndex];
1695 
for (const
*tok = scope-&; tok != scope-&; tok = tok-&()) {
1696 
if (!(tok, &%name% (&) || !-&.(tok-&str()))
1697 
1698 
1699 
unsigned int argnr = 1;
1700 
for (const
*argtok = tok-&(2); argtok = argtok-&(), argnr++) {
1701 
if (!(argtok, &%str% ,|)&))
1702 
1703 
*strtoken = argtok-&();
1704 
if (!strtoken)
1705 
1706 
const std::list&Library::ArgumentChecks::MinSize& *minsizes = -&.(tok, argnr);
1707 
if (!minsizes)
1708 
1709 
if ((*minsizes, tok, (strtoken), nullptr, ))
1710 
1711 
1712 
1713 
1714 }
1715 
1716 
1717 
1718 
1719 
1720 
1721 
1722 
1723 
1724 
1725 
1726 
 void ()
1728 {
1729 
const std::size_t functions = -&.size();
1730 
for (std::size_t i = 0; i & ++i) {
1731 
* function = -&[i]-&
1732 
if (function) {
1733 
const * tok = function-&
1734 
1735 
1736 
unsigned int varid = 0;
1737 
if ((tok, &main ( int %var% , char * %var% [ ] ,|)&)) {
1738 
varid = tok-&(7)-&();
1739 
1740 
} else if ((tok, &main ( int %var% , char * * %var% ,|)&)) {
1741 
varid = tok-&(8)-&();
1742 
1743 
1744 
1745 
1746 
tok = -&[i]-&classS
1747 
1748 
1749 
for (const * end = tok-&(); tok != tok = tok-&()) {
1750 
1751 
if (tok-&() == varid)
1752 
1753 
1754 
1755 
1756 
if ((tok, &strcpy|strcat ( %name% , * %varid%&, varid) ||
1757 
(tok, &strcpy|strcat ( %name% , %varid% [&, varid)) {
1758 
1759 
tok = tok-&(1);
1760 
1761 
1762 
1763 
1764 }
1765 
1766 
1767 
 void (const
1769 {
1770 
1771 
ostr && &Array index & && index && & is out of bounds.&;
1772 
(tok, , &negativeIndex&, ostr.str(), , false);
1773 }
1774 
 void (const
*tok, const
1776 {
1777 
1778 
ostr && &Array index & && index. && & is out of bounds.&;
1779 
if (index.)
1780 
ostr && & Otherwise there is useless condition at line & && index.-&() && &.&;
1781 
(tok, index. ?
: , &negativeIndex&, ostr.str(), , index.);
1782 }
1783 
1785 
: _element_size(0), _declarationId(0)
1786 {
1787 }
1788 
 (const
*var, const
* symDb, const unsigned int forcedeclid)
1790 
: _varname(var-&()), _declarationId((forcedeclid == 0U) ? var-&declarationId() : forcedeclid)
1791 {
1792 
for (std::size_t i = 0; i & var-&().size(); i++)
1793 
.push_back(var-&(i));
1794 
if (var-&()-&() == &*&)
1795 
= symDb-&(var-&());
1796 
else if (var-&()-&(-1) == &struct&)
1797 
1798 
1799 
= symDb-&(var-&());
1800 
1801 }
1802 
1803 
1804 
1805 
1806 
1807 
1808 
 (unsigned int id, const std::string &,
1810 
: _varname(name), _element_size(size1), _declarationId(id)
1811 {
1812 
.push_back(n);
1813 }
1814 
  ( value) const
1816 {
1817 
uvalue = std::max((0), value);
1818 
1819 
for (std::size_t i = 0; i & _num.size(); ++i)
1820 
n *= _num[i];
1821 
if (uvalue & n)
1822 
1823 
return (_declarationId, _varname, _element_size, n - uvalue);
1824 }
1825 
  () const
1827 {
1828 
if (_num.empty())
1829 
1830 
1831 
1832 
1833 
for (std::size_t i = 0; i & _num.size(); ++i) {
1834 
ret *= _num[i];
1835 
1836 
1837 }
1838 
  (const std::vector&ValueFlow::Value& &indexes) const
1840 {
1841 
index = 0;
1842 
elements = 1;
1843 
for (std::size_t i = 0; i & _num.size(); ++i) {
1844 
const std::size_t ri = _num.size() - 1U -
1845 
index += indexes[ri].intvalue *
1846 
elements *= _num[ri];
1847 
1848 
1849 }
1850 
1851 
 void ()
1853 {
1854 
if (!-&(&style&))
1855 
1856 
1857 
const std::size_t functions = -&.size();
1858 
for (std::size_t i = 0; i & ++i) {
1859 
* const scope = -&[i];
1860 
for (const
*tok = scope-&; tok && tok != scope-&; tok = tok-&()) {
1861 
if ((tok, &sizeof (&)) {
1862 
tok = tok-&linkAt(1);
1863 
1864 
1865 
1866 
if ((tok, &%name% [ %var% ]&)) {
1867 
tok = tok-&tokAt(2);
1868 
1869 
const unsigned int indexID = tok-&varId();
1870 
const std::string& indexName(tok-&str());
1871 
1872 
1873 
tok = tok-&tokAt(2);
1874 
while (tok && tok-&str() == &[&)
1875 
tok = tok-&link()-&next();
1876 
1877 
1878 
1879 
1880 
1881 
1882 
if (tok-&tokType() == )
1883 
tok = tok-&tokAt(2);
1884 
1885 
1886 
1887 
1888 
if (tok-&str() == &)&)
1889 
tok = tok-&next();
1890 
1891 
1892 
1893 
if ((tok, &&& (| %varid% &|&=&, indexID))
1894 
(tok, indexName);
1895 
else if ((tok, &&& (| %any% &|&= %varid% !!+&, indexID))
1896 
(tok, indexName);
1897 
1898 
1899 
1900 }
1901 
 void (const
*tok, const std::string &indexName)
1903 {
1904 
(tok, , &arrayIndexThenCheck&,
1905 
&Array index '& + indexName + &' is used before limits check.\n&
1906 
&Defensive programming: The variable '& + indexName + &' is used as an array index before it &
1907 
&is checked that is within limits. This can mean that the array might be accessed out of bounds. &
1908 
&Reorder conditions such as '(a[i] && i & 10)' to '(i & 10 && a[i])'. That way the array will &
1909 
&not be accessed if the index is out of limits.&, , false);
1910 }
1911 
 std::string () const
1913 {
1914 
1915 
for (std::map&std::string, struct CheckBufferOverrun::MyFileInfo::ArrayUsage&::const_iterator it = arrayUsage.begin(); it != arrayUsage.end(); ++it) {
1916 
&ArrayUsage&
1917 
&& & array=\&& && (it-&first) && '\&'
1918 
&& & index=\&& && it-&second.index && '\&'
1919 
&& & fileName=\&& && (it-&second.fileName) && '\&'
1920 
&& & linenr=\&& && it-&second.linenr && &\&/&\n&;
1921 
1922 
for (std::map&std::string, MathLib::bigint&::const_iterator it = arraySize.begin(); it != arraySize.end(); ++it) {
1923 
&ArraySize&
1924 
&& & array=\&& && (it-&first) && '\&'
1925 
&& & size=\&& && it-&second && &\&/&\n&;
1926 
1927 
return ret.str();
1928 }
1929 
 * (const
*tokenizer, const
*settings) const
1931 {
1932 
1933 
1934 
*fileInfo = new ;
1935 
1936 
1937 
const * const symbolDB = tokenizer-&();
1938 
const std::size_t functions = symbolDB-&.size();
1939 
for (std::size_t i = 0; i & ++i) {
1940 
* const scope = symbolDB-&[i];
1941 
for (const
*tok = scope-&; tok && tok != scope-&; tok = tok-&()) {
1942 
if ((tok, &%var% [&)
1943 
(tok-&linkAt(1), &] !![&) &&
1944 
tok-&variable()
1945 
tok-&variable()-&isExtern()
1946 
tok-&variable()-&isGlobal()
1947 
tok-&next()-&astOperand2()) {
1948 
*value = tok-&next()-&astOperand2()-&getMaxValue(false);
1949 
if (value && value-& & 0) {
1950 
arrayIndex = value-&;
1951 
std::map&std::string, struct MyFileInfo::ArrayUsage&::iterator it = fileInfo-&.find(tok-&str());
1952 
if (it != fileInfo-&.end() && it-&second.index &= arrayIndex)
1953 
1954 
1955 
arrayUsage. = arrayI
1956 
arrayUsage. = tokenizer-&.(tok);
1957 
arrayUsage. = tok-&linenr();
1958 
fileInfo-&[tok-&str()] = arrayU
1959 
1960 
1961 
1962 
1963 
1964 
1965 
const std::list&Variable& &varlist = symbolDB-&.front().
1966 
for (std::list&Variable&::const_iterator it = varlist.begin(); it != varlist.end(); ++it) {
1967 
1968 
if (!var.() && var.() && var.().size() == 1U && var.(0U) & 0U)
1969 
fileInfo-&[var.()] = var.(0U);
1970 
1971 
1972 
return fileI
1973 }
1974 
 void (const std::list&Check::FileInfo*& &fileInfo, const &,
&errorLogger)
1976 {
1977 
1978 
1979 
for (std::list&Check::FileInfo*&::const_iterator it = fileInfo.begin(); it != fileInfo.end(); ++it) {
1980 
*fi = dynamic_cast&*&(*it);
1981 
1982 
1983 
1984 
1985 
for (std::map&std::string, struct MyFileInfo::ArrayUsage&::const_iterator it2 = fi-&.begin(); it2 != fi-&.end(); ++it2) {
1986 
std::map&std::string, struct MyFileInfo::ArrayUsage&::const_iterator allit = all..find(it2-&first);
1987 
if (allit == all..end() || it2-&second.index & allit-&second.index)
1988 
all.[it2-&first] = it2-&
1989 
1990 
1991 
1992 
for (std::map&std::string, MathLib::bigint&::const_iterator it2 = fi-&.begin(); it2 != fi-&.end(); ++it2) {
1993 
std::map&std::string, MathLib::bigint&::const_iterator allit = all..find(it2-&first);
1994 
if (allit == all..end())
1995 
all.[it2-&first] = it2-&
1996 
1997 
all.[it2-&first] = -1;
1998 
1999 
2000 
2001 
2002 
for (std::map&std::string, struct MyFileInfo::ArrayUsage&::const_iterator it = all..begin(); it != all..end(); ++it) {
2003 
std::map&std::string, MathLib::bigint&::const_iterator sz = all..find(it-&first);
2004 
if (sz != all..end() && sz-&second & 0 && sz-&second & it-&second.index) {
2005 
2006 
fileLoc.(it-&second.fileName);
2007 
fileLoc. = it-&second.
2008 
2009 
std::list&ErrorLogger::ErrorMessage::FileLocation& locationL
2010 
locationList.push_back(fileLoc);
2011 
2012 
2013 
ostr && &Array & && it-&first && '[' && sz-&second && &] accessed at index & && it-&second.index && & which is out of bounds&;
2014 
2015 
errmsg(locationList,
2016 
2017 
2018 
ostr.str(),
2019 
&arrayIndexOutOfBounds&,
2020 
2021 
errorLogger.(errmsg);
2022 
2023 
2024 }
2025 
 unsigned int (const
*type) const
2027 {
2028 
2029 
return -&(type);
2030 
2031 
2032 }
Definition:
virtual void reportErr(const ErrorLogger::ErrorMessage &msg)=0Information about found errors and warnings is directed here.
static void reportError(const ErrorLogger::ErrorMessage &errmsg)Write given error to errorlogger or to out stream in xml format. Definition:
static std::string toxml(const std::string &str)Convert XML-sensitive characters into XML entities. Definition:
bool isPointer() const Is pointer variable. Definition:
void strncatUsageError(const Token *tok)Definition:
Wrapper for error messages, provided by reportErr() Definition:
bool isMaxTime() const Definition:
CWE id (Common Weakness Enumeration) See https://cwe.mitre.org/ for further reference. Definition:
bool isClassOrStruct() const Definition:
bool isCPP() const Is the code CPP. Definition:
unsigned int varIdFor calculated values - varId that calculated value depends on. Definition:
const ValueFlow::Value * getValueLE(const MathLib::bigint val, const Settings *settings) const Definition:
void checkGlobalAndLocalVariable()Check for buffer overruns - locate global variables and local function variables and check them with ...Definition:
void sizeArgumentAsCharError(const Token *tok)Definition:
const Scope * nestedInDefinition:
void scope(const Scope *s)Associate this token with given scope. Definition:
Definition:
bool inconclusiveInconclusive checks. Definition:
void checkScope(const Token *tok, const ArrayInfo &arrayInfo)Check for buffer overruns (based on ArrayInfo) Definition:
const std::string & file(const Token *tok) const get filename for given token Definition:
std::string expressionString() const Definition:
Check::FileInfo * getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const Parse current TU and extract file info. Definition:
Programming error. Definition:
static bigint toLongNumber(const std::string &str)Definition:
MathLib::bigint totalIndex(const std::vector& ValueFlow::Value & &indexes) const Definition:
Definition:
static bool isVLAIndex(const Token *index)Definition:
void link(Token *linkToToken)Create link to given token. Definition:
const Token * tokAt(int index) const Definition:
MathLib::bigint element_size() const size of each element Definition:
bool isStatic() const Is variable static. Definition:
std::string fileNameDefinition:
std::list& Scope & scopeListInformation about all namespaces/classes/structrues. Definition:
Information about a member variable. Definition:
bool isEnabled(T &&str) const Returns true if given id is in the list of enabled extra checks (–enable) Definition:
The main purpose is to tokenize the source code. Definition:
MathLib::bigint indexDefinition:
static const CWE CWE119(119U)
void arrayIndexThenCheckError(const Token *tok, const std::string &indexName)Definition:
unsigned int linenr() const Definition:
Definition:
static void makeArrayIndexOutOfBoundsError(std::ostream &oss, const CheckBufferOverrun::ArrayInfo &arrayInfo, const std::vector& MathLib::bigint & &index)Definition:
static const CWE CWE131(131U)
Style warning. Definition:
std::vector& const Scope * & functionScopesFast access to function scopes. Definition:
const std::vector& Dimension & & dimensions() const Get array dimensions. Definition:
const Token * linkAt(int index) const Definition:
void negativeArraySizeError(const Token *tok)Definition:
buffer overruns and array index out of bounds Definition:
const std::string & strAt(int index) const Definition:
static const CWE CWE788(788U)
static std::size_t getStrLength(const Token *tok)Definition:
unsigned long long biguintDefinition:
std::map& std::string, MathLib::bigint & arraySizeDefinition:
void function(const Function *f)Associate this token with given function. Definition:
Base class used for whole-program analysis. Definition:
void argumentSizeError(const Token *tok, const std::string &functionName, const std::string &varname)Definition:
unsigned int lineDefinition:
virtual void reportProgress(const std::string &filename, const char stage[], const std::size_t value)Report progress to client. Definition:
Definition:
const std::list& ArgumentChecks::MinSize & * argminsizes(const Token *ftok, int argnr) const Definition:
const std::vector& MathLib::bigint & & num() const array sizes Definition:
void arrayIndexThenCheck()Using array index before bounds check. Definition:
const Token * typeStartToken() const Get type start token. Definition:
const Token * getValueTokenMaxStrLength() const Definition:
Definition:
void checkFunctionCall(const Token *tok, const ArrayInfo &arrayInfo, std::list& const Token * & callstack)Helper function that checks if the array is used and if so calls the checkFunctionCall. Definition:
ArrayInfo()Definition:
Definition:
void checkStructVariable()Check for buffer overruns - locate struct variables and check them with the .._CheckScope function...Definition:
const Variable * getVariableFromVarId(std::size_t varId) const Definition:
bool isargformatstr(const Token *ftok, int argnr) const Definition:
bool inconclusiveIs this value inconclusive? Definition:
const Scope * scope() const Get Scope pointer of enclosing scope. Definition:
static const CWE CWE682(682U)
void analyseWholeProgram(const std::list& Check::FileInfo * & &fileInfo, const Settings &settings, ErrorLogger &errorLogger)Analyse all file infos for all TU. Definition:
bool hasBody() const Definition:
unsigned int declarationId() const Variable name. Definition:
std::string astCanonicalType(const Token *expr)Get canonical type of expression. Definition:
void arrayIndexOutOfBoundsError(const Token *tok, const ArrayInfo &arrayInfo, const std::vector& MathLib::bigint & &index)Definition:
bool isArray() const Is variable an array. Definition:
static const std::string emptyStringDefinition:
const Token * classDefDefinition:
Information about N-dimensional array. Definition:
void bufferNotZeroTerminatedError(const Token *tok, const std::string &varname, const std::string &function)Definition:
unsigned int sizeOfType(const Token *type) const Calculates sizeof value for given type. Definition:
static std::string bufferOverrunMessage(std::string varnames)Definition:
unsigned int sizeOfType(const Token *type) const Calculates sizeof value for given type. Definition:
Definition:
const SymbolDatabase * symbolDatabaseDefinition:
Token * next() const Definition:
const ValueFlow::Value * getValue(const MathLib::bigint val) const Definition:
MathLib::bigint numberOfElements() const Definition:
This is an interface, which the class responsible of error logging should implement. Definition:
static bool checkMinSizes(const std::list& Library::ArgumentChecks::MinSize & &minsizes, const Token *const ftok, const MathLib::bigint arraySize, const Token **charSizeToken, const Settings *const settings)Definition:
long long intvalueint value Definition:
Definition:
void checkFunctionParameter(const Token &tok, const unsigned int paramIndex, const ArrayInfo &arrayInfo, const std::list& const Token * & &callstack)Helper function for checkFunctionCall - check a function parameter. Definition:
void cmdLineArgsError(const Token *tok)Definition:
void valueFlowCheckArrayIndex(const Token *const tok, const ArrayInfo &arrayInfo)Definition:
void bufferOverrunError(const Token *tok, const std::string &varnames=emptyString)Definition:
static const CWE CWE758(758U)
ErrorLogger *const _errorLoggerDefinition:
const Settings *const _settingsDefinition:
Token * previous() const Definition:
static biguint toULongNumber(const std::string &str)Definition:
void checkBufferAllocatedWithStrlen()Check for buffer overruns due to allocating strlen(src) bytes instead of (strlen(src)+1) bytes before...Definition:
This is just a container for general settings so that we don't need to pass individual values to func...Definition:
Definition:
std::map& std::string, ArrayUsage & arrayUsageDefinition:
const std::string & getSourceFilePath() const Definition:
Portability warning. Definition:
const Token * tokens() const Definition:
std::vector& MathLib::bigint & _numnumber of elements of array Definition:
const std::string & varname() const Variable name. Definition:
void variable(const Variable *v)Associate this token with given variable. Definition:
bool hasminsize(const std::string &functionName) const Definition:
const std::string & name() const Get name string. Definition:
std::vector& const Scope * & classAndStructScopesFast access to class and struct scopes. Definition:
static std::size_t getStrSize(const Token *tok)Definition:
Library libraryLibrary (–library) Definition:
const Scope * functionOfDefinition:
const Token * classStartDefinition:
const Token * conditionCondition that this value depends on (TODO: replace with a 'callstack') Definition:
std::string eitherTheConditionIsRedundant(const Token *condition)Definition:
void checkInsecureCmdLineArgs()Check for buffer overruns due to copying command-line args to fixed-sized buffers without bounds chec...Definition:
void negativeIndexError(const Token *tok, MathLib::bigint index)Definition:
Warning. Definition:
bool isNumber() const Definition:
void possibleBufferOverrunError(const Token *tok, const std::string &src, const std::string &dst, bool cat)Definition:
unsigned int varId() const Definition:
void checkStringArgument()Check string argument buffer overruns. Definition:
unsigned int linenrDefinition:
static bool isArrayOfStruct(const Token *tok, int &position)Definition:
std::string toString() const Definition:
std::list& Variable & varlistDefinition:
MathLib::bigint dimension(std::size_t index_) const Get array dimension length. Definition:
void terminateStrncpyError(const Token *tok, const std::string &varname)Definition:
void outOfBoundsError(const Token *tok, const std::string &what, const bool show_size_info, const MathLib::bigint &supplied_size, const MathLib::bigint &actual_size)Definition:
const Tokenizer *const _tokenizerDefinition:
static const CWE CWE398(398U)
bool hasKnownIntValue() const Definition:
Token * nextArgument() const Definition:
File name and line number. Definition:
const Token * astParent() const Definition:
ArrayInfo limit(MathLib::bigint value) const Create a copy ArrayInfo where the number of elements have been limited by a value. Definition:
unsigned int declarationId() const Get declaration ID (varId used for variable in its declaration). Definition:
static bool simpleMatch(const Token *tok, const char pattern[])Match given token (or list of tokens) to a pattern list. Definition:
ScopeType typeDefinition:
const SymbolDatabase * getSymbolDatabase() const Definition:
void pointerOutOfBoundsError(const Token *tok, const Token *index=nullptr, const MathLib::bigint indexvalue=0)Definition:
bool dimensionKnown(std::size_t index_) const Get array dimension known. Definition:
Definition:
static MathLib::biguint countSprintfLength(const std::string &input_string, const std::list& const Token * & &parameters)Get minimum length of format string result. Definition:
static bool bailoutIfSwitch(const Token *tok, const unsigned int varid)bailout if variable is used inside if/else/switch block or if there is "break" Definition:
const Token * nameToken() const Get name token. Definition:
Definition:
static bool isAddressOf(const Token *tok)Definition:
long long bigintDefinition:
The token list that the TokenList generates is a linked-list of this class. Definition:
const Variable * getArgumentVar(std::size_t num) const Definition:
Definition:
static std::string toString(T value)Definition:
void negativeMemoryAllocationSizeError(const Token *tok)Definition:
void negativeArraySize()negative size for array Definition:
static bool Match(const Token *tok, const char pattern[], unsigned int varid=0)Match given token (or list of tokens) to a pattern list. Definition:
const Scope * functionScopeDefinition:
const ValueFlow::Value * getValueGE(const MathLib::bigint val, const Settings *settings) const Definition:
Definition:
static std::vector& ValueFlow::Value & valueFlowGetArrayIndexes(const Token *const tok, bool conditional, std::size_t dimensions)Definition:
static const CWE CWE786(786U)
const std::string & name() const class name, used to generate documentation Definition:
static const CWE CWE170(170U)
TokenList listToken list: stores all tokens. Definition:
Token::Type tokType() const Definition:
void astOperand2(Token *tok)Definition:
Definition:
void setfile(const std::string &file)Set the filename. Definition:
bool isName() const Definition:
unsigned int varIdCount() const Get variable count. Definition:
Definition:
bool isCast() const Definition:
void str(T &&s)Definition:
void bufferOverrun()Check for buffer overruns (single pass, use ast and valueflow) Definition:
MathLib::bigint _element_sizesize of each element in array Definition:
std::string classNameDefinition:
Definition:
const Token * classEndDefinition:
void astOperand1(Token *tok)Definition:
Definition:
Definition:
const Token * typeEndToken() const Get type end token. Definition:
const Token * getValueTokenMinStrSize() const Definition:
void checkScope_inner(const Token *tok, const ArrayInfo &arrayInfo)Definition:}