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

**

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

** All rights reserved.

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

**

** This file is part of the Qt Mobility Components.

**

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

**

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

// Copyright (c) 2008 Roberto Raggi <roberto.raggi@gmail.com>

//

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to deal

// in the Software without restriction, including without limitation the rights

// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

// copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

#include "Parser.h"

#include "Token.h"

#include "Lexer.h"

#include "Control.h"

#include "AST.h"

#include "Literals.h"

#include "ObjectiveCTypeQualifiers.h"

#include <cstdio> // for putchar

#ifdef ICHECK_BUILD

#  include <QString>

#endif

#define CPLUSPLUS_NO_DEBUG_RULE

#define MAX_EXPRESSION_DEPTH 100

using namespace CPlusPlus;

namespace {

class DebugRule {

    const char *name;

    static int depth;

public:

    DebugRule(const char *name)

        : name(name)

    {

        for (int i = 0; i < depth; ++i)

            putchar(' ');

        ++depth;

        printf("%s\n", name);

    }

    ~DebugRule()

    { --depth; }

};

int DebugRule::depth = 0;

inline bool lookAtAssignmentOperator(int tokenKind)

{

    switch (tokenKind) {

    case T_EQUAL:

    case T_AMPER_EQUAL:

    case T_CARET_EQUAL:

    case T_SLASH_EQUAL:

    case T_GREATER_GREATER_EQUAL:

    case T_LESS_LESS_EQUAL:

    case T_MINUS_EQUAL:

    case T_PERCENT_EQUAL:

    case T_PIPE_EQUAL:

    case T_PLUS_EQUAL:

    case T_STAR_EQUAL:

    case T_TILDE_EQUAL:

        return true;

    default:

        return false;

    } // switch

}

namespace Prec {

enum {

    Unknown         = 0,

    Comma           = 1,

    Assignment      = 2,

    Conditional     = 3,

    LogicalOr       = 4,

    LogicalAnd      = 5,

    InclusiveOr     = 6,

    ExclusiveOr     = 7,

    And             = 8,

    Equality        = 9,

    Relational      = 10,

    Shift           = 11,

    Additive        = 12,

    Multiplicative  = 13,

    PointerToMember = 14

};

} // end of namespace Precedece

inline int precedence(int tokenKind, bool templateArguments)

{

    // ### this will/might need some tuning for C++0x

    // (see: [temp.names]p3)

    if (templateArguments && tokenKind == T_GREATER)

        return -1;

    if (lookAtAssignmentOperator(tokenKind))

        return Prec::Assignment;

    switch (tokenKind) {

    case T_COMMA:           return Prec::Comma;

    case T_QUESTION:        return Prec::Conditional;

    case T_PIPE_PIPE:       return Prec::LogicalOr;

    case T_AMPER_AMPER:     return Prec::LogicalAnd;

    case T_PIPE:            return Prec::InclusiveOr;

    case T_CARET:           return Prec::ExclusiveOr;

    case T_AMPER:           return Prec::And;

    case T_EQUAL_EQUAL:

    case T_EXCLAIM_EQUAL:   return Prec::Equality;

    case T_GREATER:

    case T_LESS:

    case T_LESS_EQUAL:

    case T_GREATER_EQUAL:   return Prec::Relational;

    case T_LESS_LESS:

    case T_GREATER_GREATER: return Prec::ExclusiveOr;

    case T_PLUS:

    case T_MINUS:           return Prec::Additive;

    case T_STAR:

    case T_SLASH:

    case T_PERCENT:         return Prec::Multiplicative;

    case T_ARROW_STAR:

    case T_DOT_STAR:        return Prec::PointerToMember;

    default:                return Prec::Unknown;

    }

}

inline bool isBinaryOperator(int tokenKind)

{ return precedence(tokenKind, false) != Prec::Unknown; }

inline bool isRightAssociative(int tokenKind)

{

    const int prec = precedence(tokenKind, false);

    return prec == Prec::Conditional || prec == Prec::Assignment;

}

} // end of anonymous namespace

#ifndef CPLUSPLUS_NO_DEBUG_RULE

#  define DEBUG_THIS_RULE() DebugRule __debug_rule__(__func__)

#else

#  define DEBUG_THIS_RULE() do {} while (0)

#endif

#define PARSE_EXPRESSION_WITH_OPERATOR_PRECEDENCE(node, minPrecedence) { \

    if (LA() == T_THROW) { \

        if (!parseThrowExpression(node)) \

            return false; \

    } else if (!parseCastExpression(node)) \

        return false; \

    \

    parseExpressionWithOperatorPrecedence(node, minPrecedence); \

    return true; \

}

class Parser::Rewind

{

    Parser *_parser;

    MemoryPool::State _state;

public:

    inline Rewind(Parser *parser)

        : _parser(parser) {}

    inline void operator()(unsigned tokenIndex)

    { rewind(tokenIndex); }

    inline void mark()

    { _state = _parser->_pool->state(); }

    inline void rewind(unsigned tokenIndex)

    {

        _parser->rewind(tokenIndex);

        if (_state.isValid())

            _parser->_pool->rewind(_state);

    }

};

Parser::Parser(TranslationUnit *unit)

    : _translationUnit(unit),

      _control(_translationUnit->control()),

      _pool(_translationUnit->memoryPool()),

      _tokenIndex(1),

      _templateArguments(0),

      _qtMocRunEnabled(false),

      _objCEnabled(false),

      _inFunctionBody(false),

      _inObjCImplementationContext(false),

      _expressionDepth(0)

{ }

Parser::~Parser()

{ }

bool Parser::qtMocRunEnabled() const

{ return _qtMocRunEnabled; }

void Parser::setQtMocRunEnabled(bool onoff)

{ _qtMocRunEnabled = onoff; }

bool Parser::objCEnabled() const

{ return _objCEnabled; }

void Parser::setObjCEnabled(bool onoff)

{ _objCEnabled = onoff; }

bool Parser::switchTemplateArguments(bool templateArguments)

{

    bool previousTemplateArguments = _templateArguments;

    _templateArguments = templateArguments;

    return previousTemplateArguments;

}

bool Parser::blockErrors(bool block)

{ return _translationUnit->blockErrors(block); }

bool Parser::skipUntil(int token)

{

    while (int tk = LA()) {

        if (tk == token)

            return true;

        consumeToken();

    }

    return false;

}

void Parser::skipUntilDeclaration()

{

    for (; ; consumeToken()) {

        switch (LA()) {

        case T_EOF_SYMBOL:

        // names

        case T_IDENTIFIER:

        case T_COLON_COLON:

        case T_TILDE:

        case T_OPERATOR:

        // empty declaration

        case T_SEMICOLON:

        // member specification

        case T_USING:

        case T_TEMPLATE:

        case T_PUBLIC:

        case T_PROTECTED:

        case T_PRIVATE:

        case T_Q_SIGNALS:

        case T_Q_SLOTS:

        // declarations

        case T_ENUM:

        case T_NAMESPACE:

        case T_ASM:

        case T_EXPORT:

        case T_AT_CLASS:

        case T_AT_INTERFACE:

        case T_AT_PROTOCOL:

        case T_AT_IMPLEMENTATION:

        case T_AT_END:

            return;

        default:

            if (lookAtBuiltinTypeSpecifier() || lookAtClassKey() ||

                lookAtFunctionSpecifier() || lookAtStorageClassSpecifier())

                return;

        } // switch

    }

}

bool Parser::skipUntilStatement()

{

    while (int tk = LA()) {

        switch (tk) {

            case T_SEMICOLON:

            case T_LBRACE:

            case T_RBRACE:

            case T_CONST:

            case T_VOLATILE:

            case T_IDENTIFIER:

            case T_CASE:

            case T_DEFAULT:

            case T_IF:

            case T_SWITCH:

            case T_WHILE:

            case T_DO:

            case T_FOR:

            case T_BREAK:

            case T_CONTINUE:

            case T_RETURN:

            case T_GOTO:

            case T_TRY:

            case T_CATCH:

            case T_THROW:

            case T_CHAR:

            case T_WCHAR_T:

            case T_BOOL:

            case T_SHORT:

            case T_INT:

            case T_LONG:

            case T_SIGNED:

            case T_UNSIGNED:

            case T_FLOAT:

            case T_DOUBLE:

            case T_VOID:

            case T_CLASS:

            case T_STRUCT:

            case T_UNION:

            case T_ENUM:

            case T_COLON_COLON:

            case T_TEMPLATE:

            case T_USING:

                return true;

            case T_AT_SYNCHRONIZED:

                if (objCEnabled())

                    return true;

            default:

                consumeToken();

        }

    }

    return false;

}

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

{

    int count = 0;

    while (int tk = LA()) {

        if (tk == l)

            ++count;

        else if (tk == r)

            --count;

        else if (l != T_LBRACE && (tk == T_LBRACE ||

                                   tk == T_RBRACE ||

                                   tk == T_SEMICOLON))

            return false;

        if (count == 0)

            return true;

        consumeToken();

    }

    return false;

}

void Parser::match(int kind, unsigned *token)

{

    if (LA() == kind)

        *token = consumeToken();

    else {

        *token = 0;

        _translationUnit->error(_tokenIndex, "expected token `%s' got `%s'",

                                Token::name(kind), tok().spell());

    }

}

bool Parser::parseClassOrNamespaceName(NameAST *&node)

{

    DEBUG_THIS_RULE();

    if (LA() == T_IDENTIFIER) {

        unsigned identifier_token = cursor();

        if (LA(2) == T_LESS && parseTemplateId(node) && LA() == T_COLON_COLON)

            return true;

        rewind(identifier_token);

        if (LA(2) == T_COLON_COLON) {

            SimpleNameAST *ast = new (_pool) SimpleNameAST;

            ast->identifier_token = consumeToken();

            node = ast;

            return true;

        }

    } else if (LA() == T_TEMPLATE) {

        unsigned template_token = consumeToken();

        if (parseTemplateId(node))

            return true;

        rewind(template_token);

    }

    return false;

}

bool Parser::parseTemplateId(NameAST *&node)

{

    DEBUG_THIS_RULE();

    const unsigned start = cursor();

    if (LA() == T_IDENTIFIER && LA(2) == T_LESS) {

        TemplateIdAST *ast = new (_pool) TemplateIdAST;

        ast->identifier_token = consumeToken();

        ast->less_token = consumeToken();

        if (LA() == T_GREATER || parseTemplateArgumentList(

                ast->template_argument_list)) {

            if (LA() == T_GREATER) {

                ast->greater_token = consumeToken();

                node = ast;

                return true;

            }

        }

    }

    rewind(start);

    return false;

}

bool Parser::parseNestedNameSpecifier(NestedNameSpecifierListAST *&node,

                                      bool /*acceptTemplateId*/)

{

    DEBUG_THIS_RULE();

    NestedNameSpecifierListAST **nested_name_specifier = &node;

    NameAST *class_or_namespace_name = 0;

    if (parseClassOrNamespaceName(class_or_namespace_name) && LA() == T_COLON_COLON) {

        unsigned scope_token = consumeToken();

        NestedNameSpecifierAST *name = new (_pool) NestedNameSpecifierAST;

        name->class_or_namespace_name = class_or_namespace_name;

        name->scope_token = scope_token;

        *nested_name_specifier = new (_pool) NestedNameSpecifierListAST(name);

        nested_name_specifier = &(*nested_name_specifier)->next;

        while (parseClassOrNamespaceName(class_or_namespace_name) && LA() == T_COLON_COLON) {

            scope_token = consumeToken();

            name = new (_pool) NestedNameSpecifierAST;

            name->class_or_namespace_name = class_or_namespace_name;

            name->scope_token = scope_token;

            *nested_name_specifier = new (_pool) NestedNameSpecifierListAST(name);

            nested_name_specifier = &(*nested_name_specifier)->next;

        }

        // ### ugly hack

        rewind(scope_token);

        consumeToken();

        return true;

    }

    return false;

}

bool Parser::parseNestedNameSpecifierOpt(NestedNameSpecifierListAST *&name, bool acceptTemplateId)

{

    DEBUG_THIS_RULE();

    unsigned start = cursor();

    if (! parseNestedNameSpecifier(name, acceptTemplateId))

        rewind(start);

    return true;

}

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

{

    DEBUG_THIS_RULE();

    unsigned global_scope_token = 0;

    if (LA() == T_COLON_COLON)

        global_scope_token = consumeToken();

    NestedNameSpecifierListAST *nested_name_specifier = 0;

    parseNestedNameSpecifierOpt(nested_name_specifier,

                                /*acceptTemplateId=*/ true);

    NameAST *unqualified_name = 0;

    if (parseUnqualifiedName(unqualified_name,

                             /*acceptTemplateId=*/ acceptTemplateId || nested_name_specifier != 0)) {

        if (! global_scope_token && ! nested_name_specifier) {

            node = unqualified_name;

            return true;

        }