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

**

** 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>

#include <vector>

#if defined(_MSC_VER) || defined(__GNUC__)

#include <sstream>

std::string _joinLocation(const char* name, int line)

{

std::stringstream ss;

ss << name << ":" << line;

return ss.str();

}

#define PARSER_METHOD_NAME _joinLocation(__FUNCTION__, __LINE__).c_str()

#else

#define PARSER_METHOD_NAME ""

#endif

#define SYNTAX_ERROR() syntaxError(PARSER_METHOD_NAME)

#define ADVANCE(tk, descr) \

{ \

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

tokenRequiredError(tk, PARSER_METHOD_NAME); \

return false; \

} \

nextToken(); \

}

#define ADVANCE_NR(tk, descr) \

do { \

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

tokenRequiredError(tk, PARSER_METHOD_NAME); \

} else \

nextToken(); \

} while (0)

#define CHECK(tk) \

do { \

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

return false; \

} \

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

{

token_stream.nextToken();

keepTrackDebug();

}

void Parser::rewind(std::size_t pos)

{

token_stream.rewind(pos);

keepTrackDebug();

}

TranslationUnitAST* Parser::parse(const char* contents, std::size_t size, pool* p)

{

_M_block_errors = false;

_M_pool = p;

lexer.tokenize(contents, size);

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

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;

}

void Parser::tokenRequiredError(int token, const char* functionName)

{

QString err;

err += "expected token ";

err += "``";

err += token_name(token);

err += "'' found ``";

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

err += "''";

reportError(err, functionName);

}

void Parser::syntaxError(const char* functionName)

{

QString err;

err += "unexpected token ";

err += "``";

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

err += "''";

reportError(err, functionName);

}

void Parser::reportError(const QString& msg, const char* functionName)

{

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

if (functionName && *functionName) {

errmsg.setMessage(errmsg.message() + " in " + functionName);

}

control->reportError(errmsg);

}

}

void Parser::keepTrackDebug()

{

#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

}

bool Parser::skipAlignas()

{

// 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 Parser::skipAttributes()

{

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;

}

bool Parser::skipUntil(int token)

{

while (token_stream.lookAhead()) {

if (token_stream.lookAhead() == token)

return true;

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

}

bool Parser::skipUntilStatement()

{

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;

}

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;

nextToken();

}

return false;

}

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

{

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;

}

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

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 ';':

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

}

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

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

nextToken();

}

skipUntilDeclaration();

}

}

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

reportError(("} expected"));

else

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

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;

}

bool Parser::parseUsing(DeclarationAST*& node)

{

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;

}

bool Parser::parseUsingTypedef(DeclarationAST*& node)

{

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;

}

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

SYNTAX_ERROR();

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

nextToken();

if (!parseTemplateArgument(templArg)) {

if (reportError) {

SYNTAX_ERROR();

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

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

}

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

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;

}

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

nextToken();

if (token_stream.lookAhead() == '[' && token_stream.lookAhead(1) == ']') {

ast->open = token_stream.cursor();

nextToken();

ast->close = token_stream.cursor();

nextToken();

}

} break;

case '+':

case '-':

case '*':

case '/':

case '%':

case '^':

case '&':

case '|':

case '~':

case '!':

case '=':

case '<':

case '>':

case ',':

case Token_assign:

case Token_shift_left:

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

nextToken();

break;

case Token_shift_right:

ast->op = token_stream.cursor();

nextToken();

// skip placeholder

nextToken();

break;

default:

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

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

nextToken();