: _settings(0), _errorLogger(0)

{

// No tokens to start with

_tokens = 0;

_tokensBack = 0;

// is there any templates?

_codeWithTemplates = false;

// symbol database

_symbolDatabase = NULL;

// variable count

_varId = 0;

: _settings(settings), _errorLogger(errorLogger)

{

// make sure settings are specified

assert(_settings);

// No tokens to start with

_tokens = 0;

_tokensBack = 0;

// is there any templates?

_codeWithTemplates = false;

// symbol database

_symbolDatabase = NULL;

// variable count

_varId = 0;

{

if (str[0] == 0)

return;

// If token contains # characters, split it up

if (split && strstr(str, "##"))

{

std::string temp;

for (unsigned int i = 0; str[i]; ++i)

{

if (strncmp(&str[i], "##", 2) == 0)

{

addtoken(temp.c_str(), lineno, fileno, false);

temp.clear();

addtoken("##", lineno, fileno, false);

++i;

}

else

temp += str[i];

}

addtoken(temp.c_str(), lineno, fileno, false);

return;

}

// Replace hexadecimal value with decimal

std::ostringstream str2;

if (strncmp(str, "0x", 2) == 0 || strncmp(str, "0X", 2) == 0)

{

str2 << std::strtoul(str + 2, NULL, 16);

}

else

{

str2 << str;

}

if (_tokensBack)

{

_tokensBack->insertToken(str2.str().c_str());

}

else

{

_tokens = new Token(&_tokensBack);

_tokensBack = _tokens;

_tokensBack->str(str2.str());

}

_tokensBack->linenr(lineno);

_tokensBack->fileIndex(fileno);

{

if (tok == 0)

return;

// Replace hexadecimal value with decimal

std::ostringstream str2;

if (strncmp(tok->str().c_str(), "0x", 2) == 0)

{

str2 << std::strtoul(tok->str().c_str() + 2, NULL, 16);

}

else

{

str2 << tok->str();

}

if (_tokensBack)

{

_tokensBack->insertToken(str2.str().c_str());

}

else

{

_tokens = new Token(&_tokensBack);

_tokensBack = _tokens;

_tokensBack->str(str2.str());

}

_tokensBack->linenr(lineno);

_tokensBack->fileIndex(fileno);

_tokensBack->isUnsigned(tok->isUnsigned());

_tokensBack->isSigned(tok->isSigned());

_tokensBack->isLong(tok->isLong());

_tokensBack->isUnused(tok->isUnused());

{

if (!type || type->str().empty())

return 0;

if (type->str()[0] == '"')

return static_cast<unsigned int>(Token::getStrLength(type) + 1);

std::map<std::string, unsigned int>::const_iterator it = _typeSize.find(type->str());

if (it == _typeSize.end())

return 0;

else if (type->isLong())

{

if (type->str() == "double")

return sizeof(long double);

else if (type->str() == "long")

return sizeof(long);

}

return it->second;

{

std::stack<Token *> link;

while (n > 0)

{

dest->insertToken(src->str());

dest = dest->next();

// Set links

if (Token::Match(dest, "(|[|{"))

link.push(dest);

else if (!link.empty() && Token::Match(dest, ")|]|}"))

{

Token::createMutualLinks(dest, link.top());

link.pop();

}

dest->fileIndex(src->fileIndex());

dest->linenr(src->linenr());

dest->varId(src->varId());

dest->isName(src->isName());

dest->isNumber(src->isNumber());

dest->isBoolean(src->isBoolean());

dest->isUnsigned(src->isUnsigned());

dest->isSigned(src->isSigned());

dest->isPointerCompare(src->isPointerCompare());

dest->isLong(src->isLong());

dest->isUnused(src->isUnused());

src = src->next();

--n;

}

{

// line number in parsed code

unsigned int lineno = 1;

// The current token being parsed

std::string CurrentToken;

// lineNumbers holds line numbers for files in fileIndexes

// every time an include file is completely parsed, last item in the vector

// is removed and lineno is set to point to that value.

std::vector<unsigned int> lineNumbers;

// fileIndexes holds index for _files vector about currently parsed files

// every time an include file is completely parsed, last item in the vector

// is removed and FileIndex is set to point to that value.

std::vector<unsigned int> fileIndexes;

// FileIndex. What file in the _files vector is read now?

unsigned int FileIndex = 0;

// Read one byte at a time from code and create tokens

for (char ch = (char)code.get(); code.good(); ch = (char)code.get())

{

// char/string..

// multiline strings are not handled. The preprocessor should handle that for us.

if (ch == '\'' || ch == '\"')

{

std::string line;

// read char

bool special = false;

char c = ch;

do

{

// Append token..

line += c;

// Special sequence '\.'

if (special)

special = false;

else

special = (c == '\\');

// Get next character

c = (char)code.get();

}

while (code.good() && (special || c != ch));

line += ch;

// Handle #file "file.h"

if (CurrentToken == "#file")

{

// Extract the filename

line = line.substr(1, line.length() - 2);

// Has this file been tokenized already?

++lineno;

bool foundOurfile = false;

fileIndexes.push_back(FileIndex);

for (unsigned int i = 0; i < _files.size(); i++)

{

if (Path::sameFileName(_files[i].c_str(), line.c_str()))

{

// Use this index

foundOurfile = true;

FileIndex = i;

}

}

if (!foundOurfile)

{

// The "_files" vector remembers what files have been tokenized..

_files.push_back(Path::simplifyPath(line.c_str()));

FileIndex = static_cast<unsigned int>(_files.size() - 1);

}

lineNumbers.push_back(lineno);

lineno = 0;

}

else

{

// Add previous token

addtoken(CurrentToken.c_str(), lineno, FileIndex);

// Add content of the string

addtoken(line.c_str(), lineno, FileIndex);

}

CurrentToken.clear();

continue;

}

if (strchr("+-*/%&|^?!=<>[](){};:,.~\n ", ch))

{

if (ch == '.' &&

CurrentToken.length() > 0 &&

std::isdigit(CurrentToken[0]))

{

// Don't separate doubles "5.4"

}

else if (strchr("+-", ch) &&

CurrentToken.length() > 0 &&

std::isdigit(CurrentToken[0]) &&

(CurrentToken[CurrentToken.length()-1] == 'e' ||

CurrentToken[CurrentToken.length()-1] == 'E'))

{

// Don't separate doubles "4.2e+10"

}

else if (CurrentToken.empty() && ch == '.' && std::isdigit(code.peek()))

{

// tokenize .125 into 0.125

CurrentToken = "0";

}

else if (ch=='&' && code.peek() == '&')

{

if (!CurrentToken.empty())

{

addtoken(CurrentToken.c_str(), lineno, FileIndex, true);

CurrentToken.clear();

}

// &&

ch = (char)code.get();

addtoken("&&", lineno, FileIndex, true);

continue;

}

else if (ch==':' && CurrentToken.empty() && code.peek() == ' ')

{

// :

addtoken(":", lineno, FileIndex, true);

CurrentToken.clear();

continue;

}

else if (ch==':' && CurrentToken.empty() && code.peek() == ':')

{

// ::

ch = (char)code.get();

addtoken("::", lineno, FileIndex, true);

CurrentToken.clear();

continue;

}

else

{

if (CurrentToken == "#file")

{

// Handle this where strings are handled

continue;

}

else if (CurrentToken == "#endfile")

{

if (lineNumbers.empty() || fileIndexes.empty())

{

cppcheckError(0);

deallocateTokens();

return;

}

lineno = lineNumbers.back();

lineNumbers.pop_back();

FileIndex = fileIndexes.back();

fileIndexes.pop_back();

CurrentToken.clear();

continue;

}

addtoken(CurrentToken.c_str(), lineno, FileIndex, true);

CurrentToken.clear();

if (ch == '\n')

{

++lineno;

continue;

}

else if (ch == ' ')

{

continue;

}

CurrentToken += ch;

// Add "++", "--" or ">>" token

if ((ch == '+' || ch == '-' || ch == '>') && (code.peek() == ch))

CurrentToken += (char)code.get();

addtoken(CurrentToken.c_str(), lineno, FileIndex);

CurrentToken.clear();

continue;

}

}

CurrentToken += ch;

}

addtoken(CurrentToken.c_str(), lineno, FileIndex, true);

_tokens->assignProgressValues();

{

if (tok1 && !(_settings->_checkCodingStyle))

return;

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

std::string tok2_str;

if (tok1 && tok2)

{

ErrorLogger::ErrorMessage::FileLocation loc;

loc.line = tok1->linenr();

loc.setfile(file(tok1));

locationList.push_back(loc);

loc.line = tok2->linenr();

loc.setfile(file(tok2));

locationList.push_back(loc);

tok2_str = tok2->str();

}

else

tok2_str = "name";

const ErrorLogger::ErrorMessage errmsg(locationList,

Severity::style,

std::string(type + " '" + tok2_str +

"' hides typedef with same name"),

"variableHidingTypedef",

false);

if (_errorLogger)

_errorLogger->reportErr(errmsg);

else

Check::reportError(errmsg);

{

if (tok1 && !(_settings->_checkCodingStyle))

return;

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

std::string tok2_str;

if (tok1 && tok2)

{

ErrorLogger::ErrorMessage::FileLocation loc;

loc.line = tok1->linenr();

loc.setfile(file(tok1));

locationList.push_back(loc);

loc.line = tok2->linenr();

loc.setfile(file(tok2));

locationList.push_back(loc);

tok2_str = tok2->str();

}

else

tok2_str = "name";

const ErrorLogger::ErrorMessage errmsg(locationList,

Severity::style,

std::string(type + " '" + tok2_str +

"' forward declaration unnecessary, already declared"),

"unnecessaryForwardDeclaration",

false);

if (_errorLogger)

_errorLogger->reportErr(errmsg);

else

Check::reportError(errmsg);

{

// check for an end of definition

const Token * tok = *tokPtr;

if (tok && Token::Match(tok->next(), ";|,|[|=|)|>|(|{"))

{

const Token * end = tok->next();

if (end->str() == "[")

{

end = end->link()->next();

}

else if (end->str() == ",")

{

// check for derived class

if (Token::Match(tok->previous(), "public|private|protected"))

return false;

// find end of definition

int level = 0;

while (end && end->next() && (!Token::Match(end->next(), ";|)|>") ||

(end->next()->str() == ")" && level == 0)))

{

if (end->next()->str() == "(")

level++;

else if (end->next()->str() == ")")

level--;

end = end->next();

}

end = end->next();

}

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

{

if (tok->previous()->str().find("operator") == 0)

{

// conversion operator

return false;

}

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

{

// typedef of function returning this type

return false;

}

else if (Token::Match(tok->previous(), "public:|private:|protected:"))

{

return false;

}

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

{

if (!Token::Match(tok->tokAt(-2), "%type%"))

return false;

if (!Token::Match(tok->tokAt(-3), ",|<"))

return false;

duplicateTypedefError(*tokPtr, name, "Template instantiation");

*tokPtr = end->link();

return true;

}

else if (Token::Match(tok->previous(), "%type%"))

{

if (end->link()->next()->str() == "{")

{

duplicateTypedefError(*tokPtr, name, "Function");

*tokPtr = end->link()->next()->link();

return true;

}

}

}

if (end)

{

if (Token::simpleMatch(end, ") {")) // function parameter ?

{

// look backwards

if (Token::Match(tok->previous(), "%type%") &&

!Token::Match(tok->previous(), "return|new|const"))

{

duplicateTypedefError(*tokPtr, name, "Function parameter");

// duplicate definition so skip entire function

*tokPtr = end->next()->link();

return true;

}

}

else if (end->str() == ">") // template parameter ?

{

// look backwards

if (Token::Match(tok->previous(), "%type%") &&

!Token::Match(tok->previous(), "return|new|const|volatile"))

{

// duplicate definition so skip entire template

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

end = end->next();

if (end)

{

duplicateTypedefError(*tokPtr, name, "Template parameter");

*tokPtr = end->link();

return true;

}

}

}

else

{

// look backwards

if (Token::Match(tok->previous(), "typedef|}|>") ||

(tok->previous()->str() == "*" && tok->next()->str() != "(") ||

(Token::Match(tok->previous(), "%type%") &&

(!Token::Match(tok->previous(), "return|new|const|friend|public|private|protected|throw|extern") &&

!Token::simpleMatch(tok->tokAt(-2), "friend class"))))

{

// scan backwards for the end of the previous statement

int level = (tok->previous()->str() == "}") ? 1 : 0;

while (tok && tok->previous() && (!Token::Match(tok->previous(), ";|{") || (level != 0)))

{

if (tok->previous()->str() == "}")

{

tok = tok->previous()->link();

}

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

{

duplicateTypedefError(*tokPtr, name, "Typedef");

return true;

}

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

{

duplicateTypedefError(*tokPtr, name, "Enum");

return true;

}

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

{

if (tok->strAt(-2) == "typedef" &&

tok->next()->str() == "{" &&

typeDef->strAt(3) != "{")

{

// declaration after forward declaration

return true;

}

else if (tok->next()->str() != ";")

{

duplicateTypedefError(*tokPtr, name, "Struct");

return true;

}

else

{

// forward declaration after declaration

duplicateDeclarationError(*tokPtr, name, "Struct");

return false;

}

}

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

{

if (tok->next()->str() != ";")

{

duplicateTypedefError(*tokPtr, name, "Union");

return true;

}

else

{

// forward declaration after declaration

duplicateDeclarationError(*tokPtr, name, "Union");

return false;

}

}

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

{

if (tok->next()->str() != ";")

{

duplicateTypedefError(*tokPtr, name, "Class");

return true;

}

else

{

// forward declaration after declaration

duplicateDeclarationError(*tokPtr, name, "Class");

return false;

}

}

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

level--;

tok = tok->previous();

}

duplicateTypedefError(*tokPtr, name, "Variable");

return true;

}

}

}

}

return false;

{

if (!_settings->debugwarnings)

return;

std::ostringstream str;

const Token *tok1 = tok;

int level = 0;

while (tok)

{

if (level == 0 && tok->str() == ";")

break;

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

level++;

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

level--;

if (tok != tok1)

str << " ";

str << tok->str();

tok = tok->next();

}

if (tok)

str << " ;";

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

ErrorLogger::ErrorMessage::FileLocation loc;

loc.line = tok1->linenr();

loc.setfile(file(tok1));

locationList.push_back(loc);

const ErrorLogger::ErrorMessage errmsg(locationList,

Severity::debug,

"Failed to parse \'" + str.str() + "\'. The checking continues anyway.",

"debug",

false);

if (_errorLogger)

_errorLogger->reportErr(errmsg);

else

Check::reportError(errmsg);

{

bool isNamespace;

std::string className;

const Token * classEnd;

{