/****************************************************************************

**

** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Script Generator project on Qt Labs.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights. These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

// c++ support

#include "parser.h"

#include "tokens.h"

#include "lexer.h"

#include "control.h"

#include <cstdlib>

#include <iostream>

#define ADVANCE(tk, descr) \

{ \

if (token_stream.lookAhead() != tk) { \

tokenRequiredError(tk); \

return false; \

} \

token_stream.nextToken(); \

}

#define ADVANCE_NR(tk, descr) \

do { \

if (token_stream.lookAhead() != tk) { \

tokenRequiredError(tk); \

} \

else \

token_stream.nextToken(); \

} while (0)

#define CHECK(tk) \

do { \

if (token_stream.lookAhead() != tk) { \

return false; \

} \

token_stream.nextToken(); \

} while (0)

#define UPDATE_POS(_node, start, end) \

do { \

(_node)->start_token = start; \

(_node)->end_token = end; \

} while (0)

Parser::Parser(Control *c)

: _M_location(token_stream, location_table, line_table),

control(c),

lexer(_M_location, control)

{

_M_block_errors = false;

}

Parser::~Parser()

{

}

void Parser::advance()

{

token_stream.nextToken();

}

TranslationUnitAST *Parser::parse(const char *contents,

std::size_t size, pool *p)

{

_M_block_errors = false;

_M_pool = p;

lexer.tokenize(contents, size);

token_stream.nextToken(); // skip the first token

Lexer *oldLexer = control->changeLexer (&lexer);

Parser *oldParser = control->changeParser (this);

TranslationUnitAST *ast = 0;

parseTranslationUnit(ast);

control->changeLexer (oldLexer);

control->changeParser (oldParser);

return ast;

}

bool Parser::parseWinDeclSpec(WinDeclSpecAST *&node)

{

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

token_stream.nextToken();

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

return false;

token_stream.nextToken();

if (token_stream.lookAhead() != Token_identifier)

return false;

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

token_stream.nextToken();

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

return false;

token_stream.nextToken();

node = CreateNode<WinDeclSpecAST>(_M_pool);

node->specifier = specifier;

node->modifier = modifier;

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

return true;

}

void Parser::tokenRequiredError(int token)

{

QString err;

err += "expected token ";

err += "``";

err += token_name(token);

err += "'' found ``";

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

err += "''";

reportError(err);

}

void Parser::syntaxError()

{

QString err;

err += "unexpected token ";

err += "``";

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

err += "''";

reportError(err);

}

void Parser::reportError(const QString& msg)

{

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

}

}

bool Parser::skipUntil(int token)

{

while (token_stream.lookAhead())

{

if (token_stream.lookAhead() == token)

return true;

token_stream.nextToken();

}

return false;

}

bool Parser::skipUntilDeclaration()

{

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_volatile: // cv

case Token_public:

case Token_protected:

case Token_private:

case Token_signals: // Qt

case Token_slots: // Qt

return true;

default:

token_stream.nextToken();

}

}

return false;

}

bool Parser::skipUntilStatement()

{

while (token_stream.lookAhead())

{

switch(token_stream.lookAhead())

{

case ';':

case '{':

case '}':

case Token_const:

case Token_volatile:

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:

token_stream.nextToken();

}

}

return false;

}

bool Parser::skip(int l, int r)

{

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;

token_stream.nextToken();

}

return false;

}

bool Parser::parseName(NameAST *&node, bool acceptTemplateId)

{

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

WinDeclSpecAST *winDeclSpec = 0;

parseWinDeclSpec(winDeclSpec);

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

if (token_stream.lookAhead() == Token_scope)

{

ast->global = true;

token_stream.nextToken();

}

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

while (true)

{

UnqualifiedNameAST *n = 0;

if (!parseUnqualifiedName(n))

return false;

if (token_stream.lookAhead() == Token_scope)

{

token_stream.nextToken();

ast->qualified_names

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

if (token_stream.lookAhead() == Token_template)

{

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

token_stream.nextToken();

}

}

else

{

Q_ASSERT(n != 0);

if (!acceptTemplateId)

{

token_stream.rewind((int) n->start_token);

parseUnqualifiedName(n, false);

}

ast->unqualified_name = n;

break;

}

}

if (idx == token_stream.cursor())

return false;

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

node = ast;

return true;

}

bool Parser::parseTranslationUnit(TranslationUnitAST *&node)

{

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

token_stream.nextToken();

}

skipUntilDeclaration();

}

}

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

node = ast;

return true;

}

bool Parser::parseDeclaration(DeclarationAST *&node)

{

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

switch(token_stream.lookAhead())

{

case ';':

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

default:

{

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

parseCvQualify(cv);

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

parseStorageClassSpecifier(storageSpec);

parseCvQualify(cv);

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

token_stream.rewind((int) start);

return parseDeclarationInternal(node);

}

bool Parser::parseLinkageSpecification(DeclarationAST *&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();

token_stream.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;

}

bool Parser::parseLinkageBody(LinkageBodyAST *&node)

{

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

token_stream.nextToken();

}

skipUntilDeclaration();

}

}

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

reportError(("} expected"));

else

token_stream.nextToken();

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

node = ast;

return true;

}

bool Parser::parseNamespace(DeclarationAST *&node)

{

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

token_stream.nextToken();

}

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

{

// namespace alias

token_stream.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;

}

bool Parser::parseUsing(DeclarationAST *&node)

{

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

CHECK(Token_using);

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

token_stream.nextToken();

}

if (!parseName(ast->name))

return false;

ADVANCE(';', ";");

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

node = ast;

return true;

}

bool Parser::parseUsingDirective(DeclarationAST *&node)

{

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;

}

bool Parser::parseOperatorFunctionId(OperatorFunctionIdAST *&node)

{

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 Parser::parseTemplateArgumentList(const ListNode<TemplateArgumentAST*> *&node,

bool reportError)

{

TemplateArgumentAST *templArg = 0;

if (!parseTemplateArgument(templArg))

return false;

node = snoc(node, templArg, _M_pool);

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

{

token_stream.nextToken();

if (!parseTemplateArgument(templArg))

{

if (reportError)

{

syntaxError();

break;

}

node = 0;

return false;

}

node = snoc(node, templArg, _M_pool);

}

return true;

}

bool Parser::parseTypedef(DeclarationAST *&node)

{

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;

}

bool Parser::parseAsmDefinition(DeclarationAST *&node)

{

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

ADVANCE(Token_asm, "asm");

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

parseCvQualify(cv);

#if defined(__GNUC__)

#warning "implement me"

#endif

skip('(', ')');

token_stream.nextToken();

ADVANCE(';', ";");

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

ast->cv = cv;

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

node = ast;

return true;

}

bool Parser::parseTemplateDeclaration(DeclarationAST *&node)

{

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

std::size_t exported = 0;

if (token_stream.lookAhead() == Token_export)

{

exported = token_stream.cursor();

token_stream.nextToken();

}

CHECK(Token_template);

const ListNode<TemplateParameterAST*> *params = 0;

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

{

token_stream.nextToken();

parseTemplateParameterList(params);

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;

}

bool Parser::parseOperator(OperatorAST *&node)

{

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

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

switch(token_stream.lookAhead())

{

case Token_new:

case Token_delete:

{

ast->op = token_stream.cursor();

token_stream.nextToken();

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

&& token_stream.lookAhead(1) == ']')

{

ast->open = token_stream.cursor();

token_stream.nextToken();

ast->close = token_stream.cursor();

token_stream.nextToken();

}

}

break;

case '+':

case '-':

case '*':

case '/':

case '%':

case '^':

case '&':

case '|':

case '~':

case '!':

case '=':

case '<':

case '>':

case ',':

case Token_assign:

case Token_shift:

case Token_eq:

case Token_not_eq:

case Token_leq:

case Token_geq:

case Token_and:

case Token_or:

case Token_incr:

case Token_decr:

case Token_ptrmem:

case Token_arrow:

ast->op = token_stream.cursor();

token_stream.nextToken();

break;

default:

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

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

{

ast->op = ast->open = token_stream.cursor();

token_stream.nextToken();

ast->close = token_stream.cursor();

token_stream.nextToken();

}

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

&& token_stream.lookAhead(1) == ']')

{

ast->op = ast->open = token_stream.cursor();

token_stream.nextToken();

ast->close = token_stream.cursor();

token_stream.nextToken();

}

else

{

return false;

}

}

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

node = ast;

return true;

}

bool Parser::parseCvQualify(const ListNode<std::size_t> *&node)

{

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

int tk;

while (0 != (tk = token_stream.lookAhead())

&& (tk == Token_const || tk == Token_volatile))

{

node = snoc(node, token_stream.cursor(), _M_pool);

token_stream.nextToken();

}

return start != token_stream.cursor();

}

bool Parser::parseSimpleTypeSpecifier(TypeSpecifierAST *&node,

bool onlyIntegral)

{

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

bool isIntegral = false;

bool done = false;

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

while (!done)

{

switch(token_stream.lookAhead())

{

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:

integrals = snoc(integrals, token_stream.cursor(), _M_pool);

isIntegral = true;

token_stream.nextToken();

break;

default:

done = true;

}

}

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

if (isIntegral)

{

ast->integrals = integrals;

}

else if (token_stream.lookAhead() == Token___typeof)

{

ast->type_of = token_stream.cursor();

token_stream.nextToken();

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

{