/*

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

* Copyright (C) 2007-2016 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 "check.h"

#include "library.h"

#include "mathlib.h"

#include "path.h"

#include "platform.h"

#include "settings.h"

#include "standards.h"

#include "symboldatabase.h"

#include "templatesimplifier.h"

#include "timer.h"

#include "token.h"

#include "utils.h"

#include "valueflow.h"

#include <algorithm>

#include <cassert>

#include <cctype>

#include <cstring>

#include <ctime>

#include <iostream>

#include <stack>

#include <utility>

#include <vector>

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

namespace {

// local struct used in setVarId

// in order to store information about the scope

struct VarIdScopeInfo {

VarIdScopeInfo()

:isExecutable(false), isStructInit(false), isEnum(false), startVarid(0) {

}

VarIdScopeInfo(bool _isExecutable, bool _isStructInit, bool _isEnum, unsigned int _startVarid)

:isExecutable(_isExecutable), isStructInit(_isStructInit), isEnum(_isEnum), startVarid(_startVarid) {

}

const bool isExecutable;

const bool isStructInit;

const bool isEnum;

const unsigned int startVarid;

};

}

/** Return whether tok is the "{" that starts an enumerator list */

static bool isEnumStart(const Token* tok)

{

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

return false;

return (tok->strAt(-1) == "enum") || (tok->strAt(-2) == "enum");

}

template<typename T>

static void skipEnumBody(T **tok)

{

T *defStart = *tok;

while (Token::Match(defStart, "%name%|::|:"))

defStart = defStart->next();

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

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

}

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

{

return Tokenizer::isFunctionHead(tok, endsWith, isCPP());

}

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

{

if (!tok)

return nullptr;

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

tok = tok->link();

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

tok = tok->next();

if (tok->isName())

tok = tok->next();

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

}

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

tok = tok->next();

while (Token::Match(tok, "const|noexcept|override|volatile|&|&& !!(") ||

(Token::Match(tok, "%name% !!(") && tok->isUpperCaseName()))

tok = tok->next();

if (Token::Match(tok, "throw|noexcept ("))

tok = tok->linkAt(1)->next();

if (Token::Match(tok, "%name% (") && tok->isUpperCaseName())

tok = tok->linkAt(1)->next();

if (tok && tok->str() == ".") { // trailing return type

for (tok = tok->next(); tok && !Token::Match(tok, "[;{]"); tok = tok->next())

if (tok->link() && Token::Match(tok, "<|[|("))

tok = tok->link();

}

if (Token::Match(tok, "= 0|default|delete ;"))

tok = tok->tokAt(2);

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(nullptr),

_settings(nullptr),

_errorLogger(nullptr),

_symbolDatabase(nullptr),

_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(nullptr),

_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 Token::getStrLength(type) + 1U;

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

if (it == _typeSize.end()) {

const Library::PodType* podtype = _settings->library.podtype(type->str());

if (!podtype)

return 0;

return podtype->size;

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

}

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

// check if this statement is a duplicate definition

bool Tokenizer::duplicateTypedef(Token **tokPtr, const Token *name, const Token *typeDef) 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); // 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;

*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|struct")) {

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

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

return true;

} else if (tok->previous()->str() == "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() == "{") {

return true;

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

return true;

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

return true;

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

return true;

} else {

return false;

}

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

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

return true;

} else {

return false;

}

} else if (isCPP() && tok->previous()->str() == "class") {

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

return true;

} else {

return false;

}

}

if (tok)

tok = tok->previous();

}

if ((*tokPtr)->strAt(1) != "(" || !Token::Match((*tokPtr)->linkAt(1), ") .|(|["))

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;

}

namespace {

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

{

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;

if (isMaxTime())

return;

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

Token *tokOffset2 = nullptr;

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

tokOffset2 = tokOffset->next();

if (tokOffset2->str() == "typename")

tokOffset2 = tokOffset2->next();

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

tokOffset2 = tokOffset2->tokAt(2);

}

// 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(tokOffset2, "* %name% ) (")) {

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

typeEnd = typeEnd->next();

functionPtr = true;

funcStart = funcEnd = tokOffset2; // *

tokOffset = tokOffset2->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% ) [")) {