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

**

** 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('>', ">");