mTokensFrontBack(tokensFrontBack),

mNext(nullptr),

mPrevious(nullptr),

mLink(nullptr),

mScope(nullptr),

mFunction(nullptr), // Initialize whole union

mVarId(0),

mFileIndex(0),

mLineNumber(0),

mColumn(0),

mProgressValue(0),

mTokType(eNone),

mFlags(0),

mBits(0),

mAstOperand1(nullptr),

mAstOperand2(nullptr),

mAstParent(nullptr),

mOriginalName(nullptr),

mValueType(nullptr),

mValues(nullptr)

{

{

setFlag(fIsControlFlowKeyword, controlFlowKeywords.find(mStr) != controlFlowKeywords.end());

if (!mStr.empty()) {

if (mStr == "true" || mStr == "false")

tokType(eBoolean);

else if (std::isalpha((unsigned char)mStr[0]) || mStr[0] == '_' || mStr[0] == '$') { // Name

if (mVarId)

tokType(eVariable);

else if (mTokType != eVariable && mTokType != eFunction && mTokType != eType && mTokType != eKeyword)

tokType(eName);

} else if (std::isdigit((unsigned char)mStr[0]) || (mStr.length() > 1 && mStr[0] == '-' && std::isdigit((unsigned char)mStr[1])))

tokType(eNumber);

else if (mStr.length() > 1 && mStr[0] == '"' && endsWith(mStr,'"'))

tokType(eString);

else if (mStr.length() > 1 && mStr[0] == '\'' && endsWith(mStr,'\''))

tokType(eChar);

else if (mStr == "=" || mStr == "<<=" || mStr == ">>=" ||

(mStr.size() == 2U && mStr[1] == '=' && std::strchr("+-*/%&^|", mStr[0])))

tokType(eAssignmentOp);

else if (mStr.size() == 1 && mStr.find_first_of(",[]()?:") != std::string::npos)

tokType(eExtendedOp);

else if (mStr=="<<" || mStr==">>" || (mStr.size()==1 && mStr.find_first_of("+-*/%") != std::string::npos))

tokType(eArithmeticalOp);

else if (mStr.size() == 1 && mStr.find_first_of("&|^~") != std::string::npos)

tokType(eBitOp);

else if (mStr.size() <= 2 &&

(mStr == "&&" ||

mStr == "||" ||

mStr == "!"))

tokType(eLogicalOp);

else if (mStr.size() <= 2 && !mLink &&

(mStr == "==" ||

mStr == "!=" ||

mStr == "<" ||

mStr == "<=" ||

mStr == ">" ||

mStr == ">="))

tokType(eComparisonOp);

else if (mStr.size() == 2 &&

(mStr == "++" ||

mStr == "--"))

tokType(eIncDecOp);

else if (mStr.size() == 1 && (mStr.find_first_of("{}") != std::string::npos || (mLink && mStr.find_first_of("<>") != std::string::npos)))

tokType(eBracket);

else

tokType(eOther);

} else {

tokType(eNone);

}

update_property_isStandardType();

{

isStandardType(false);

if (mStr.size() < 3)

return;

if (stdTypes.find(mStr)!=stdTypes.end()) {

isStandardType(true);

tokType(eType);

}

{

if (!isName())

return false;

for (size_t i = 0; i < mStr.length(); ++i) {

if (std::islower(mStr[i]))

return false;

}

return true;

{

mStr.erase(mStr.length() - 1);

mStr.append(b.begin() + 1, b.end());

update_property_info();

{

assert(mTokType == eString);

std::string ret(mStr.substr(1, mStr.length() - 2));

std::string::size_type pos = 0U;

while ((pos = ret.find('\\', pos)) != std::string::npos) {

ret.erase(pos,1U);

if (ret[pos] >= 'a') {

if (ret[pos] == 'n')

ret[pos] = '\n';

else if (ret[pos] == 'r')

ret[pos] = '\r';

else if (ret[pos] == 't')

ret[pos] = '\t';

}

if (ret[pos] == '0')

return ret.substr(0,pos);

pos++;

}

return ret;

{

while (mNext && index) {

Token *n = mNext;

// #8154 we are about to be unknown -> destroy the link to us

if (n->mLink && n->mLink->mLink == n)

n->mLink->link(nullptr);

mNext = n->next();

delete n;

--index;

}

if (mNext)

mNext->previous(this);

else if (mTokensFrontBack)

mTokensFrontBack->back = this;

{

while (mPrevious && index) {

Token *p = mPrevious;

// #8154 we are about to be unknown -> destroy the link to us

if (p->mLink && p->mLink->mLink == p)

p->mLink->link(nullptr);

mPrevious = p->previous();

delete p;

--index;

}

if (mPrevious)

mPrevious->next(this);

else if (mTokensFrontBack)

mTokensFrontBack->front = this;

{

if (mNext) {

std::swap(mStr, mNext->mStr);

std::swap(mTokType, mNext->mTokType);

std::swap(mFlags, mNext->mFlags);

std::swap(mVarId, mNext->mVarId);

std::swap(mFileIndex, mNext->mFileIndex);

std::swap(mLineNumber, mNext->mLineNumber);

if (mNext->mLink)

mNext->mLink->mLink = this;

if (this->mLink)

this->mLink->mLink = mNext;

std::swap(mLink, mNext->mLink);

std::swap(mScope, mNext->mScope);

std::swap(mFunction, mNext->mFunction);

std::swap(mOriginalName, mNext->mOriginalName);

std::swap(mValues, mNext->mValues);

std::swap(mValueType, mNext->mValueType);

std::swap(mProgressValue, mNext->mProgressValue);

}

{

mStr = fromToken->mStr;

tokType(fromToken->mTokType);

mFlags = fromToken->mFlags;

mVarId = fromToken->mVarId;

mFileIndex = fromToken->mFileIndex;

mLineNumber = fromToken->mLineNumber;

mLink = fromToken->mLink;

mScope = fromToken->mScope;

mFunction = fromToken->mFunction;

if (fromToken->mOriginalName) {

delete mOriginalName;

mOriginalName = fromToken->mOriginalName;

fromToken->mOriginalName = nullptr;

}

delete mValues;

mValues = fromToken->mValues;

fromToken->mValues = nullptr;

delete mValueType;

mValueType = fromToken->mValueType;

fromToken->mValueType = nullptr;

if (mLink)

mLink->link(this);

{

if (mNext) { // Copy next to this and delete next

takeData(mNext);

mNext->link(nullptr); // mark as unlinked

deleteNext();

} else if (mPrevious && mPrevious->mPrevious) { // Copy previous to this and delete previous

takeData(mPrevious);

Token* toDelete = mPrevious;

mPrevious = mPrevious->mPrevious;

mPrevious->mNext = this;

delete toDelete;

} else {

// We are the last token in the list, we can't delete

// ourselves, so just make us empty

str("");

}

{

// Fix the whole in the old location of start and end

if (start->previous())

start->previous()->next(end->next());

if (end->next())

end->next()->previous(start->previous());

// Move start and end to their new location

if (replaceThis->previous())

replaceThis->previous()->next(start);

if (replaceThis->next())

replaceThis->next()->previous(end);

start->previous(replaceThis->previous());

end->next(replaceThis->next());

if (end->mTokensFrontBack && end->mTokensFrontBack->back == end) {

while (end->next())

end = end->next();

end->mTokensFrontBack->back = end;

}

// Update mProgressValue, fileIndex and linenr

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

tok->mProgressValue = replaceThis->mProgressValue;

// Delete old token, which is replaced

delete replaceThis;

{

++haystack;

// Compare only the first character of the string for optimization reasons

switch (haystack[0]) {

case '\0':

case ' ':

case '|':

//simple '%' character

haystack += 1;

if (tok->isArithmeticalOp() && tok->str() == "%")

return 1;

break;

case 'v':

if (haystack[3] == '%') { // %var%

haystack += 4;

if (tok->varId() != 0)

return 1;

} else { // %varid%

if (varid == 0) {

throw InternalError(tok, "Internal error. Token::Match called with varid 0. Please report this to Cppcheck developers");

}

haystack += 6;

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

return 1;

}

break;

case 't':

// Type (%type%)

{

haystack += 5;

if (tok->isName() && tok->varId() == 0 && !tok->isKeyword())

return 1;

}

break;

case 'a':

// Accept any token (%any%) or assign (%assign%)

{

if (haystack[3] == '%') { // %any%

haystack += 4;

return 1;

} else { // %assign%

haystack += 7;

if (tok->isAssignmentOp())

return 1;

}

}

break;

case 'n':

// Number (%num%) or name (%name%)

{

if (haystack[4] == '%') { // %name%

haystack += 5;

if (tok->isName())

return 1;

} else {

haystack += 4;

if (tok->isNumber())

return 1;

}

}

break;

case 'c': {

haystack += 1;

// Character (%char%)

if (haystack[0] == 'h') {

haystack += 4;

if (tok->tokType() == Token::eChar)

return 1;

}

// Const operator (%cop%)

else if (haystack[1] == 'p') {

haystack += 3;

if (tok->isConstOp())

return 1;

}

// Comparison operator (%comp%)

else {

haystack += 4;

if (tok->isComparisonOp())

return 1;

}

}

break;

case 's':

// String (%str%)

{

haystack += 4;

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

return 1;

}

break;

case 'b':

// Bool (%bool%)

{

haystack += 5;

if (tok->isBoolean())

return 1;

}

break;

case 'o': {

++haystack;

if (haystack[1] == '%') {

// Op (%op%)

if (haystack[0] == 'p') {

haystack += 2;

if (tok->isOp())

return 1;

}

// Or (%or%)

else {

haystack += 2;

if (tok->tokType() == Token::eBitOp && tok->str() == "|")

return 1;

}

}

// Oror (%oror%)

else {

haystack += 4;

if (tok->tokType() == Token::eLogicalOp && tok->str() == "||")

return 1;

}

}

break;

default:

//unknown %cmd%, abort

throw InternalError(tok, "Unexpected command");

}

if (*haystack == '|')

haystack += 1;

else

return -1;

return 0xFFFF;

{

const char *needle = tok->str().c_str();

const char *needlePointer = needle;

for (;;) {

if (needlePointer == needle && haystack[0] == '%' && haystack[1] != '|' && haystack[1] != '\0' && haystack[1] != ' ') {

const int ret = multiComparePercent(tok, haystack, varid);

if (ret < 2)

return ret;

} else if (*haystack == '|') {

if (*needlePointer == 0) {

// If needle is at the end, we have a match.

return 1;

}

needlePointer = needle;

++haystack;

} else if (*needlePointer == *haystack) {

if (*needlePointer == '\0')

return 1;

++needlePointer;

++haystack;

} else if (*haystack == ' ' || *haystack == '\0') {

if (needlePointer == needle)

return 0;

break;

}

// If haystack and needle don't share the same character,

// find next '|' character.

else {

needlePointer = needle;

do {

++haystack;

} while (*haystack != ' ' && *haystack != '|' && *haystack);

if (*haystack == ' ' || *haystack == '\0') {

return -1;

}

++haystack;

}

}

if (*needlePointer == '\0')

return 1;

return -1;

{

if (!tok)

return false; // shortcut

const char *current = pattern;

const char *next = std::strchr(pattern, ' ');

if (!next)

next = pattern + std::strlen(pattern);

while (*current) {

const std::size_t length = next - current;

if (!tok || length != tok->mStr.length() || std::strncmp(current, tok->mStr.c_str(), length))

return false;

current = next;

if (*next) {

next = std::strchr(++current, ' ');

if (!next)

next = current + std::strlen(current);

}

tok = tok->next();

}

return true;

{

for (;;) {

if (*str != *word) {

return (*str == ' ' && *word == 0);

} else if (*str == 0)

break;

++str;

++word;

}

return true;

{

const char *p = pattern;

while (*p) {

// Skip spaces in pattern..

while (*p == ' ')

++p;

// No token => Success!

if (*p == '\0')

break;

if (!tok) {

// If we have no tokens, pattern "!!else" should return true

if (p[0] == '!' && p[1] == '!' && p[2] != '\0') {

while (*p && *p != ' ')

++p;

continue;

} else

return false;

}

// [.. => search for a one-character token..

if (p[0] == '[' && chrInFirstWord(p, ']')) {

if (tok->str().length() != 1)

return false;

const char *temp = p+1;

bool chrFound = false;

unsigned int count = 0;

while (*temp && *temp != ' ') {

if (*temp == ']') {

++count;

}

else if (*temp == tok->str()[0]) {

chrFound = true;

break;

}

++temp;

}

if (count > 1 && tok->str()[0] == ']')

chrFound = true;

if (!chrFound)

return false;

p = temp;

while (*p && *p != ' ')

++p;

}

// Parse "not" options. Token can be anything except the given one

else if (p[0] == '!' && p[1] == '!' && p[2] != '\0') {

p += 2;

if (firstWordEquals(p, tok->str().c_str()))

return false;

while (*p && *p != ' ')

++p;

}

// Parse multi options, such as void|int|char (accept token which is one of these 3)

else {

const int res = multiCompare(tok, p, varid);

if (res == 0) {

// Empty alternative matches, use the same token on next round

while (*p && *p != ' ')

++p;

continue;

} else if (res == -1) {

// No match

return false;

}

}

while (*p && *p != ' ')

++p;

tok = tok->next();

}

// The end of the pattern has been reached and nothing wrong has been found

return true;

{

assert(tok != nullptr);

assert(tok->mTokType == eString);

std::size_t len = 0;

std::string::const_iterator it = tok->str().begin() + 1U;

const std::string::const_iterator end = tok->str().end() - 1U;

while (it != end) {

if (*it == '\\') {

++it;

// string ends at '\0'

if (*it == '0')

return len;

}

if (*it == '\0')

return len;

++it;

++len;

}

return len;

{

assert(tok != nullptr && tok->tokType() == eString);

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

unsigned int sizeofstring = 1U;

for (unsigned int i = 1U; i < str.size() - 1U; i++) {

if (str[i] == '\\')

++i;

++sizeofstring;

}

return sizeofstring;

{

assert(tok != nullptr);

std::string::const_iterator it = tok->str().begin() + 1U;

const std::string::const_iterator end = tok->str().end() - 1U;

while (it != end) {

if (index == 0) {

if (*it == '\0')

return "\\0";

std::string ret(1, *it);

if (*it == '\\') {

++it;

ret += *it;

}

return ret;

}

if (*it == '\\')

++it;

++it;

--index;

}

assert(index == 0);

return "\\0";

{

/**[newLocation] -> b -> c -> [srcStart] -> [srcEnd] -> f */

// Fix the gap, which tokens to be moved will leave

srcStart->previous()->next(srcEnd->next());

srcEnd->next()->previous(srcStart->previous());

// Fix the tokens to be moved

srcEnd->next(newLocation->next());

srcStart->previous(newLocation);

// Fix the tokens at newLocation

newLocation->next()->previous(srcEnd);

newLocation->next(srcStart);

// Update _progressValue

for (Token *tok = srcStart; tok != srcEnd->next(); tok = tok->next())

tok->mProgressValue = newLocation->mProgressValue;

{

//TODO: Find a solution for the first token on the list

if (prepend && !this->previous())

return;

Token *newToken;

if (mStr.empty())

newToken = this;

else

newToken = new Token(mTokensFrontBack);

newToken->str(tokenStr);

if (!originalNameStr.empty())

newToken->originalName(originalNameStr);

if (newToken != this) {

newToken->mLineNumber = mLineNumber;

newToken->mFileIndex = mFileIndex;

newToken->mProgressValue = mProgressValue;

if (prepend) {

/*if (this->previous())*/ {

newToken->previous(this->previous());

newToken->previous()->next(newToken);

} /*else if (tokensFront?) {

this->previous(newToken);

newToken->next(this);

} else {

if (this->next()) {

newToken->next(this->next());

newToken->next()->previous(newToken);

} else if (mTokensFrontBack) {

mTokensFrontBack->back = newToken;

}

this->next(newToken);

newToken->previous(this);

}

}

{

if (!begin || begin == end)

return;

while (begin->next() && begin->next() != end) {

begin->deleteNext();

}

{

assert(begin != nullptr);

assert(end != nullptr);

assert(begin != end);

begin->link(end);

end->link(begin);

{

if (title && title[0])

std::cout << "\n### " << title << " ###\n";

std::cout << stringifyList(true, true, true, true, true, nullptr, nullptr) << std::endl;

{

if (title && title[0])

std::cout << "\n### " << title << " ###\n";

std::cout << stringifyList(true, true, true, true, true, &fileNames, nullptr) << std::endl;

{

if (attributes) {

if (isUnsigned())

os << "unsigned ";

else if (isSigned())

os << "signed ";