{

enum Token {

StarToken,

AmpersandToken,

LessThanToken,

ColonToken,

CommaToken,

EllipsisToken,

OpenParenToken,

CloseParenToken,

SquareBegin,

SquareEnd,

GreaterThanToken,

ConstToken,

Identifier,

NoToken

};

Scanner(const QString &s)

: m_pos(0), m_length(s.length()), m_chars(s.constData())

{

}

Token nextToken();

QString identifier() const;

int m_pos;

int m_length;

int m_token_start;

const QChar *m_chars;

{

Token tok = NoToken;

// remove whitespace

while (m_pos < m_length && m_chars[m_pos] == ' ') {

++m_pos;

}

m_token_start = m_pos;

while (m_pos < m_length) {

const QChar &c = m_chars[m_pos];

if (tok == NoToken) {

switch (c.toLatin1()) {

case '*': tok = StarToken; break;

case '&': tok = AmpersandToken; break;

case '<': tok = LessThanToken; break;

case '>': tok = GreaterThanToken; break;

case ',': tok = CommaToken; break;

case '(': tok = OpenParenToken; break;

case ')': tok = CloseParenToken; break;

case '[': tok = SquareBegin; break;

case ']' : tok = SquareEnd; break;

case ':':

tok = ColonToken;

Q_ASSERT(m_pos + 1 < m_length);

++m_pos;

break;

case '.':

if (m_pos + 2 < m_length && c == m_chars[m_pos + 1] && c == m_chars[m_pos + 2]) {

tok = EllipsisToken;

m_pos += 2;

break;

}

default:

if (c.isLetterOrNumber() || c == '_')

tok = Identifier;

else

qFatal("Unrecognized character in lexer: %c", c.toLatin1());

break;

}

}

if (tok <= GreaterThanToken) {

++m_pos;

break;

}

if (tok == Identifier) {

if (c.isLetterOrNumber() || c == '_')

++m_pos;

else

break;

}

}

if (tok == Identifier && m_pos - m_token_start == 5) {

if (m_chars[m_token_start] == 'c'

&& m_chars[m_token_start + 1] == 'o'

&& m_chars[m_token_start + 2] == 'n'

&& m_chars[m_token_start + 3] == 's'

&& m_chars[m_token_start + 4] == 't')

tok = ConstToken;

}

return tok;

{

Scanner scanner(str);

Info info;

QStack<Info *> stack;

stack.push(&info);

bool colon_prefix = false;

bool in_array = false;

QString array;

Scanner::Token tok = scanner.nextToken();

while (tok != Scanner::NoToken) {

switch (tok) {

case Scanner::StarToken:

++stack.top()->indirections;

break;

case Scanner::AmpersandToken:

stack.top()->is_reference = true;

break;

case Scanner::LessThanToken:

stack.top()->template_instantiations << Info();

stack.push(&stack.top()->template_instantiations.last());

break;

case Scanner::CommaToken:

stack.pop();

stack.top()->template_instantiations << Info();

stack.push(&stack.top()->template_instantiations.last());

break;

case Scanner::GreaterThanToken:

stack.pop();

break;

case Scanner::ColonToken:

colon_prefix = true;

break;

case Scanner::ConstToken:

stack.top()->is_constant = true;

break;

case Scanner::OpenParenToken: // function pointers not supported

case Scanner::CloseParenToken:

case Scanner::EllipsisToken: // variadic templates not supported

{

Info i;

i.is_busted = true;

return i;

}

case Scanner::Identifier:

if (in_array) {

array = scanner.identifier();

} else if (colon_prefix || stack.top()->qualified_name.isEmpty()) {

stack.top()->qualified_name << scanner.identifier();

colon_prefix = false;

} else {

stack.top()->qualified_name.last().append(" " + scanner.identifier());

}

break;

case Scanner::SquareBegin:

in_array = true;

break;

case Scanner::SquareEnd:

in_array = false;

stack.top()->arrays += array;

break;

default:

break;

}

tok = scanner.nextToken();

}

return info;