tokensBack(t),

_next(0),

_previous(0),

_link(0),

_scope(0),

_function(0), // Initialize whole union

_varId(0),

_fileIndex(0),

_linenr(0),

_progressValue(0),

_type(eNone),

_flags(0),

_astOperand1(nullptr),

_astOperand2(nullptr),

_astParent(nullptr),

_originalName(nullptr)

{

{

if (!_str.empty()) {

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

_type = eBoolean;

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

if (_varId)

_type = eVariable;

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

_type = eName;

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

_type = eNumber;

else if (_str.length() > 1 && _str[0] == '"' && _str[_str.length()-1] == '"')

_type = eString;

else if (_str.length() > 1 && _str[0] == '\'' && _str[_str.length()-1] == '\'')

_type = eChar;

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

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

_type = eAssignmentOp;

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

_type = eExtendedOp;

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

_type = eArithmeticalOp;

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

_type = eBitOp;

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

(_str == "&&" ||

_str == "||" ||

_str == "!"))

_type = eLogicalOp;

else if (_str.size() <= 2 && !_link &&

(_str == "==" ||

_str == "!=" ||

_str == "<" ||

_str == "<=" ||

_str == ">" ||

_str == ">="))

_type = eComparisonOp;

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

(_str == "++" ||

_str == "--"))

_type = eIncDecOp;

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

_type = eBracket;

else

_type = eOther;

} else {

_type = eNone;

}

update_property_isStandardType();

{

isStandardType(false);

if (_str.size() < 3)

return;

static const std::set<std::string> stdTypes = make_container<std::set<std::string> >() <<

"bool" << "char" << "char16_t" << "char32_t" << "double" << "float" << "int" << "long" << "short" << "size_t" << "void" << "wchar_t";

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

isStandardType(true);

_type = eType;

}

{

if (!isName())

return false;

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

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

return false;

}

return true;

{

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

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

update_property_info();

{

assert(_type == eString);

std::string ret(_str.substr(1, _str.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 (_next && index) {

Token *n = _next;

_next = n->next();

delete n;

--index;

}

if (_next)

_next->previous(this);

else if (tokensBack)

*tokensBack = this;

{

if (_next) {

Token temp(0);

temp._str = _next->_str;

temp._type = _next->_type;

temp._flags = _next->_flags;

temp._varId = _next->_varId;

temp._fileIndex = _next->_fileIndex;

temp._link = _next->_link;

temp._scope = _next->_scope;

temp._function = _next->_function;

temp._originalName = _next->_originalName;

temp.values = _next->values;

temp._progressValue = _next->_progressValue;

_next->_str = _str;

_next->_type = _type;

_next->_flags = _flags;

_next->_varId = _varId;

_next->_fileIndex = _fileIndex;

_next->_link = _link;

_next->_scope = _scope;

_next->_function = _function;

_next->_originalName = _originalName;

_next->values = values;

_next->_progressValue = _progressValue;

_str = temp._str;

_type = temp._type;

_flags = temp._flags;

_varId = temp._varId;

_fileIndex = temp._fileIndex;

_link = temp._link;

_scope = temp._scope;

_function = temp._function;

_originalName = temp._originalName;

values = temp.values;

_progressValue = temp._progressValue;

}

{

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

_str = _next->_str;

_type = _next->_type;

_flags = _next->_flags;

_varId = _next->_varId;

_fileIndex = _next->_fileIndex;

_linenr = _next->_linenr;

_link = _next->_link;

_scope = _next->_scope;

_function = _next->_function;

_variable = _next->_variable;

if (_next->_originalName) {

_originalName = _next->_originalName;

_next->_originalName = nullptr;

}

values = _next->values;

if (_link)

_link->link(this);

deleteNext();

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

_str = _previous->_str;

_type = _previous->_type;

_flags = _previous->_flags;

_varId = _previous->_varId;

_fileIndex = _previous->_fileIndex;

_linenr = _previous->_linenr;

_link = _previous->_link;

_scope = _previous->_scope;

_function = _previous->_function;

_variable = _previous->_variable;

if (_previous->_originalName) {

_originalName = _previous->_originalName;

_previous->_originalName = nullptr;

}

values = _previous->values;

if (_link)

_link->link(this);

Token* toDelete = _previous;

_previous = _previous->_previous;

_previous->_next = 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->tokensBack && *(end->tokensBack) == end) {

while (end->next())

end = end->next();

*(end->tokensBack) = end;

}

// Update _progressValue, fileIndex and linenr

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

tok->_progressValue = replaceThis->_progressValue;

// 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%)

{

haystack += 4;

return 1;

}

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->type() == 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->type() == 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->type() == Token::eBitOp && tok->str() == "|")

return 1;

}

}

// Oror (%oror%)

else {

haystack += 4;

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

return 1;

}

}

break;

default:

//unknown %cmd%, abort

throw InternalError(tok, "Unexpected command");

}

if (*haystack == '|')

haystack += 1;

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

return emptyStringFound ? 0 : -1;

else

return -1;

return 0xFFFF;

{

bool emptyStringFound = false;

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

const char *needlePointer = needle;

for (;;) {

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

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

if (ret < 2)

return ret;

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

if (*needlePointer == 0) {

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

return 1;

} else if (needlePointer == needle) {

// If needlePointer was not increased at all, we had a empty

// string in the haystack

emptyStringFound = true;

}

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 emptyStringFound ? 0 : -1;

}

++haystack;

}

}

if (*needlePointer == '\0')

return 1;

// If empty string was found earlier from the haystack

if (emptyStringFound)

return 0;

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

std::size_t length = static_cast<std::size_t>(next - current);

if (!tok || length != tok->_str.length() || std::strncmp(current, tok->_str.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 {

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

const std::string strValue(tok->strValue());

const char *str = strValue.c_str();

while (*str) {

if (index == 0) {

std::string ret;

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

ret = *str;

++str;

}

ret += *str;

return ret;

}

if (*str == '\\')

++str;

++str;

--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->_progressValue = newLocation->_progressValue;

{

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

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

return;

Token *newToken;

if (_str.empty())

newToken = this;

else

newToken = new Token(tokensBack);

newToken->str(tokenStr);

newToken->_linenr = _linenr;

newToken->_fileIndex = _fileIndex;

newToken->_progressValue = _progressValue;

if (newToken != this) {

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

*tokensBack = newToken;

}

this->next(newToken);

newToken->previous(this);

}

}

{

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

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

return;

Token *newToken;

if (_str.empty())

newToken = this;

else

newToken = new Token(tokensBack);

newToken->str(tokenStr);

if (!originalNameStr.empty())

newToken->originalName(originalNameStr);

newToken->_linenr = _linenr;

newToken->_fileIndex = _fileIndex;

newToken->_progressValue = _progressValue;

if (newToken != this) {

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

*tokensBack = 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, 0, 0) << std::endl;

{

if (title && title[0])

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

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

{

if (attributes) {