/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2015 Daniel Marjamäki and Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

#include "tokenize.h"

#include "mathlib.h"

#include "settings.h"

#include "check.h"

#include "path.h"

#include "symboldatabase.h"

#include "templatesimplifier.h"

#include "timer.h"

#include <cstring>

#include <sstream>

#include <cassert>

#include <cctype>

#include <stack>

#include <iostream>

//---------------------------------------------------------------------------

namespace {

// local struct used in setVarId

// in order to store information about the scope

struct scopeStackEntryType {

scopeStackEntryType()

:isExecutable(false), startVarid(0) {

}

scopeStackEntryType(bool _isExecutable, unsigned int _startVarid)

:isExecutable(_isExecutable), startVarid(_startVarid) {

}

const bool isExecutable;

const unsigned int startVarid;

};

}

const Token * Tokenizer::isFunctionHead(const Token *tok, const std::string &endsWith) const

{

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

tok = tok->link();

if (Token::Match(tok, ") const| [;:{]")) {

tok = tok->next();

if (tok->isName())

tok = tok->next();

return (endsWith.find(tok->str()) != std::string::npos) ? tok : nullptr;

}

if (isCPP() && Token::Match(tok, ") const| throw (")) {

tok = tok->next();

while (tok->isName())

tok = tok->next();

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

while (tok && tok->isName())

tok = tok->next();

return (tok && endsWith.find(tok->str()) != std::string::npos) ? tok : nullptr;

}

return nullptr;

}

/**

* is tok the start brace { of a class, struct, union, or enum

*/

static bool isClassStructUnionEnumStart(const Token * tok)

{

if (!Token::Match(tok->previous(), "class|struct|union|enum|%name%|>|>> {"))

return false;

const Token * tok2 = tok->previous();

while (tok2 && !Token::Match(tok2, "class|struct|union|enum|{|}|;"))

tok2 = tok2->previous();

return Token::Match(tok2, "class|struct|union|enum");

}

//---------------------------------------------------------------------------

Tokenizer::Tokenizer() :

list(0),

_settings(0),

_errorLogger(0),

_symbolDatabase(0),

_varId(0),

_codeWithTemplates(false), //is there any templates?

m_timerResults(nullptr)

#ifdef MAXTIME

,maxtime(std::time(0) + MAXTIME)

#endif

{

}

Tokenizer::Tokenizer(const Settings *settings, ErrorLogger *errorLogger) :

list(settings),

_settings(settings),

_errorLogger(errorLogger),

_symbolDatabase(0),

_varId(0),

_codeWithTemplates(false), //is there any templates?

m_timerResults(nullptr)

#ifdef MAXTIME

,maxtime(std::time(0) + MAXTIME)

#endif

{

// make sure settings are specified

assert(_settings);

}

Tokenizer::~Tokenizer()

{

delete _symbolDatabase;

}

//---------------------------------------------------------------------------

// SizeOfType - gives the size of a type

//---------------------------------------------------------------------------

unsigned int Tokenizer::sizeOfType(const Token *type) const

{

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

return 0;

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

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 _settings->sizeof_long_double;

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

return _settings->sizeof_long_long;

}

return it->second;

}

//---------------------------------------------------------------------------

Token *Tokenizer::copyTokens(Token *dest, const Token *first, const Token *last, bool one_line)

{

std::stack<Token *> links;

Token *tok2 = dest;

unsigned int linenrs = dest->linenr();

const unsigned int commonFileIndex = dest->fileIndex();

for (const Token *tok = first; tok != last->next(); tok = tok->next()) {

tok2->insertToken(tok->str());

tok2 = tok2->next();

tok2->fileIndex(commonFileIndex);

tok2->linenr(linenrs);

tok2->tokType(tok->tokType());

tok2->flags(tok->flags());

tok2->varId(tok->varId());

// Check for links and fix them up

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

links.push(tok2);

else if (Token::Match(tok2, ")|]|}")) {

if (links.empty())

return tok2;

Token * link = links.top();

tok2->link(link);

link->link(tok2);

links.pop();

}

if (!one_line && tok->next())

linenrs += tok->next()->linenr() - tok->linenr();

}

return tok2;

}

//---------------------------------------------------------------------------

void Tokenizer::duplicateTypedefError(const Token *tok1, const Token *tok2, const std::string &type) const

{

if (tok1 && !(_settings->isEnabled("style") && _settings->inconclusive))

return;

std::list<const Token*> locationList;

locationList.push_back(tok1);

locationList.push_back(tok2);

const std::string tok2_str = tok2 ? tok2->str() : std::string("name");

reportError(locationList, Severity::style, "variableHidingTypedef",

std::string("The " + type + " '" + tok2_str + "' hides a typedef with the same name."), true);

}

void Tokenizer::duplicateDeclarationError(const Token *tok1, const Token *tok2, const std::string &type) const

{

if (tok1 && !(_settings->isEnabled("style")))

return;

std::list<const Token*> locationList;

locationList.push_back(tok1);

locationList.push_back(tok2);

const std::string tok2_str = tok2 ? tok2->str() : std::string("name");

reportError(locationList, Severity::style, "unnecessaryForwardDeclaration",

std::string("The " + type + " '" + tok2_str + "' forward declaration is unnecessary. Type " + type + " is already declared earlier."));

}

// check if this statement is a duplicate definition

bool Tokenizer::duplicateTypedef(Token **tokPtr, const Token *name, const Token *typeDef, const std::set<std::string>& structs) const

{

// check for an end of definition

const Token * tok = *tokPtr;

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

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

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

if (!end->link())

syntaxError(end); // #6680 invalid code

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

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

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

end = end->linkAt(1);

end = (end)?end->next():nullptr;

}

if (end)

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;

}

}

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|}|>") ||

(end->str() == ";" && tok->previous()->str() == ",") ||

(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

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

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() == "{") {

if (structs.find(name->strAt(-1)) == structs.end())

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

return true;

} else if (Token::Match(tok->next(), ")|*")) {

return true;

} else if (tok->next()->str() == name->str()) {

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 (isCPP() && 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;

}

}

tok = tok->previous();

}

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

return true;

}

}

}

}

return false;

}

void Tokenizer::unsupportedTypedef(const Token *tok) const

{

if (!_settings->debugwarnings)

return;

std::ostringstream str;

const Token *tok1 = tok;

unsigned int level = 0;

while (tok) {

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

break;

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

++level;

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

if (!level)

break;

--level;

}

if (tok != tok1)

str << " ";

str << tok->str();

tok = tok->next();

}

if (tok)

str << " ;";

reportError(tok1, Severity::debug, "debug",

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

}

Token * Tokenizer::deleteInvalidTypedef(Token *typeDef)

{

Token *tok = nullptr;

// remove typedef but leave ;

while (typeDef->next()) {

if (typeDef->next()->str() == ";") {

typeDef->deleteNext();

break;

} else if (typeDef->next()->str() == "{")

Token::eraseTokens(typeDef, typeDef->linkAt(1));

else if (typeDef->next()->str() == "}")

break;

typeDef->deleteNext();

}

if (typeDef != list.front()) {

tok = typeDef->previous();

tok->deleteNext();

} else {

list.front()->deleteThis();

tok = list.front();

}

return tok;

}

struct Space {

Space() : classEnd(nullptr), isNamespace(false) { }

std::string className;

const Token * classEnd;

bool isNamespace;

};

static Token *splitDefinitionFromTypedef(Token *tok)

{

Token *tok1;

std::string name;

bool isConst = false;

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

tok->deleteNext();

isConst = true;

}

if (tok->strAt(2) == "{") { // unnamed

tok1 = tok->linkAt(2);

if (tok1 && tok1->next()) {

// use typedef name if available

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

name = tok1->next()->str();

else { // create a unique name

static unsigned int count = 0;

name = "Unnamed" + MathLib::toString(count++);

}

tok->next()->insertToken(name);

} else

return nullptr;

} else if (tok->strAt(3) == ":") {

tok1 = tok->tokAt(4);

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

tok1 = tok1->next();

if (!tok1)

return nullptr;

tok1 = tok1->link();

name = tok->strAt(2);

} else { // has a name

tok1 = tok->linkAt(3);

if (!tok1)

return nullptr;

name = tok->strAt(2);

}

tok1->insertToken(";");

tok1 = tok1->next();

if (tok1->next() && tok1->next()->str() == ";" && tok1->previous()->str() == "}") {

tok->deleteThis();

tok1->deleteThis();

return nullptr;

} else {

tok1->insertToken("typedef");

tok1 = tok1->next();

Token * tok3 = tok1;

if (isConst) {

tok1->insertToken("const");

tok1 = tok1->next();

}

tok1->insertToken(tok->next()->str()); // struct, union or enum

tok1 = tok1->next();

tok1->insertToken(name);

tok->deleteThis();

tok = tok3;

}

return tok;

}

/* This function is called when processing function related typedefs.

* If simplifyTypedef generates an "Internal Error" message and the

* code that generated it deals in some way with functions, then this

* function will probably need to be extended to handle a new function

* related pattern */

Token *Tokenizer::processFunc(Token *tok2, bool inOperator) const

{

if (tok2->next() && tok2->next()->str() != ")" &&

tok2->next()->str() != ",") {

// skip over tokens for some types of canonicalization

if (Token::Match(tok2->next(), "( * %type% ) ("))

tok2 = tok2->linkAt(5);

else if (Token::Match(tok2->next(), "* ( * %type% ) ("))

tok2 = tok2->linkAt(6);

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

tok2 = tok2->tokAt(5);

else if (Token::Match(tok2->next(), "* ( %type% [") &&

Token::Match(tok2->linkAt(4), "] ) ;|="))

tok2 = tok2->linkAt(4)->next();

else if (Token::Match(tok2->next(), "* ( * %type% ("))

tok2 = tok2->linkAt(5)->next();

else if (Token::simpleMatch(tok2->next(), "* [") &&

Token::simpleMatch(tok2->linkAt(2), "] ;"))

tok2 = tok2->next();

else {

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

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

else if (!inOperator && !Token::Match(tok2->next(), "[|>|;")) {

tok2 = tok2->next();

while (Token::Match(tok2, "*|&") &&

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

tok2 = tok2->next();

// skip over namespace

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

tok2 = tok2->tokAt(2);

if (!tok2)

return nullptr;

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

tok2->link()->next() &&

tok2->link()->next()->str() == "(") {

tok2 = tok2->link();

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

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

}

// skip over typedef parameter

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

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

if (!tok2->next())

syntaxError(tok2);

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

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

}

}

}

}

return tok2;

}

void Tokenizer::simplifyTypedef()

{

// Collect all structs for later detection of undefined structs

std::set<std::string> structs;

for (const Token* tok = list.front(); tok; tok = tok->next()) {

if (Token::Match(tok, "struct %type% {|:"))

structs.insert(tok->strAt(1));

}

std::vector<Space> spaceInfo;

bool isNamespace = false;

std::string className;

bool hasClass = false;

bool goback = false;

for (Token *tok = list.front(); tok; tok = tok->next()) {

if (_errorLogger && !list.getFiles().empty())

_errorLogger->reportProgress(list.getFiles()[0], "Tokenize (typedef)", tok->progressValue());

if (_settings->terminated())

return;

#ifdef MAXTIME

if (std::time(0) > maxtime)

return;

#endif

if (goback) {

//jump back once, see the comment at the end of the function

goback = false;

tok = tok->previous();

}

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

if (tok->str() == "(" && tok->strAt(1) == "typedef") {

// Skip typedefs inside parentheses (#2453 and #4002)

tok = tok->next();

} else if (Token::Match(tok, "class|struct|namespace %any%") &&

(!tok->previous() || tok->previous()->str() != "enum")) {

isNamespace = (tok->str() == "namespace");

hasClass = true;

className = tok->next()->str();

} else if (hasClass && tok->str() == ";") {

hasClass = false;

} else if (hasClass && tok->str() == "{") {

Space info;

info.isNamespace = isNamespace;

info.className = className;

info.classEnd = tok->link();

spaceInfo.push_back(info);

hasClass = false;

} else if (!spaceInfo.empty() && tok->str() == "}" && spaceInfo.back().classEnd == tok) {

spaceInfo.pop_back();

}

continue;

}

// pull struct, union, enum or class definition out of typedef

// use typedef name for unnamed struct, union, enum or class

if (Token::Match(tok->next(), "const| struct|enum|union|class %type%| {")) {

Token *tok1 = splitDefinitionFromTypedef(tok);

if (!tok1)

continue;

tok = tok1;

} else if (Token::Match(tok->next(), "const| struct|class %type% :")) {

Token *tok1 = tok;

while (tok1 && tok1->str() != ";" && tok1->str() != "{")

tok1 = tok1->next();

if (tok1 && tok1->str() == "{") {

tok1 = splitDefinitionFromTypedef(tok);

if (!tok1)

continue;

tok = tok1;

}

}

/** @todo add support for union */

if (Token::Match(tok->next(), "enum %type% %type% ;") && tok->strAt(2) == tok->strAt(3)) {

tok->deleteNext(3);

tok->deleteThis();

if (tok->next())

tok->deleteThis();

//now the next token to process is 'tok', not 'tok->next()';

goback = true;

continue;

}

Token *typeName;

Token *typeStart = nullptr;

Token *typeEnd = nullptr;

Token *argStart = nullptr;

Token *argEnd = nullptr;

Token *arrayStart = nullptr;

Token *arrayEnd = nullptr;

Token *specStart = nullptr;

Token *specEnd = nullptr;

Token *typeDef = tok;

Token *argFuncRetStart = nullptr;

Token *argFuncRetEnd = nullptr;

Token *funcStart = nullptr;

Token *funcEnd = nullptr;

Token *tokOffset = tok->next();

bool function = false;

bool functionPtr = false;

bool functionRef = false;

bool functionRetFuncPtr = false;

bool functionPtrRetFuncPtr = false;

bool ptrToArray = false;

bool refToArray = false;

bool ptrMember = false;

bool typeOf = false;

Token *namespaceStart = nullptr;

Token *namespaceEnd = nullptr;

// check for invalid input

if (!tokOffset)

syntaxError(tok);

if (tokOffset->str() == "::") {

typeStart = tokOffset;

tokOffset = tokOffset->next();

while (Token::Match(tokOffset, "%type% ::"))

tokOffset = tokOffset->tokAt(2);

typeEnd = tokOffset;

if (Token::Match(tokOffset, "%type%"))

tokOffset = tokOffset->next();

} else if (Token::Match(tokOffset, "%type% ::")) {

typeStart = tokOffset;

do {

tokOffset = tokOffset->tokAt(2);

} while (Token::Match(tokOffset, "%type% ::"));

typeEnd = tokOffset;

if (Token::Match(tokOffset, "%type%"))

tokOffset = tokOffset->next();

} else if (Token::Match(tokOffset, "%type%")) {

typeStart = tokOffset;

while (Token::Match(tokOffset, "const|signed|unsigned|struct|enum %type%") ||

(tokOffset->next() && tokOffset->next()->isStandardType()))

tokOffset = tokOffset->next();

typeEnd = tokOffset;

tokOffset = tokOffset->next();

bool atEnd = false;

while (!atEnd) {

if (tokOffset && tokOffset->str() == "::") {

typeEnd = tokOffset;

tokOffset = tokOffset->next();

}

if (Token::Match(tokOffset, "%type%") &&

tokOffset->next() && !Token::Match(tokOffset->next(), "[|;|,|(")) {

typeEnd = tokOffset;

tokOffset = tokOffset->next();

} else if (Token::simpleMatch(tokOffset, "const (")) {

typeEnd = tokOffset;

tokOffset = tokOffset->next();

atEnd = true;

} else

atEnd = true;

}

} else

continue; // invalid input

// check for invalid input

if (!tokOffset)

syntaxError(tok);

// check for template

if (!isC() && tokOffset->str() == "<") {

typeEnd = tokOffset->findClosingBracket();

while (typeEnd && Token::Match(typeEnd->next(), ":: %type%"))

typeEnd = typeEnd->tokAt(2);

if (!typeEnd) {

// internal error

return;

}

while (Token::Match(typeEnd->next(), "const|volatile"))

typeEnd = typeEnd->next();

tok = typeEnd;

tokOffset = tok->next();

}

std::list<std::string> pointers;

// check for pointers and references

while (Token::Match(tokOffset, "*|&|&&|const")) {

pointers.push_back(tokOffset->str());

tokOffset = tokOffset->next();

}

// check for invalid input

if (!tokOffset)

syntaxError(tok);

if (Token::Match(tokOffset, "%type%")) {

// found the type name

typeName = tokOffset;

tokOffset = tokOffset->next();

// check for array

if (tokOffset && tokOffset->str() == "[") {

arrayStart = tokOffset;

bool atEnd = false;

while (!atEnd) {

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

tokOffset = tokOffset->next();

}

if (!tokOffset->next())

return; // invalid input

else if (tokOffset->next()->str() == ";")

atEnd = true;

else if (tokOffset->str() == "]")

atEnd = true;

else

tokOffset = tokOffset->next();

}

arrayEnd = tokOffset;

tokOffset = tokOffset->next();

}

// check for end or another

if (Token::Match(tokOffset, ";|,"))

tok = tokOffset;

// or a function typedef

else if (tokOffset && tokOffset->str() == "(") {

// unhandled typedef, skip it and continue

if (typeName->str() == "void") {

unsupportedTypedef(typeDef);

tok = deleteInvalidTypedef(typeDef);

if (tok == list.front())

//now the next token to process is 'tok', not 'tok->next()';

goback = true;

continue;

}

// function pointer

else if (Token::Match(tokOffset, "( * %name% ) (")) {

// name token wasn't a name, it was part of the type

typeEnd = typeEnd->next();

functionPtr = true;

tokOffset = tokOffset->next();

funcStart = tokOffset;

funcEnd = tokOffset;

tokOffset = tokOffset->tokAt(3);

typeName = tokOffset->tokAt(-2);

argStart = tokOffset;

argEnd = tokOffset->link();

tok = argEnd->next();

}

// function

else if (isFunctionHead(tokOffset->link(), ";,")) {

function = true;

if (tokOffset->link()->next()->str() == "const") {

specStart = tokOffset->link()->next();

specEnd = specStart;

}

argStart = tokOffset;

argEnd = tokOffset->link();

tok = argEnd->next();

if (specStart)

tok = tok->next();

}

// syntax error

else

syntaxError(tok);

}

// unhandled typedef, skip it and continue

else {

unsupportedTypedef(typeDef);

tok = deleteInvalidTypedef(typeDef);

if (tok == list.front())

//now the next token to process is 'tok', not 'tok->next()';

goback = true;

continue;

}

}

// typeof: typedef __typeof__ ( ... ) type;

else if (Token::simpleMatch(tokOffset->previous(), "__typeof__ (") &&

Token::Match(tokOffset->link(), ") %type% ;")) {

argStart = tokOffset;

argEnd = tokOffset->link();

typeName = tokOffset->link()->next();

tok = typeName->next();

typeOf = true;

}

// function: typedef ... ( ... type )( ... );

// typedef ... (( ... type )( ... ));

// typedef ... ( * ( ... type )( ... ));

else if (tokOffset->str() == "(" && (

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

Token::Match(tokOffset->link()->next()->link(), ") const|volatile|;")) ||

(Token::simpleMatch(tokOffset, "( (") &&

tokOffset->next() && Token::Match(tokOffset->next()->link()->previous(), "%type% ) (") &&

Token::Match(tokOffset->next()->link()->next()->link(), ") const|volatile| ) ;|,")) ||

(Token::simpleMatch(tokOffset, "( * (") &&

tokOffset->linkAt(2) && Token::Match(tokOffset->linkAt(2)->previous(), "%type% ) (") &&

Token::Match(tokOffset->linkAt(2)->next()->link(), ") const|volatile| ) ;|,")))) {

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

tokOffset = tokOffset->next();

else if (Token::simpleMatch(tokOffset, "( * (")) {

pointers.push_back("*");

tokOffset = tokOffset->tokAt(2);

}

if (tokOffset->link()->strAt(-2) == "*")

functionPtr = true;

else

function = true;

funcStart = tokOffset->next();

tokOffset = tokOffset->link();

funcEnd = tokOffset->tokAt(-2);

typeName = tokOffset->previous();

argStart = tokOffset->next();

argEnd = tokOffset->next()->link();

if (!argEnd)

syntaxError(argStart);

tok = argEnd->next();

Token *spec = tok;

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

specStart = spec;

specEnd = spec;

while (Token::Match(spec->next(), "const|volatile")) {

specEnd = spec->next();

spec = specEnd;

}

tok = specEnd->next();

}

if (!tok)

syntaxError(specEnd);

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

tok = tok->next();

}

else if (Token::Match(tokOffset, "( %type% (")) {

function = true;

if (tokOffset->link()->next()) {

tok = tokOffset->link()->next();

tokOffset = tokOffset->tokAt(2);

typeName = tokOffset->previous();

argStart = tokOffset;

argEnd = tokOffset->link();

} else {

// internal error

continue;

}

}

// pointer to function returning pointer to function

else if (Token::Match(tokOffset, "( * ( * %type% ) (") &&

Token::simpleMatch(tokOffset->linkAt(6), ") ) (") &&

Token::Match(tokOffset->linkAt(6)->linkAt(2), ") ;|,")) {

functionPtrRetFuncPtr = true;

tokOffset = tokOffset->tokAt(6);

typeName = tokOffset->tokAt(-2);

argStart = tokOffset;

argEnd = tokOffset->link();

if (!argEnd)

syntaxError(arrayStart);

argFuncRetStart = argEnd->tokAt(2);

argFuncRetEnd = argFuncRetStart->link();

if (!argFuncRetEnd)

syntaxError(argFuncRetStart);

tok = argFuncRetEnd->next();

}

// function returning pointer to function

else if (Token::Match(tokOffset, "( * %type% (") &&

Token::simpleMatch(tokOffset->linkAt(3), ") ) (") &&

Token::Match(tokOffset->linkAt(3)->linkAt(2), ") ;|,")) {

functionRetFuncPtr = true;

tokOffset = tokOffset->tokAt(3);

typeName = tokOffset->previous();

argStart = tokOffset;

argEnd = tokOffset->link();

argFuncRetStart = argEnd->tokAt(2);

if (!argFuncRetStart)

syntaxError(tokOffset);

argFuncRetEnd = argFuncRetStart->link();

if (!argFuncRetEnd)

syntaxError(tokOffset);

tok = argFuncRetEnd->next();

} else if (Token::Match(tokOffset, "( * ( %type% ) (")) {

functionRetFuncPtr = true;

tokOffset = tokOffset->tokAt(5);

typeName = tokOffset->tokAt(-2);

argStart = tokOffset;

argEnd = tokOffset->link();

if (!argEnd)

syntaxError(arrayStart);

argFuncRetStart = argEnd->tokAt(2);

if (!argFuncRetStart)

syntaxError(tokOffset);

argFuncRetEnd = argFuncRetStart->link();

if (!argFuncRetEnd)

syntaxError(tokOffset);

tok = argFuncRetEnd->next();

}

// pointer/reference to array

else if (Token::Match(tokOffset, "( *|& %type% ) [")) {

ptrToArray = (tokOffset->next()->str() == "*");

refToArray = !ptrToArray;

tokOffset = tokOffset->tokAt(2);

typeName = tokOffset;