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

**

** 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 QtDeclarative module of the Qt Toolkit.

**

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

**

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

#include <QtCore/QtDebug>

#include <QtGui/QApplication>

#include <string.h>

#include "private/qdeclarativejsengine_p.h"

#include "private/qdeclarativejslexer_p.h"

#include "private/qdeclarativejsast_p.h"

#include "private/qdeclarativejsnodepool_p.h"

#include "private/qdeclarativejsparser_p.h"

#include <QVarLengthArray>

//

// This file is automatically generated from qmljs.g.

// Changes will be lost.

//

using namespace QDeclarativeJS;

QT_QML_BEGIN_NAMESPACE

void Parser::reallocateStack()

{

    if (! stack_size)

        stack_size = 128;

    else

        stack_size <<= 1;

    sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));

    state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));

    location_stack = reinterpret_cast<AST::SourceLocation*> (qRealloc(location_stack, stack_size * sizeof(AST::SourceLocation)));

}

inline static bool automatic(Engine *driver, int token)

{

    return token == QDeclarativeJSGrammar::T_RBRACE

        || token == 0

        || driver->lexer()->prevTerminator();

}

Parser::Parser(Engine *engine):

    driver(engine),

    tos(0),

    stack_size(0),

    sym_stack(0),

    state_stack(0),

    location_stack(0),

    first_token(0),

    last_token(0)

{

}

Parser::~Parser()

{

    if (stack_size) {

        qFree(sym_stack);

        qFree(state_stack);

        qFree(location_stack);

    }

}

static inline AST::SourceLocation location(Lexer *lexer)

{

    AST::SourceLocation loc;

    loc.offset = lexer->tokenOffset();

    loc.length = lexer->tokenLength();

    loc.startLine = lexer->startLineNo();

    loc.startColumn = lexer->startColumnNo();

    return loc;

}

AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)

{

    QVarLengthArray<NameId *, 4> nameIds;

    QVarLengthArray<AST::SourceLocation, 4> locations;

    AST::ExpressionNode *it = expr;

    while (AST::FieldMemberExpression *m = AST::cast<AST::FieldMemberExpression *>(it)) {

        nameIds.append(m->name);

        locations.append(m->identifierToken);

        it = m->base;

    }

    if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {

        AST::UiQualifiedId *q = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), idExpr->name);

        q->identifierToken = idExpr->identifierToken;

        AST::UiQualifiedId *currentId = q;

        for (int i = nameIds.size() - 1; i != -1; --i) {

            currentId = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), currentId, nameIds[i]);

            currentId->identifierToken = locations[i];

        }

        return currentId->finish();

    }

    return 0;

}

bool Parser::parse(int startToken)

{

    Lexer *lexer = driver->lexer();

    bool hadErrors = false;

    int yytoken = -1;

    int action = 0;

    token_buffer[0].token = startToken;

    first_token = &token_buffer[0];

    last_token = &token_buffer[1];

    tos = -1;

    program = 0;

    do {

        if (++tos == stack_size)

            reallocateStack();

        state_stack[tos] = action;

    _Lcheck_token:

        if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {

            yyprevlloc = yylloc;

            if (first_token == last_token) {

                yytoken = lexer->lex();

                yylval = lexer->dval();

                yylloc = location(lexer);

            } else {

                yytoken = first_token->token;

                yylval = first_token->dval;

                yylloc = first_token->loc;

                ++first_token;

            }

        }

        action = t_action(action, yytoken);

        if (action > 0) {

            if (action != ACCEPT_STATE) {

                yytoken = -1;

                sym(1).dval = yylval;

                loc(1) = yylloc;

            } else {

              --tos;

              return ! hadErrors;

            }

        } else if (action < 0) {

          const int r = -action - 1;

          tos -= rhs[r];

          switch (r) {

case 0: {

  sym(1).Node = sym(2).Node;

  program = sym(1).Node;

} break;

case 1: {

  sym(1).Node = sym(2).Node;

  program = sym(1).Node;

} break;

case 2: {

  sym(1).Node = sym(2).Node;

  program = sym(1).Node;

} break;

case 3: {

  sym(1).Node = sym(2).Node;

  program = sym(1).Node;

} break;

case 4: {

  sym(1).Node = sym(2).Node;

  program = sym(1).Node;

} break;

case 5: {

  sym(1).Node = sym(2).Node;

  program = sym(1).Node;

} break;

case 6: {

  sym(1).UiProgram = makeAstNode<AST::UiProgram> (driver->nodePool(), sym(1).UiImportList,

        sym(2).UiObjectMemberList->finish());

} break;

case 8: {

    sym(1).Node = sym(1).UiImportList->finish();

} break;

case 9: {

    sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(), sym(1).UiImport);

} break;

case 10: {

    sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(),

        sym(1).UiImportList, sym(2).UiImport);

} break;

case 13: {

    sym(1).UiImport->semicolonToken = loc(2);

} break;

case 15: {

    sym(1).UiImport->versionToken = loc(2);

    sym(1).UiImport->semicolonToken = loc(3);

} break;

case 17: {

    sym(1).UiImport->versionToken = loc(2);

    sym(1).UiImport->asToken = loc(3);

    sym(1).UiImport->importIdToken = loc(4);

    sym(1).UiImport->importId = sym(4).sval;

    sym(1).UiImport->semicolonToken = loc(5);

} break;

case 19: {

    sym(1).UiImport->asToken = loc(2);

    sym(1).UiImport->importIdToken = loc(3);

    sym(1).UiImport->importId = sym(3).sval;

    sym(1).UiImport->semicolonToken = loc(4);

} break;

case 20: {

    AST::UiImport *node = 0;

    if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {

        node = makeAstNode<AST::UiImport>(driver->nodePool(), importIdLiteral->value);

        node->fileNameToken = loc(2);

    } else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {

        node = makeAstNode<AST::UiImport>(driver->nodePool(), qualifiedId);

        node->fileNameToken = loc(2);

    }

    sym(1).Node = node;

    if (node) {

        node->importToken = loc(1);

    } else {

       diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),

         QLatin1String("Expected a qualified name id or a string literal")));

        return false; // ### remove me

    }

} break;

case 21: {

    sym(1).Node = 0;

} break;

case 22: {

    sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);

} break;

case 23: {

    sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);

} break;

case 24: {

    AST::UiObjectMemberList *node = makeAstNode<AST:: UiObjectMemberList> (driver->nodePool(),

        sym(1).UiObjectMemberList, sym(2).UiObjectMember);

    sym(1).Node = node;

} break;

case 25: {

    sym(1).Node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(), sym(1).UiObjectMember);

} break;

case 26: {

    AST::UiArrayMemberList *node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(),

        sym(1).UiArrayMemberList, sym(3).UiObjectMember);

    node->commaToken = loc(2);

    sym(1).Node = node;

} break;

case 27: {

    AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), (AST::UiObjectMemberList*)0);

    node->lbraceToken = loc(1);

    node->rbraceToken = loc(2);

    sym(1).Node = node;

}   break;

case 28: {

    AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), sym(2).UiObjectMemberList->finish());

    node->lbraceToken = loc(1);

    node->rbraceToken = loc(3);

    sym(1).Node = node;

}   break;

case 29: {

    AST::UiObjectDefinition *node = makeAstNode<AST::UiObjectDefinition> (driver->nodePool(), sym(1).UiQualifiedId,

        sym(2).UiObjectInitializer);

    sym(1).Node = node;

}   break;

case 31: {

    AST::UiArrayBinding *node = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),

        sym(1).UiQualifiedId, sym(4).UiArrayMemberList->finish());

    node->colonToken = loc(2);

    node->lbracketToken = loc(3);

    node->rbracketToken = loc(5);

    sym(1).Node = node;

}   break;

case 32: {

    AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),

      sym(1).UiQualifiedId, sym(3).UiQualifiedId, sym(4).UiObjectInitializer);

    node->colonToken = loc(2);

    sym(1).Node = node;

} break;

case 33: {

    AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),

      sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer);

    node->colonToken = loc(2);

    node->hasOnToken = true;

    sym(1).Node = node;

} break;

case 34:case 35:case 36:case 37:

{

    AST::UiScriptBinding *node = makeAstNode<AST::UiScriptBinding> (driver->nodePool(),

        sym(1).UiQualifiedId, sym(3).Statement);

    node->colonToken = loc(2);

    sym(1).Node = node;

}   break;

case 38:

case 39: {

    sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());

    break;

}

case 41: {

  sym(1).Node = 0;

} break;

case 42: {

  sym(1).Node = sym(1).UiParameterList->finish ();

} break;

case 43: {

  AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).sval, sym(2).sval);

  node->identifierToken = loc(2);

  sym(1).Node = node;

} break;

case 44: {

  AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).UiParameterList, sym(3).sval, sym(4).sval);

  node->commaToken = loc(2);

  node->identifierToken = loc(4);

  sym(1).Node = node;

} break;

case 46: {

    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);

    node->type = AST::UiPublicMember::Signal;

    node->propertyToken = loc(1);

    node->typeToken = loc(2);

    node->identifierToken = loc(2);

    node->parameters = sym(4).UiParameterList;

    node->semicolonToken = loc(6);

    sym(1).Node = node;

}   break;

case 48: {

    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);

    node->type = AST::UiPublicMember::Signal;

    node->propertyToken = loc(1);

    node->typeToken = loc(2);

    node->identifierToken = loc(2);

    node->semicolonToken = loc(3);

    sym(1).Node = node;

}   break;

case 50: {

    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);

    node->typeModifier = sym(2).sval;

    node->propertyToken = loc(1);

    node->typeModifierToken = loc(2);

    node->typeToken = loc(4);

    node->identifierToken = loc(6);

    node->semicolonToken = loc(7);

    sym(1).Node = node;

}   break;

case 52: {

    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);

    node->propertyToken = loc(1);

    node->typeToken = loc(2);

    node->identifierToken = loc(3);

    node->semicolonToken = loc(4);

    sym(1).Node = node;

}   break;

case 54: {

    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval);

    node->isDefaultMember = true;

    node->defaultToken = loc(1);

    node->propertyToken = loc(2);

    node->typeToken = loc(3);

    node->identifierToken = loc(4);

    node->semicolonToken = loc(5);

    sym(1).Node = node;

}   break;

case 56: {

    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval,

        sym(5).Expression);

    node->propertyToken = loc(1);

    node->typeToken = loc(2);

    node->identifierToken = loc(3);

    node->colonToken = loc(4);

    node->semicolonToken = loc(6);

    sym(1).Node = node;

}   break;

case 58: {

    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,

        sym(6).Expression);

    node->isReadonlyMember = true;

    node->readonlyToken = loc(1);

    node->propertyToken = loc(2);

    node->typeToken = loc(3);

    node->identifierToken = loc(4);

    node->colonToken = loc(5);

    node->semicolonToken = loc(7);

    sym(1).Node = node;

}   break;

case 60: {

    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,

        sym(6).Expression);

    node->isDefaultMember = true;

    node->defaultToken = loc(1);

    node->propertyToken = loc(2);

    node->typeToken = loc(3);

    node->identifierToken = loc(4);

    node->colonToken = loc(5);

    node->semicolonToken = loc(7);

    sym(1).Node = node;

}   break;

case 61: {

    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);

    node->typeModifier = sym(2).sval;

    node->propertyToken = loc(1);

    node->typeModifierToken = loc(2);

    node->typeToken = loc(4);

    node->identifierToken = loc(6);

    node->semicolonToken = loc(7); // insert a fake ';' before ':'

    AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(6).sval);

    propertyName->identifierToken = loc(6);

    propertyName->next = 0;

    AST::UiArrayBinding *binding = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),

        propertyName, sym(9).UiArrayMemberList->finish());

    binding->colonToken = loc(7);

    binding->lbracketToken = loc(8);

    binding->rbracketToken = loc(10);

    node->binding = binding;

    sym(1).Node = node;

}   break;

case 62: {

    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);

    node->propertyToken = loc(1);

    node->typeToken = loc(2);

    node->identifierToken = loc(3);

    node->semicolonToken = loc(4); // insert a fake ';' before ':'

    AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(3).sval);

    propertyName->identifierToken = loc(3);

    propertyName->next = 0;

    AST::UiObjectBinding *binding = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),

      propertyName, sym(5).UiQualifiedId, sym(6).UiObjectInitializer);

    binding->colonToken = loc(4);

    node->binding = binding;