: _M_location(token_stream, location_table, line_table),

control(c),

lexer(_M_location, control)

{

_M_block_errors = false;

{

token_stream.nextToken();

keepTrackDebug();

{

token_stream.rewind(pos);

keepTrackDebug();

{

if (token_stream.lookAhead() != Token_identifier)

return false;

std::size_t start = token_stream.cursor();

const NameSymbol *name_symbol = token_stream.symbol(token_stream.cursor());

QString name = name_symbol->as_string();

if (name != QLatin1String("__declspec"))

return false;

std::size_t specifier = token_stream.cursor();

nextToken();

if (token_stream.lookAhead() != '(')

return false;

nextToken();

if (token_stream.lookAhead() != Token_identifier)

return false;

std::size_t modifier = token_stream.cursor();

nextToken();

if (token_stream.lookAhead() != ')')

return false;

nextToken();

node = CreateNode<WinDeclSpecAST>(_M_pool);

node->specifier = specifier;

node->modifier = modifier;

UPDATE_POS(node, start, token_stream.cursor());

return true;

{

QString err;

err += "expected token ";

err += "``";

err += token_name(token);

err += "'' found ``";

err += token_name(token_stream.lookAhead());

err += "''";

reportError(err);

{

QString err;

err += "unexpected token ";

err += "``";

err += token_name(token_stream.lookAhead());

err += "''";

reportError(err);

{

if (!_M_block_errors)

{

int line, column;

QString fileName;

std::size_t tok = token_stream.cursor();

location().positionAt(token_stream.position(tok),

&line, &column, &fileName);

Control::ErrorMessage errmsg;

errmsg.setLine(line + 1);

errmsg.setColumn(column);

errmsg.setFileName(fileName);

errmsg.setMessage(QLatin1String("** PARSER ERROR ") + msg);

control->reportError(errmsg);

}

{

#ifndef NDEBUG

std::size_t tok = token_stream.cursor();

location().positionAt(token_stream.position(tok),

&_currentLine, &_currentColumn, &_currentFile);

_currentToken = token_name(token_stream.lookAhead());

if (token_stream.lookAhead() == Token_identifier)

{

_currentSymbol = token_stream.symbol(tok)->as_string();

}

else

{

_currentSymbol = "";

}

#endif

{

// we are currently not interested in alignas, so we just skip it

if (token_stream.lookAhead() == Token_alignas)

{

nextToken();

if (token_stream.lookAhead() == '(')

{

if (skip('(', ')'))

{

nextToken();

}

}

return true;

}

return false;

{

bool any = false;

while (true) {

if (token_stream.lookAhead() == Token___attribute__)

{

parse_Attribute__();

any = true;

}

else if (token_stream.lookAhead() == '[' && token_stream.lookAhead(1) == '[')

{

nextToken();

while (true)

{

nextToken();

int tk = token_stream.lookAhead();

if (tk == Token_EOF)

{

break;

}

else if (tk == ']' && token_stream.lookAhead(1) == ']') // this has no separate token because "]]" can occur in other contexts

{

nextToken();

nextToken();

break;

}

}

any = true;

}

else

{

break;

}

}

return any;

{

while (token_stream.lookAhead())

{

if (token_stream.lookAhead() == token)

return true;

nextToken();

}

return false;

{

while (token_stream.lookAhead())

{

switch(token_stream.lookAhead())

{

case ';':

case '~':

case Token_scope:

case Token_identifier:

case Token_operator:

case Token_char:

case Token_wchar_t:

case Token_bool:

case Token_short:

case Token_int:

case Token_long:

case Token_signed:

case Token_unsigned:

case Token_float:

case Token_double:

case Token_void:

case Token_extern:

case Token_namespace:

case Token_using:

case Token_typedef:

case Token_asm:

case Token_template:

case Token_export:

case Token_const: // cv

case Token_constexpr: // cv

case Token_volatile: // cv

case Token_mutable: // cv

case Token_public:

case Token_protected:

case Token_private:

case Token_signals: // Qt

case Token_slots: // Qt

return true;

case Token_decltype:

case Token___typeof:

reportError("C++11 decltype/__typeof(id|expression) not handled");

return true;

default:

nextToken();

}

}

return false;

{

while (token_stream.lookAhead())

{

switch(token_stream.lookAhead())

{

case ';':

case '{':

case '}':

case Token_const:

case Token_constexpr:

case Token_decltype:

case Token___typeof:

case Token_volatile:

case Token_mutable:

case Token_identifier:

case Token_case:

case Token_default:

case Token_if:

case Token_switch:

case Token_while:

case Token_do:

case Token_for:

case Token_break:

case Token_continue:

case Token_return:

case Token_goto:

case Token_try:

case Token_catch:

case Token_throw:

case Token_char:

case Token_wchar_t:

case Token_bool:

case Token_short:

case Token_int:

case Token_long:

case Token_signed:

case Token_unsigned:

case Token_float:

case Token_double:

case Token_void:

case Token_class:

case Token_struct:

case Token_union:

case Token_enum:

case Token_scope:

case Token_template:

case Token_using:

return true;

default:

nextToken();

}

}

return false;

{

int count = 0;

while (token_stream.lookAhead())

{

int tk = token_stream.lookAhead();

if (tk == l)

++count;

else if (tk == r)

--count;

else if (l != '{' && (tk == '{' || tk == '}' || tk == ';'))

return false;

if (count == 0)

return true;

nextToken();

}

return false;

{

std::size_t start = token_stream.cursor();

WinDeclSpecAST *winDeclSpec = 0;

while (skipAlignas() || (!winDeclSpec && parseWinDeclSpec(winDeclSpec)))

{

;

}

NameAST *ast = CreateNode<NameAST>(_M_pool);

if (token_stream.lookAhead() == Token_scope)

{

ast->global = true;

nextToken();

}

std::size_t idx = token_stream.cursor();

while (true)

{

UnqualifiedNameAST *n = 0;

if (!parseUnqualifiedName(n, acceptTemplateId))

return false;

if (token_stream.lookAhead() == Token_scope)

{

nextToken();

ast->qualified_names

= snoc(ast->qualified_names, n, _M_pool);

if (token_stream.lookAhead() == Token_template)

{

/// skip optional template #### @todo CHECK

nextToken();

}

}

else

{

Q_ASSERT(n != 0);

ast->unqualified_name = n;

break;

}

}

if (idx == token_stream.cursor())

return false;

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{

std::size_t start = token_stream.cursor();

TranslationUnitAST *ast = CreateNode<TranslationUnitAST>(_M_pool);

while (token_stream.lookAhead())

{

std::size_t startDecl = token_stream.cursor();

DeclarationAST *declaration = 0;

if (parseDeclaration(declaration))

{

ast->declarations =

snoc(ast->declarations, declaration, _M_pool);

}

else

{

// error recovery

if (startDecl == token_stream.cursor())

{

// skip at least one token

nextToken();

}

skipUntilDeclaration();

}

}

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{

std::size_t start = token_stream.cursor();

switch(token_stream.lookAhead())

{

case ';':

// ignore ellipse in constructs like

// using T1 = T2<f<Args>...>;

case Token_ellipsis:

nextToken();

return true;

case Token_extern:

return parseLinkageSpecification(node);

case Token_namespace:

return parseNamespace(node);

case Token_using:

return parseUsing(node);

case Token_typedef:

return parseTypedef(node);

case Token_asm:

return parseAsmDefinition(node);

case Token_Q_ENUMS:

return parseQ_ENUMS(node);

case Token_Q_ENUM:

return parseQ_ENUM(node);

case Token_template:

case Token_export:

return parseTemplateDeclaration(node);

case Token_inline:

if (token_stream.lookAhead(1) == Token_namespace)

{

nextToken();

// handle like a normal namespace for now

return parseNamespace(node);

}

// else fallthrough

default:

{

skipAttributes();

const ListNode<std::size_t> *cv = 0;

const ListNode<std::size_t>* storageSpec = 0;

// consume all qualifiers/specifiers

while (parseCvQualify(cv) || parseStorageClassSpecifier(storageSpec))

{

;

}

TypeSpecifierAST *spec = 0;

if (parseEnumSpecifier(spec)

|| parseClassSpecifier(spec)

|| parseForwardDeclarationSpecifier(spec))

{

parseCvQualify(cv);

spec->cv = cv;

const ListNode<InitDeclaratorAST*> *declarators = 0;

parseInitDeclaratorList(declarators);

ADVANCE(';', ";");

SimpleDeclarationAST *ast =

CreateNode<SimpleDeclarationAST>(_M_pool);

ast->storage_specifiers = storageSpec;

ast->type_specifier = spec;

ast->init_declarators = declarators;

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

}

}

} // end switch

rewind(start);

return parseDeclarationInternal(node);

{

std::size_t start = token_stream.cursor();

CHECK(Token_extern);

LinkageSpecificationAST *ast = CreateNode<LinkageSpecificationAST>(_M_pool);

if (token_stream.lookAhead() == Token_string_literal)

{

ast->extern_type = token_stream.cursor();

nextToken();

}

if (token_stream.lookAhead() == '{')

{

parseLinkageBody(ast->linkage_body);

}

else if (!parseDeclaration(ast->declaration))

{

reportError(("Declaration syntax error"));

}

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{

std::size_t start = token_stream.cursor();

CHECK('{');

LinkageBodyAST *ast = CreateNode<LinkageBodyAST>(_M_pool);

while (token_stream.lookAhead())

{

int tk = token_stream.lookAhead();

if (tk == '}')

break;

std::size_t startDecl = token_stream.cursor();

DeclarationAST *declaration = 0;

if (parseDeclaration(declaration))

{

ast->declarations = snoc(ast->declarations, declaration, _M_pool);

}

else

{

// error recovery

if (startDecl == token_stream.cursor())

{

// skip at least one token

nextToken();

}

skipUntilDeclaration();

}

}

if (token_stream.lookAhead() != '}')

reportError(("} expected"));

else

nextToken();

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{

std::size_t start = token_stream.cursor();

CHECK(Token_namespace);

std::size_t namespace_name = 0;

if (token_stream.lookAhead() == Token_identifier)

{

namespace_name = token_stream.cursor();

nextToken();

}

if (token_stream.lookAhead() == '=')

{

// namespace alias

nextToken();

NameAST *name = 0;

if (parseName(name))

{

ADVANCE(';', ";");

NamespaceAliasDefinitionAST *ast

= CreateNode<NamespaceAliasDefinitionAST>(_M_pool);

ast->namespace_name = namespace_name;

ast->alias_name = name;

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

}

else

{

reportError(("namespace expected"));

return false;

}

}

else if (token_stream.lookAhead() != '{')

{

reportError(("{ expected"));

return false;

}

NamespaceAST *ast = CreateNode<NamespaceAST>(_M_pool);

ast->namespace_name = namespace_name;

parseLinkageBody(ast->linkage_body);

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{

std::size_t start = token_stream.cursor();

CHECK(Token_using);

if (token_stream.lookAhead(1) == '=')

{

return parseUsingTypedef(node);

}

if (token_stream.lookAhead() == Token_namespace)

return parseUsingDirective(node);

UsingAST *ast = CreateNode<UsingAST>(_M_pool);

if (token_stream.lookAhead() == Token_typename)

{

ast->type_name = token_stream.cursor();

nextToken();

}

if (!parseName(ast->name, /*acceptTemplateId=*/true))

return false;

ADVANCE(';', ";");

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{

std::size_t start = token_stream.cursor();

DeclaratorAST* decl = 0;

if (!parseDeclarator(decl))

{

return false;

}

InitDeclaratorAST* init_decl = CreateNode<InitDeclaratorAST>(_M_pool);

init_decl->declarator = decl;

init_decl->initializer = 0;

const ListNode<InitDeclaratorAST*>* declarators = 0;

declarators = snoc(declarators, init_decl, _M_pool);

ADVANCE('=', "=");

TypeSpecifierAST* spec = 0;

if (!parseTypeSpecifierOrClassSpec(spec))

{

reportError(("Need a type specifier to declare"));

return false;

}

TypedefAST* ast = CreateNode<TypedefAST>(_M_pool);

ast->type_specifier = spec;

ast->init_declarators = declarators;

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{

std::size_t start = token_stream.cursor();

CHECK(Token_namespace);

NameAST *name = 0;

if (!parseName(name))

{

reportError(("Namespace name expected"));

return false;

}

ADVANCE(';', ";");

UsingDirectiveAST *ast = CreateNode<UsingDirectiveAST>(_M_pool);

ast->name = name;

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{

std::size_t start = token_stream.cursor();

CHECK(Token_operator);

OperatorFunctionIdAST *ast = CreateNode<OperatorFunctionIdAST>(_M_pool);

if (!parseOperator(ast->op))

{

ast->op = 0;

// parse cast operator

const ListNode<std::size_t> *cv = 0;

parseCvQualify(cv);

if (!parseSimpleTypeSpecifier(ast->type_specifier))

{

syntaxError();

return false;

}

parseCvQualify(cv);

ast->type_specifier->cv = cv;

PtrOperatorAST *ptr_op = 0;

while (parsePtrOperator(ptr_op))

ast->ptr_ops = snoc(ast->ptr_ops, ptr_op, _M_pool);

}

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

bool reportError)

{

TemplateArgumentAST *templArg = 0;

if (!parseTemplateArgument(templArg))

return false;

node = snoc(node, templArg, _M_pool);

while (token_stream.lookAhead() == ',')

{

nextToken();

if (!parseTemplateArgument(templArg))

{

if (reportError)

{

syntaxError();

break;

}

node = 0;

return false;

}

node = snoc(node, templArg, _M_pool);

}

return true;

{

std::size_t start = token_stream.cursor();

CHECK(Token_typedef);

TypeSpecifierAST *spec = 0;

if (!parseTypeSpecifierOrClassSpec(spec))

{

reportError(("Need a type specifier to declare"));

return false;

}

const ListNode<InitDeclaratorAST*> *declarators = 0;

if (!parseInitDeclaratorList(declarators))

{

//reportError(("Need an identifier to declare"));

//return false;

}

ADVANCE(';', ";");

TypedefAST *ast = CreateNode<TypedefAST>(_M_pool);

ast->type_specifier = spec;

ast->init_declarators = declarators;

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{

std::size_t start = token_stream.cursor();

ADVANCE(Token_asm, "asm");

const ListNode<std::size_t> *cv = 0;

parseCvQualify(cv);

#if defined(__GNUC__)

#pragma GCC warning "implement me"

#endif

skip('(', ')');

nextToken();

ADVANCE(';', ";");

AsmDefinitionAST *ast = CreateNode<AsmDefinitionAST>(_M_pool);

ast->cv = cv;

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{

std::size_t start = token_stream.cursor();

std::size_t exported = 0;

if (token_stream.lookAhead() == Token_export)

{

exported = token_stream.cursor();

nextToken();

}

CHECK(Token_template);

const ListNode<TemplateParameterAST*> *params = 0;

if (token_stream.lookAhead() == '<')

{

nextToken();

parseTemplateParameterList(params);

resolveRightShift();

ADVANCE('>', ">");

}

DeclarationAST *declaration = 0;

if (!parseDeclaration(declaration))

{

reportError(("expected a declaration"));

}

TemplateDeclarationAST *ast = CreateNode<TemplateDeclarationAST>(_M_pool);

ast->exported = exported;

ast->template_parameters = params;

ast->declaration = declaration;

UPDATE_POS(ast, start, token_stream.cursor());

node = ast;

return true;

{