: _settings(0), _errorLogger(0)

{

_tokens = 0;

_tokensBack = 0;

: _settings(settings), _errorLogger(errorLogger)

{

_tokens = 0;

_tokensBack = 0;

{

if (str[0] == 0)

return;

// Replace hexadecimal value with decimal

std::ostringstream str2;

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

{

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

}

else

{

str2 << str;

}

if (_tokensBack)

{

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

_tokensBack = _tokensBack->next();

}

else

{

_tokens = new Token;

_tokensBack = _tokens;

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

}

_tokensBack->linenr(lineno);

_tokensBack->fileIndex(fileno);

{

if (!type)

return 0;

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

if (it == _typeSize.end())

return 0;

return it->second;

{

while (n > 0)

{

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

dest = dest->next();

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

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

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

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

{

// We are not handling UTF and stuff like that. Code is supposed to plain simple text.

if (ch < 0)

continue;

// char/string..

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

{

std::string line;

// read char

bool special = false;

char c = ch;

do

{

// Append token..

line += c;

if (c == '\n')

++lineno;

// 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 (FileLister::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(FileLister::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')

{

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

}

else

{

if (CurrentToken == "#file")

{

// Handle this where strings are handled

continue;

}

else if (CurrentToken == "#endfile")

{

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

{

std::cerr << "####### Preprocessor bug! #######\n";

std::exit(0);

}

lineno = lineNumbers.back();

lineNumbers.pop_back();

FileIndex = fileIndexes.back();

fileIndexes.pop_back();

CurrentToken.clear();

continue;

}

// If token contains # characters, split it up

std::string temp;

for (std::string::size_type i = 0; i < CurrentToken.length(); ++i)

{

if (CurrentToken[i] == '#' && CurrentToken.length() + 1 > i && CurrentToken[i+1] == '#')

{

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

temp.clear();

addtoken("##", lineno, FileIndex);

++i;

}

else

temp += CurrentToken[i];

}

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

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

{

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

_files.push_back(FileLister::simplifyPath(FileName));

createTokens(code);

if (!createLinks())

{

// Source has syntax errors, can't proceed

return false;

}

// Combine "- %num%" ..

for (Token *tok = _tokens; tok; tok = tok->next())

{

if (Token::Match(tok, "[(+-*/=,] - %num%") && tok->strAt(2)[0] != '-')

{

tok->next()->str(std::string("-") + tok->strAt(2));

tok->next()->deleteNext();

}

if (Token::Match(tok, "return - %num%") && tok->strAt(2)[0] != '-')

{

tok->next()->str(std::string("-") + tok->strAt(2));

tok->next()->deleteNext();

}

}

// Combine tokens..

for (Token *tok = _tokens; tok && tok->next(); tok = tok->next())

{

static const char * const combineWithNext[][3] =

{

{ "<", "<", "<<" },

{ "&", "&", "&&" },

{ "|", "|", "||" },

{ "+", "=", "+=" },

{ "-", "=", "-=" },

{ "*", "=", "*=" },

{ "/", "=", "/=" },

{ "&", "=", "&=" },

{ "|", "=", "|=" },

{ "=", "=", "==" },

{ "!", "=", "!=" },

{ "<", "=", "<=" },

{ ">", "=", ">=" },

{ ":", ":", "::" },

{ "-", ">", "." }, // Replace "->" with "."

{ "private", ":", "private:" },

{ "protected", ":", "protected:" },

{ "public", ":", "public:" }

};

for (unsigned ui = 0; ui < sizeof(combineWithNext) / sizeof(combineWithNext[0]); ui++)

{

if (tok->str() == combineWithNext[ui][0] && tok->next()->str() == combineWithNext[ui][1])

{

tok->str(combineWithNext[ui][2]);

tok->deleteNext();

}

}

}

// typedef..

for (Token *tok = _tokens; tok; tok = tok->next())

{

if (tok->str() != "typedef")

continue;

if (Token::Match(tok->next(), "%type% %type% ;"))

{

const char *type1 = tok->strAt(1);

const char *type2 = tok->strAt(2);

tok = const_cast<Token*>(tok->tokAt(3));

for (Token *tok2 = tok; tok2; tok2 = tok2->next())

{

if (tok2->str() == type2)

tok2->str(type1);

}

}

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

{

const char *type1 = tok->strAt(1);

const char *type2 = tok->strAt(2);

const char *type3 = tok->strAt(3);

tok = const_cast<Token*>(tok->tokAt(4));

for (Token *tok2 = tok; tok2; tok2 = tok2->next())

{

if (tok2->str() == type3)

{

tok2->str(type1);

tok2->insertToken(type2);

tok2 = tok2->next();

}

}

}

}

// Remove __asm..

for (Token *tok = _tokens; tok; tok = tok->next())

{

if (Token::Match(tok->next(), "__asm|_asm|asm {"))

{

while (tok->next())

{

bool last(tok->next()->str() == "}");

// Unlink and delete tok->next()

tok->deleteNext();

// break if this was the last token to delete..

if (last)

break;

}

}

}

// Remove "volatile" and "mutable"

while (_tokens && (_tokens->str() == "volatile" || _tokens->str() == "mutable"))

{

_tokens->deleteThis();

}

for (Token *tok = _tokens; tok; tok = tok->next())

{

while (tok->next() && (tok->next()->str() == "volatile" || tok->next()->str() == "mutable"))

{

tok->deleteNext();

}

}

// replace "unsigned i" with "unsigned int i"

unsignedint();

/**

// Split up variable declarations.

simplifyVarDecl();

// Handle templates..

simplifyTemplates();

// Simplify the operator "?:"

simplifyConditionOperator();

// change array to pointer..

for (Token *tok = _tokens; tok; tok = tok->next())

{

if (Token::Match(tok, "%type% %var% [ ] [,;=]"))

{

tok->next()->deleteNext();

tok->next()->deleteNext();

tok->insertToken("*");

}

}

return true;

{

// Locate templates..

std::list<Token *> templates;

for (Token *tok = _tokens; tok; tok = tok->next())

{

if (Token::simpleMatch(tok, "template <"))

{

for (const Token *tok2 = tok; tok2; tok2 = tok2->next())

{

// Just a declaration => ignore this

if (tok2->str() == ";")

break;

// Implementation => add to "templates"

if (tok2->str() == "{")

{

templates.push_back(tok);

break;

}

}

}

}

if (templates.empty())

return;

// Locate possible instantiations of templates..

std::list<Token *> used;

for (Token *tok = _tokens; tok; tok = tok->next())

{

// template definition.. skip it

if (Token::simpleMatch(tok, "template <"))

{

unsigned int indentlevel = 0;

for (; tok; tok = tok->next())

{

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

{

++indentlevel;

}

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

{

if (indentlevel <= 1)

break;

--indentlevel;

}

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

{

break;

}

}

if (!tok)

break;

}

else if (Token::Match(tok->previous(), "[{};=] %var% <"))

{

used.push_back(tok);

}

}

if (used.empty())

return;

// expand templates

for (std::list<Token *>::iterator iter1 = templates.begin(); iter1 != templates.end(); ++iter1)

{

Token *tok = *iter1;

std::vector<std::string> type;

for (tok = tok->tokAt(2); tok && tok->str() != ">"; tok = tok->next())

{

if (Token::Match(tok, "%var% ,|>"))

type.push_back(tok->str());

}

// bail out if the end of the file was reached

if (!tok)

break;

// if this is a template function, get the position of the function name

unsigned int pos = 0;

if (Token::Match(tok, "> %type% *| %var% ("))

pos = 2;

else if (Token::Match(tok, "> %type% %type% *| %var% ("))

pos = 3;

if (pos > 0 && tok->tokAt(pos)->str() == "*")

++pos;

// name of template function/class..

const std::string name(tok->strAt(pos > 0 ? pos : 2));

const bool isfunc(pos > 0);

// locate template usage..

std::string s(name + " <");

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

{

if (i > 0)

s += ",";

s += " %any% ";

}

const std::string pattern(s + "> ");

for (std::list<Token *>::iterator iter2 = used.begin(); iter2 != used.end(); ++iter2)

{

Token *tok2 = *iter2;

if (tok2->str() != name)

continue;

if (!Token::Match(tok2, (pattern + (isfunc ? "(" : "%var%")).c_str()))

continue;

// New type..

std::vector<std::string> types2;

s = "";

for (const Token *tok3 = tok2->tokAt(2); tok3->str() != ">"; tok3 = tok3->next())

{

if (tok3->str() != ",")

types2.push_back(tok3->str());

s += tok3->str();

}

const std::string type2(s);

// New classname/funcname..

const std::string name2(name + "<" + type2 + ">");

// Copy template..

int _indentlevel = 0;

for (const Token *tok3 = _tokens; tok3; tok3 = tok3->next())

{

if (tok3->str() == "{")

++_indentlevel;

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

--_indentlevel;

// Start of template..

if (tok3 == tok)

{

tok3 = tok3->next();

}

// member function implemented outside class definition

else if (_indentlevel == 0 && Token::Match(tok3, (pattern + " :: %var% (").c_str()))

{

addtoken(name2.c_str(), tok3->linenr(), tok3->fileIndex());

while (tok3->str() != "::")

tok3 = tok3->next();

}

// not part of template.. go on to next token

else

continue;

int indentlevel = 0;

for (; tok3; tok3 = tok3->next())

{

if (tok3->str() == "{")

++indentlevel;

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

{

if (indentlevel <= 1)

{

// there is a bug if indentlevel is 0

// the "}" token should only be added if indentlevel is 1 but I add it always intentionally

// if indentlevel ever becomes 0, cppcheck will write:

// ### Error: Invalid number of character {

addtoken("}", tok3->linenr(), tok3->fileIndex());

break;

}

--indentlevel;

}

{

// search for this token in the type vector

unsigned int itype = 0;

while (itype < type.size() && type[itype] != tok3->str())

++itype;

// replace type with given type..

if (itype < type.size())

addtoken(types2[itype].c_str(), tok3->linenr(), tok3->fileIndex());

// replace name..

else if (tok3->str() == name)

addtoken(name2.c_str(), tok3->linenr(), tok3->fileIndex());

// copy

else

addtoken(tok3->str().c_str(), tok3->linenr(), tok3->fileIndex());

}

}

}

// Replace all these template usages..

s = name + " < " + type2 + " >";

for (std::string::size_type pos = s.find(","); pos != std::string::npos; pos = s.find(",", pos + 2))

{

s.insert(pos + 1, " ");

s.insert(pos, " ");

}

for (Token *tok4 = tok2; tok4; tok4 = tok4->next())

{

if (Token::simpleMatch(tok4, s.c_str()))

{

tok4->str(name2);

while (tok4->next()->str() != ">")

tok4->deleteNext();

tok4->deleteNext();

}

}

}

}

{

// Clear all variable ids

for (Token *tok = _tokens; tok; tok = tok->next())

tok->varId(0);

// Set variable ids..

unsigned int _varId = 0;

for (Token *tok = _tokens; tok; tok = tok->next())

{

if (tok != _tokens && !Token::Match(tok, "[,;{}(] %type%"))

continue;

if (Token::Match(tok, "[,;{}(] %type%"))

tok = tok->next();

if (Token::Match(tok, "else|return|typedef|delete"))

continue;

if (Token::Match(tok, "const|static|extern|public:|private:|protected:"))

tok = tok->next();

while (Token::Match(tok, "%var% ::"))

tok = tok->tokAt(2);

// Skip template arguments..

if (Token::Match(tok, "%type% <"))

{

Token *tok2 = tok->tokAt(2);

while (Token::Match(tok2, "%var% ::"))

tok2 = tok2->tokAt(2);

while (tok2 && (tok2->isName() || tok2->isNumber() || tok2->str() == "*" || tok2->str() == ","))

tok2 = tok2->next();

if (Token::Match(tok2, "> %var%"))

tok = tok2;

else if (Token::Match(tok2, "> ::|*|& %var%"))

tok = tok2->next();

else

continue; // Not code that I understand / not a variable declaration

}

// Determine name of declared variable..

const char *varname = 0;

Token *tok2 = tok->tokAt(1);

while (tok2)

{

if (tok2->isName())

varname = tok2->strAt(0);

else if (tok2->str() != "*" && tok2->str() != "&")

break;

tok2 = tok2->next();

}

// End of tokens reached..

if (!tok2)

break;

// Is it a function?

if (tok2->str() == "(")

{

// Search for function declaration, e.g. void f();

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

continue;

// Search for function declaration, e.g. void f( int c );

if (Token::Match(tok2->next(), "%num%") ||

Token::Match(tok2->next(), "%bool%") ||

tok2->next()->str()[0] == '"' ||

tok2->next()->varId() != 0)

{

// This is not a function

}

else

{

continue;

}

}

// Variable declaration found => Set variable ids

if (Token::Match(tok2, "[,();[=]") && varname)

{

++_varId;

int indentlevel = 0;

int parlevel = 0;

bool dot = false;

for (tok2 = tok->next(); tok2; tok2 = tok2->next())

{

if (!dot && tok2->str() == varname && !Token::Match(tok2->previous(), "struct|union"))

tok2->varId(_varId);

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

++indentlevel;

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

{

--indentlevel;

if (indentlevel < 0)

break;

}

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

++parlevel;

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

{

// Is this a function parameter or a variable declared in for example a for loop?

if (parlevel == 0 && indentlevel == 0 && Token::Match(tok2, ") const| {"))

;

else

--parlevel;

}

else if (parlevel < 0 && tok2->str() == ";")

break;

dot = bool(tok2->str() == ".");

}

}

}

// Struct/Class members

for (Token *tok = _tokens; tok; tok = tok->next())

{

// str.clear is a variable

// str.clear() is a member function

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

Token::Match(tok->next(), ". %var%") &&

!Token::Match(tok->tokAt(3), "(") &&

tok->tokAt(2)->varId() == 0)

{

++_varId;

const std::string pattern(std::string(". ") + tok->strAt(2));

for (Token *tok2 = tok; tok2; tok2 = tok2->next())

{

if (tok2->varId() == tok->varId() && Token::simpleMatch(tok2->next(), pattern.c_str()))

tok2->tokAt(2)->varId(_varId);

}

}

}

// Member functions in this source

std::list<Token *> allMemberFunctions;

{

const std::string funcpattern("%var% :: %var% (");

for (Token *tok2 = _tokens; tok2; tok2 = tok2->next())

{

// Found a class function..

if (Token::Match(tok2, funcpattern.c_str()))

{

allMemberFunctions.push_back(tok2);

}

}

}

// class members..

for (Token *tok = _tokens; tok; tok = tok->next())

{

if (Token::Match(tok, "class %var% {"))

{

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

// What member variables are there in this class?

std::map<std::string, unsigned int> varlist;

{

unsigned int indentlevel = 0;

for (const Token *tok2 = tok; tok2; tok2 = tok2->next())

{

// Indentation..

if (tok2->str() == "{")

++indentlevel;

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

{

if (indentlevel <= 1)

break;

--indentlevel;

}

// Found a member variable..

else if (indentlevel == 1 && tok2->varId() > 0)

varlist[tok2->str()] = tok2->varId();

}

}

// Are there any member variables in this class?

if (varlist.empty())

continue;

// Member functions for this class..

std::list<Token *> funclist;

{

const std::string funcpattern(classname + " :: %var% (");

for (std::list<Token *>::iterator func = allMemberFunctions.begin(); func != allMemberFunctions.end(); ++func)

{

Token *tok2 = *func;

// Found a class function..

if (Token::Match(tok2, funcpattern.c_str()))

{

// Goto the end paranthesis..

while (tok2 && tok2->str() != ")")

tok2 = tok2->next();

if (!tok2)

break;

// If this is a function implementation.. add it to funclist

if (Token::Match(tok2, ") const|volatile| {"))

funclist.push_back(tok2);

}

}

}

// Are there any member functions for this class?

if (funclist.empty())

continue;

// Update the variable ids..

// Parse each function..

for (std::list<Token *>::iterator func = funclist.begin(); func != funclist.end(); ++func)

{

unsigned int indentlevel = 0;

for (Token *tok2 = *func; tok2; tok2 = tok2->next())

{

if (tok2->str() == "{")

++indentlevel;

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

{

if (indentlevel <= 1)

break;

--indentlevel;

}

else if (indentlevel > 0 &&

tok2->varId() == 0 &&

varlist.find(tok2->str()) != varlist.end())

{

tok2->varId(varlist[tok2->str()]);

}

}

}

}

}

{

for (Token *token = _tokens; token; token = token->next())

{

while (token && token->str() == "namespace" &&

(!token->previous() || token->previous()->str() != "using"))

{

// Token is namespace and there is no "using" before it.

Token *start = token;

Token *tok = token->tokAt(2);

if (!tok)

return;

tok = tok->link();

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

{

tok = tok->previous();

tok->deleteNext();

start->deleteNext();

start->deleteNext();

if (start->previous())

{

token = start->next();

start = start->previous();