| ---------------------------------------------------------------------------- |
| -- |
| -- Copyright (C) 2011 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-ONLY$ |
| -- GNU Lesser General Public License Usage |
| -- 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. |
| -- |
| -- If you have questions regarding the use of this file, please contact |
| -- Nokia at qt-info@nokia.com. |
| -- $QT_END_LICENSE$ |
| -- |
| ---------------------------------------------------------------------------- |
| |
| %parser QDeclarativeJSGrammar |
| %decl qdeclarativejsparser_p.h |
| %impl qdeclarativejsparser.cpp |
| %expect 2 |
| %expect-rr 2 |
| |
| %token T_AND "&" T_AND_AND "&&" T_AND_EQ "&=" |
| %token T_BREAK "break" T_CASE "case" T_CATCH "catch" |
| %token T_COLON ":" T_COMMA ";" T_CONTINUE "continue" |
| %token T_DEFAULT "default" T_DELETE "delete" T_DIVIDE_ "/" |
| %token T_DIVIDE_EQ "/=" T_DO "do" T_DOT "." |
| %token T_ELSE "else" T_EQ "=" T_EQ_EQ "==" |
| %token T_EQ_EQ_EQ "===" T_FINALLY "finally" T_FOR "for" |
| %token T_FUNCTION "function" T_GE ">=" T_GT ">" |
| %token T_GT_GT ">>" T_GT_GT_EQ ">>=" T_GT_GT_GT ">>>" |
| %token T_GT_GT_GT_EQ ">>>=" T_IDENTIFIER "identifier" T_IF "if" |
| %token T_IN "in" T_INSTANCEOF "instanceof" T_LBRACE "{" |
| %token T_LBRACKET "[" T_LE "<=" T_LPAREN "(" |
| %token T_LT "<" T_LT_LT "<<" T_LT_LT_EQ "<<=" |
| %token T_MINUS "-" T_MINUS_EQ "-=" T_MINUS_MINUS "--" |
| %token T_NEW "new" T_NOT "!" T_NOT_EQ "!=" |
| %token T_NOT_EQ_EQ "!==" T_NUMERIC_LITERAL "numeric literal" T_OR "|" |
| %token T_OR_EQ "|=" T_OR_OR "||" T_PLUS "+" |
| %token T_PLUS_EQ "+=" T_PLUS_PLUS "++" T_QUESTION "?" |
| %token T_RBRACE "}" T_RBRACKET "]" T_REMAINDER "%" |
| %token T_REMAINDER_EQ "%=" T_RETURN "return" T_RPAREN ")" |
| %token T_SEMICOLON ";" T_AUTOMATIC_SEMICOLON T_STAR "*" |
| %token T_STAR_EQ "*=" T_STRING_LITERAL "string literal" |
| %token T_PROPERTY "property" T_SIGNAL "signal" T_READONLY "readonly" |
| %token T_SWITCH "switch" T_THIS "this" T_THROW "throw" |
| %token T_TILDE "~" T_TRY "try" T_TYPEOF "typeof" |
| %token T_VAR "var" T_VOID "void" T_WHILE "while" |
| %token T_WITH "with" T_XOR "^" T_XOR_EQ "^=" |
| %token T_NULL "null" T_TRUE "true" T_FALSE "false" |
| %token T_CONST "const" |
| %token T_DEBUGGER "debugger" |
| %token T_RESERVED_WORD "reserved word" |
| %token T_MULTILINE_STRING_LITERAL "multiline string literal" |
| %token T_COMMENT "comment" |
| |
| --- context keywords. |
| %token T_PUBLIC "public" |
| %token T_IMPORT "import" |
| %token T_AS "as" |
| %token T_ON "on" |
| |
| --- feed tokens |
| %token T_FEED_UI_PROGRAM |
| %token T_FEED_UI_OBJECT_MEMBER |
| %token T_FEED_JS_STATEMENT |
| %token T_FEED_JS_EXPRESSION |
| %token T_FEED_JS_SOURCE_ELEMENT |
| %token T_FEED_JS_PROGRAM |
| |
| %nonassoc SHIFT_THERE |
| %nonassoc T_IDENTIFIER T_COLON T_SIGNAL T_PROPERTY T_READONLY |
| %nonassoc REDUCE_HERE |
| |
| %start TopLevel |
| |
| /./**************************************************************************** |
| ** |
| ** Copyright (C) 2011 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$ |
| ** GNU Lesser General Public License Usage |
| ** 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. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $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" |
| |
| ./ |
| |
| /:/**************************************************************************** |
| ** |
| ** Copyright (C) 2011 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$ |
| ** GNU Lesser General Public License Usage |
| ** 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. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| |
| // |
| // W A R N I N G |
| // ------------- |
| // |
| // This file is not part of the Qt API. It exists purely as an |
| // implementation detail. This header file may change from version to |
| // version without notice, or even be removed. |
| // |
| // We mean it. |
| // |
| |
| // |
| // This file is automatically generated from qmljs.g. |
| // Changes will be lost. |
| // |
| |
| #ifndef QDECLARATIVEJSPARSER_P_H |
| #define QDECLARATIVEJSPARSER_P_H |
| |
| #include "private/qdeclarativejsglobal_p.h" |
| #include "private/qdeclarativejsgrammar_p.h" |
| #include "private/qdeclarativejsast_p.h" |
| #include "private/qdeclarativejsengine_p.h" |
| |
| #include <QtCore/QList> |
| #include <QtCore/QString> |
| |
| QT_QML_BEGIN_NAMESPACE |
| |
| namespace QDeclarativeJS { |
| |
| class Engine; |
| class NameId; |
| |
| class QML_PARSER_EXPORT Parser: protected $table |
| { |
| public: |
| union Value { |
| int ival; |
| double dval; |
| NameId *sval; |
| AST::ArgumentList *ArgumentList; |
| AST::CaseBlock *CaseBlock; |
| AST::CaseClause *CaseClause; |
| AST::CaseClauses *CaseClauses; |
| AST::Catch *Catch; |
| AST::DefaultClause *DefaultClause; |
| AST::ElementList *ElementList; |
| AST::Elision *Elision; |
| AST::ExpressionNode *Expression; |
| AST::Finally *Finally; |
| AST::FormalParameterList *FormalParameterList; |
| AST::FunctionBody *FunctionBody; |
| AST::FunctionDeclaration *FunctionDeclaration; |
| AST::Node *Node; |
| AST::PropertyName *PropertyName; |
| AST::PropertyNameAndValueList *PropertyNameAndValueList; |
| AST::SourceElement *SourceElement; |
| AST::SourceElements *SourceElements; |
| AST::Statement *Statement; |
| AST::StatementList *StatementList; |
| AST::Block *Block; |
| AST::VariableDeclaration *VariableDeclaration; |
| AST::VariableDeclarationList *VariableDeclarationList; |
| |
| AST::UiProgram *UiProgram; |
| AST::UiImportList *UiImportList; |
| AST::UiImport *UiImport; |
| AST::UiParameterList *UiParameterList; |
| AST::UiPublicMember *UiPublicMember; |
| AST::UiObjectDefinition *UiObjectDefinition; |
| AST::UiObjectInitializer *UiObjectInitializer; |
| AST::UiObjectBinding *UiObjectBinding; |
| AST::UiScriptBinding *UiScriptBinding; |
| AST::UiArrayBinding *UiArrayBinding; |
| AST::UiObjectMember *UiObjectMember; |
| AST::UiObjectMemberList *UiObjectMemberList; |
| AST::UiArrayMemberList *UiArrayMemberList; |
| AST::UiQualifiedId *UiQualifiedId; |
| AST::UiSignature *UiSignature; |
| AST::UiFormalList *UiFormalList; |
| AST::UiFormal *UiFormal; |
| }; |
| |
| public: |
| Parser(Engine *engine); |
| ~Parser(); |
| |
| // parse a UI program |
| bool parse() { return parse(T_FEED_UI_PROGRAM); } |
| bool parseStatement() { return parse(T_FEED_JS_STATEMENT); } |
| bool parseExpression() { return parse(T_FEED_JS_EXPRESSION); } |
| bool parseSourceElement() { return parse(T_FEED_JS_SOURCE_ELEMENT); } |
| bool parseUiObjectMember() { return parse(T_FEED_UI_OBJECT_MEMBER); } |
| bool parseProgram() { return parse(T_FEED_JS_PROGRAM); } |
| |
| AST::UiProgram *ast() const |
| { return AST::cast<AST::UiProgram *>(program); } |
| |
| AST::Statement *statement() const |
| { |
| if (! program) |
| return 0; |
| |
| return program->statementCast(); |
| } |
| |
| AST::ExpressionNode *expression() const |
| { |
| if (! program) |
| return 0; |
| |
| return program->expressionCast(); |
| } |
| |
| AST::UiObjectMember *uiObjectMember() const |
| { |
| if (! program) |
| return 0; |
| |
| return program->uiObjectMemberCast(); |
| } |
| |
| AST::Node *rootNode() const |
| { return program; } |
| |
| QList<DiagnosticMessage> diagnosticMessages() const |
| { return diagnostic_messages; } |
| |
| inline DiagnosticMessage diagnosticMessage() const |
| { |
| foreach (const DiagnosticMessage &d, diagnostic_messages) { |
| if (! d.kind == DiagnosticMessage::Warning) |
| return d; |
| } |
| |
| return DiagnosticMessage(); |
| } |
| |
| inline QString errorMessage() const |
| { return diagnosticMessage().message; } |
| |
| inline int errorLineNumber() const |
| { return diagnosticMessage().loc.startLine; } |
| |
| inline int errorColumnNumber() const |
| { return diagnosticMessage().loc.startColumn; } |
| |
| protected: |
| bool parse(int startToken); |
| |
| void reallocateStack(); |
| |
| inline Value &sym(int index) |
| { return sym_stack [tos + index - 1]; } |
| |
| inline AST::SourceLocation &loc(int index) |
| { return location_stack [tos + index - 1]; } |
| |
| AST::UiQualifiedId *reparseAsQualifiedId(AST::ExpressionNode *expr); |
| |
| protected: |
| Engine *driver; |
| int tos; |
| int stack_size; |
| Value *sym_stack; |
| int *state_stack; |
| AST::SourceLocation *location_stack; |
| |
| AST::Node *program; |
| |
| // error recovery |
| enum { TOKEN_BUFFER_SIZE = 3 }; |
| |
| struct SavedToken { |
| int token; |
| double dval; |
| AST::SourceLocation loc; |
| }; |
| |
| double yylval; |
| AST::SourceLocation yylloc; |
| AST::SourceLocation yyprevlloc; |
| |
| SavedToken token_buffer[TOKEN_BUFFER_SIZE]; |
| SavedToken *first_token; |
| SavedToken *last_token; |
| |
| QList<DiagnosticMessage> diagnostic_messages; |
| }; |
| |
| } // end of namespace QDeclarativeJS |
| |
| |
| :/ |
| |
| |
| /. |
| |
| #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 == $table::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) { |
| ./ |
| |
| -------------------------------------------------------------------------------------------------------- |
| -- Declarative UI |
| -------------------------------------------------------------------------------------------------------- |
| |
| TopLevel: T_FEED_UI_PROGRAM UiProgram ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(2).Node; |
| program = sym(1).Node; |
| } break; |
| ./ |
| |
| TopLevel: T_FEED_JS_STATEMENT Statement ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(2).Node; |
| program = sym(1).Node; |
| } break; |
| ./ |
| |
| TopLevel: T_FEED_JS_EXPRESSION Expression ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(2).Node; |
| program = sym(1).Node; |
| } break; |
| ./ |
| |
| TopLevel: T_FEED_JS_SOURCE_ELEMENT SourceElement ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(2).Node; |
| program = sym(1).Node; |
| } break; |
| ./ |
| |
| TopLevel: T_FEED_UI_OBJECT_MEMBER UiObjectMember ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(2).Node; |
| program = sym(1).Node; |
| } break; |
| ./ |
| |
| TopLevel: T_FEED_JS_PROGRAM Program ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(2).Node; |
| program = sym(1).Node; |
| } break; |
| ./ |
| |
| UiProgram: UiImportListOpt UiRootMember ; |
| /. |
| case $rule_number: { |
| sym(1).UiProgram = makeAstNode<AST::UiProgram> (driver->nodePool(), sym(1).UiImportList, |
| sym(2).UiObjectMemberList->finish()); |
| } break; |
| ./ |
| |
| UiImportListOpt: Empty ; |
| UiImportListOpt: UiImportList ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(1).UiImportList->finish(); |
| } break; |
| ./ |
| |
| UiImportList: UiImport ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(), sym(1).UiImport); |
| } break; |
| ./ |
| |
| UiImportList: UiImportList UiImport ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(), |
| sym(1).UiImportList, sym(2).UiImport); |
| } break; |
| ./ |
| |
| ImportId: MemberExpression ; |
| |
| UiImport: UiImportHead T_AUTOMATIC_SEMICOLON ; |
| UiImport: UiImportHead T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| sym(1).UiImport->semicolonToken = loc(2); |
| } break; |
| ./ |
| |
| UiImport: UiImportHead T_NUMERIC_LITERAL T_AUTOMATIC_SEMICOLON ; |
| UiImport: UiImportHead T_NUMERIC_LITERAL T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| sym(1).UiImport->versionToken = loc(2); |
| sym(1).UiImport->semicolonToken = loc(3); |
| } break; |
| ./ |
| |
| UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ; |
| UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiImport: UiImportHead T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ; |
| UiImport: UiImportHead T_AS JsIdentifier T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| |
| UiImportHead: T_IMPORT ImportId ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| Empty: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| UiRootMember: UiObjectDefinition ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember); |
| } break; |
| ./ |
| |
| UiObjectMemberList: UiObjectMember ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember); |
| } break; |
| ./ |
| |
| UiObjectMemberList: UiObjectMemberList UiObjectMember ; |
| /. |
| case $rule_number: { |
| AST::UiObjectMemberList *node = makeAstNode<AST:: UiObjectMemberList> (driver->nodePool(), |
| sym(1).UiObjectMemberList, sym(2).UiObjectMember); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UiArrayMemberList: UiObjectDefinition ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(), sym(1).UiObjectMember); |
| } break; |
| ./ |
| |
| UiArrayMemberList: UiArrayMemberList T_COMMA UiObjectDefinition ; |
| /. |
| case $rule_number: { |
| AST::UiArrayMemberList *node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(), |
| sym(1).UiArrayMemberList, sym(3).UiObjectMember); |
| node->commaToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UiObjectInitializer: T_LBRACE T_RBRACE ; |
| /. |
| case $rule_number: { |
| AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), (AST::UiObjectMemberList*)0); |
| node->lbraceToken = loc(1); |
| node->rbraceToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UiObjectInitializer: T_LBRACE UiObjectMemberList T_RBRACE ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectDefinition: UiQualifiedId UiObjectInitializer ; |
| /. |
| case $rule_number: { |
| AST::UiObjectDefinition *node = makeAstNode<AST::UiObjectDefinition> (driver->nodePool(), sym(1).UiQualifiedId, |
| sym(2).UiObjectInitializer); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UiObjectMember: UiObjectDefinition ; |
| |
| UiObjectMember: UiQualifiedId T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: UiQualifiedId T_COLON UiQualifiedId UiObjectInitializer ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: UiQualifiedId T_ON UiQualifiedId UiObjectInitializer ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: UiQualifiedId T_COLON Block ; |
| /.case $rule_number:./ |
| |
| UiObjectMember: UiQualifiedId T_COLON EmptyStatement ; |
| /.case $rule_number:./ |
| |
| UiObjectMember: UiQualifiedId T_COLON ExpressionStatement ; |
| /.case $rule_number:./ |
| |
| UiObjectMember: UiQualifiedId T_COLON IfStatement ; --- ### do we really want if statement in a binding? |
| /.case $rule_number:./ |
| |
| /. |
| { |
| AST::UiScriptBinding *node = makeAstNode<AST::UiScriptBinding> (driver->nodePool(), |
| sym(1).UiQualifiedId, sym(3).Statement); |
| node->colonToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UiPropertyType: T_VAR ; |
| /. |
| case $rule_number: |
| ./ |
| UiPropertyType: T_RESERVED_WORD ; |
| /. |
| case $rule_number: { |
| sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount()); |
| break; |
| } |
| ./ |
| |
| UiPropertyType: T_IDENTIFIER ; |
| |
| UiParameterListOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| UiParameterListOpt: UiParameterList ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(1).UiParameterList->finish (); |
| } break; |
| ./ |
| |
| UiParameterList: UiPropertyType JsIdentifier ; |
| /. |
| case $rule_number: { |
| AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).sval, sym(2).sval); |
| node->identifierToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UiParameterList: UiParameterList T_COMMA UiPropertyType JsIdentifier ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_AUTOMATIC_SEMICOLON ; |
| UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: T_SIGNAL T_IDENTIFIER T_AUTOMATIC_SEMICOLON ; |
| UiObjectMember: T_SIGNAL T_IDENTIFIER T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_AUTOMATIC_SEMICOLON ; |
| UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ; |
| UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ; |
| UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ; |
| UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ; |
| UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ; |
| UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ; |
| /. |
| case $rule_number: { |
| 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; |
| ./ |
| |
| UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON UiQualifiedId UiObjectInitializer ; |
| /. |
| case $rule_number: { |
| 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; |
| |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UiObjectMember: FunctionDeclaration ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node); |
| } break; |
| ./ |
| |
| UiObjectMember: VariableStatement ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node); |
| } break; |
| ./ |
| |
| JsIdentifier: T_IDENTIFIER; |
| |
| JsIdentifier: T_PROPERTY ; |
| /. |
| case $rule_number: { |
| QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_PROPERTY]); |
| sym(1).sval = driver->intern(s.constData(), s.length()); |
| break; |
| } |
| ./ |
| |
| JsIdentifier: T_SIGNAL ; |
| /. |
| case $rule_number: { |
| QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_SIGNAL]); |
| sym(1).sval = driver->intern(s.constData(), s.length()); |
| break; |
| } |
| ./ |
| |
| JsIdentifier: T_READONLY ; |
| /. |
| case $rule_number: { |
| QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_READONLY]); |
| sym(1).sval = driver->intern(s.constData(), s.length()); |
| break; |
| } |
| ./ |
| |
| JsIdentifier: T_ON ; |
| /. |
| case $rule_number: { |
| QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_ON]); |
| sym(1).sval = driver->intern(s.constData(), s.length()); |
| break; |
| } |
| ./ |
| |
| -------------------------------------------------------------------------------------------------------- |
| -- Expressions |
| -------------------------------------------------------------------------------------------------------- |
| |
| PrimaryExpression: T_THIS ; |
| /. |
| case $rule_number: { |
| AST::ThisExpression *node = makeAstNode<AST::ThisExpression> (driver->nodePool()); |
| node->thisToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: JsIdentifier ; |
| /. |
| case $rule_number: { |
| AST::IdentifierExpression *node = makeAstNode<AST::IdentifierExpression> (driver->nodePool(), sym(1).sval); |
| node->identifierToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_NULL ; |
| /. |
| case $rule_number: { |
| AST::NullExpression *node = makeAstNode<AST::NullExpression> (driver->nodePool()); |
| node->nullToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_TRUE ; |
| /. |
| case $rule_number: { |
| AST::TrueLiteral *node = makeAstNode<AST::TrueLiteral> (driver->nodePool()); |
| node->trueToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_FALSE ; |
| /. |
| case $rule_number: { |
| AST::FalseLiteral *node = makeAstNode<AST::FalseLiteral> (driver->nodePool()); |
| node->falseToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_NUMERIC_LITERAL ; |
| /. |
| case $rule_number: { |
| AST::NumericLiteral *node = makeAstNode<AST::NumericLiteral> (driver->nodePool(), sym(1).dval); |
| node->literalToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_MULTILINE_STRING_LITERAL ; |
| /.case $rule_number:./ |
| |
| PrimaryExpression: T_STRING_LITERAL ; |
| /. |
| case $rule_number: { |
| AST::StringLiteral *node = makeAstNode<AST::StringLiteral> (driver->nodePool(), sym(1).sval); |
| node->literalToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_DIVIDE_ ; |
| /: |
| #define J_SCRIPT_REGEXPLITERAL_RULE1 $rule_number |
| :/ |
| /. |
| case $rule_number: { |
| bool rx = lexer->scanRegExp(Lexer::NoPrefix); |
| if (!rx) { |
| diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage())); |
| return false; // ### remove me |
| } |
| |
| loc(1).length = lexer->tokenLength(); |
| |
| AST::RegExpLiteral *node = makeAstNode<AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags); |
| node->literalToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_DIVIDE_EQ ; |
| /: |
| #define J_SCRIPT_REGEXPLITERAL_RULE2 $rule_number |
| :/ |
| /. |
| case $rule_number: { |
| bool rx = lexer->scanRegExp(Lexer::EqualPrefix); |
| if (!rx) { |
| diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage())); |
| return false; |
| } |
| |
| loc(1).length = lexer->tokenLength(); |
| |
| AST::RegExpLiteral *node = makeAstNode<AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags); |
| node->literalToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_LBRACKET T_RBRACKET ; |
| /. |
| case $rule_number: { |
| AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), (AST::Elision *) 0); |
| node->lbracketToken = loc(1); |
| node->rbracketToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_LBRACKET Elision T_RBRACKET ; |
| /. |
| case $rule_number: { |
| AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).Elision->finish()); |
| node->lbracketToken = loc(1); |
| node->rbracketToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_LBRACKET ElementList T_RBRACKET ; |
| /. |
| case $rule_number: { |
| AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish ()); |
| node->lbracketToken = loc(1); |
| node->rbracketToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_LBRACKET ElementList T_COMMA T_RBRACKET ; |
| /. |
| case $rule_number: { |
| AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (), |
| (AST::Elision *) 0); |
| node->lbracketToken = loc(1); |
| node->commaToken = loc(3); |
| node->rbracketToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_LBRACKET ElementList T_COMMA Elision T_RBRACKET ; |
| /. |
| case $rule_number: { |
| AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (), |
| sym(4).Elision->finish()); |
| node->lbracketToken = loc(1); |
| node->commaToken = loc(3); |
| node->rbracketToken = loc(5); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| -- PrimaryExpression: T_LBRACE T_RBRACE ; |
| -- /. |
| -- case $rule_number: { |
| -- sym(1).Node = makeAstNode<AST::ObjectLiteral> (driver->nodePool()); |
| -- } break; |
| -- ./ |
| |
| PrimaryExpression: T_LBRACE PropertyNameAndValueListOpt T_RBRACE ; |
| /. |
| case $rule_number: { |
| AST::ObjectLiteral *node = 0; |
| if (sym(2).Node) |
| node = makeAstNode<AST::ObjectLiteral> (driver->nodePool(), |
| sym(2).PropertyNameAndValueList->finish ()); |
| else |
| node = makeAstNode<AST::ObjectLiteral> (driver->nodePool()); |
| node->lbraceToken = loc(1); |
| node->rbraceToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_LBRACE PropertyNameAndValueList T_COMMA T_RBRACE ; |
| /. |
| case $rule_number: { |
| AST::ObjectLiteral *node = makeAstNode<AST::ObjectLiteral> (driver->nodePool(), |
| sym(2).PropertyNameAndValueList->finish ()); |
| node->lbraceToken = loc(1); |
| node->rbraceToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PrimaryExpression: T_LPAREN Expression T_RPAREN ; |
| /. |
| case $rule_number: { |
| AST::NestedExpression *node = makeAstNode<AST::NestedExpression>(driver->nodePool(), sym(2).Expression); |
| node->lparenToken = loc(1); |
| node->rparenToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UiQualifiedId: MemberExpression ; |
| /. |
| case $rule_number: { |
| if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) { |
| diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, mem->lbracketToken, |
| QLatin1String("Ignored annotation"))); |
| |
| sym(1).Expression = mem->base; |
| } |
| |
| if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) { |
| sym(1).UiQualifiedId = qualifiedId; |
| } else { |
| sym(1).UiQualifiedId = 0; |
| |
| diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1), |
| QLatin1String("Expected a qualified name id"))); |
| |
| return false; // ### recover |
| } |
| } break; |
| ./ |
| |
| ElementList: AssignmentExpression ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::ElementList> (driver->nodePool(), (AST::Elision *) 0, sym(1).Expression); |
| } break; |
| ./ |
| |
| ElementList: Elision AssignmentExpression ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).Elision->finish(), sym(2).Expression); |
| } break; |
| ./ |
| |
| ElementList: ElementList T_COMMA AssignmentExpression ; |
| /. |
| case $rule_number: { |
| AST::ElementList *node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).ElementList, |
| (AST::Elision *) 0, sym(3).Expression); |
| node->commaToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ElementList: ElementList T_COMMA Elision AssignmentExpression ; |
| /. |
| case $rule_number: { |
| AST::ElementList *node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).ElementList, sym(3).Elision->finish(), |
| sym(4).Expression); |
| node->commaToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| Elision: T_COMMA ; |
| /. |
| case $rule_number: { |
| AST::Elision *node = makeAstNode<AST::Elision> (driver->nodePool()); |
| node->commaToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| Elision: Elision T_COMMA ; |
| /. |
| case $rule_number: { |
| AST::Elision *node = makeAstNode<AST::Elision> (driver->nodePool(), sym(1).Elision); |
| node->commaToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PropertyNameAndValueList: PropertyName T_COLON AssignmentExpression ; |
| /. |
| case $rule_number: { |
| AST::PropertyNameAndValueList *node = makeAstNode<AST::PropertyNameAndValueList> (driver->nodePool(), |
| sym(1).PropertyName, sym(3).Expression); |
| node->colonToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PropertyNameAndValueList: PropertyNameAndValueList T_COMMA PropertyName T_COLON AssignmentExpression ; |
| /. |
| case $rule_number: { |
| AST::PropertyNameAndValueList *node = makeAstNode<AST::PropertyNameAndValueList> (driver->nodePool(), |
| sym(1).PropertyNameAndValueList, sym(3).PropertyName, sym(5).Expression); |
| node->commaToken = loc(2); |
| node->colonToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PropertyName: T_IDENTIFIER %prec SHIFT_THERE ; |
| /. |
| case $rule_number: { |
| AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval); |
| node->propertyNameToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PropertyName: T_SIGNAL ; |
| /.case $rule_number:./ |
| |
| PropertyName: T_PROPERTY ; |
| /. |
| case $rule_number: { |
| AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), driver->intern(lexer->characterBuffer(), lexer->characterCount())); |
| node->propertyNameToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PropertyName: T_STRING_LITERAL ; |
| /. |
| case $rule_number: { |
| AST::StringLiteralPropertyName *node = makeAstNode<AST::StringLiteralPropertyName> (driver->nodePool(), sym(1).sval); |
| node->propertyNameToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PropertyName: T_NUMERIC_LITERAL ; |
| /. |
| case $rule_number: { |
| AST::NumericLiteralPropertyName *node = makeAstNode<AST::NumericLiteralPropertyName> (driver->nodePool(), sym(1).dval); |
| node->propertyNameToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PropertyName: ReservedIdentifier ; |
| /. |
| case $rule_number: { |
| AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval); |
| node->propertyNameToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ReservedIdentifier: T_BREAK ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_CASE ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_CATCH ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_CONTINUE ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_DEFAULT ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_DELETE ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_DO ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_ELSE ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_FALSE ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_FINALLY ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_FOR ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_FUNCTION ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_IF ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_IN ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_INSTANCEOF ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_NEW ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_NULL ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_RETURN ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_SWITCH ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_THIS ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_THROW ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_TRUE ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_TRY ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_TYPEOF ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_VAR ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_VOID ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_WHILE ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_CONST ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_DEBUGGER ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_RESERVED_WORD ; |
| /. |
| case $rule_number: |
| ./ |
| ReservedIdentifier: T_WITH ; |
| /. |
| case $rule_number: |
| { |
| sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount()); |
| } break; |
| ./ |
| |
| PropertyIdentifier: JsIdentifier ; |
| PropertyIdentifier: ReservedIdentifier ; |
| |
| MemberExpression: PrimaryExpression ; |
| MemberExpression: FunctionExpression ; |
| |
| MemberExpression: MemberExpression T_LBRACKET Expression T_RBRACKET ; |
| /. |
| case $rule_number: { |
| AST::ArrayMemberExpression *node = makeAstNode<AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression); |
| node->lbracketToken = loc(2); |
| node->rbracketToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| MemberExpression: MemberExpression T_DOT PropertyIdentifier ; |
| /. |
| case $rule_number: { |
| AST::FieldMemberExpression *node = makeAstNode<AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval); |
| node->dotToken = loc(2); |
| node->identifierToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| MemberExpression: T_NEW MemberExpression T_LPAREN ArgumentListOpt T_RPAREN ; |
| /. |
| case $rule_number: { |
| AST::NewMemberExpression *node = makeAstNode<AST::NewMemberExpression> (driver->nodePool(), sym(2).Expression, sym(4).ArgumentList); |
| node->newToken = loc(1); |
| node->lparenToken = loc(3); |
| node->rparenToken = loc(5); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| NewExpression: MemberExpression ; |
| |
| NewExpression: T_NEW NewExpression ; |
| /. |
| case $rule_number: { |
| AST::NewExpression *node = makeAstNode<AST::NewExpression> (driver->nodePool(), sym(2).Expression); |
| node->newToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| CallExpression: MemberExpression T_LPAREN ArgumentListOpt T_RPAREN ; |
| /. |
| case $rule_number: { |
| AST::CallExpression *node = makeAstNode<AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(3).ArgumentList); |
| node->lparenToken = loc(2); |
| node->rparenToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| CallExpression: CallExpression T_LPAREN ArgumentListOpt T_RPAREN ; |
| /. |
| case $rule_number: { |
| AST::CallExpression *node = makeAstNode<AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(3).ArgumentList); |
| node->lparenToken = loc(2); |
| node->rparenToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| CallExpression: CallExpression T_LBRACKET Expression T_RBRACKET ; |
| /. |
| case $rule_number: { |
| AST::ArrayMemberExpression *node = makeAstNode<AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression); |
| node->lbracketToken = loc(2); |
| node->rbracketToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| CallExpression: CallExpression T_DOT PropertyIdentifier ; |
| /. |
| case $rule_number: { |
| AST::FieldMemberExpression *node = makeAstNode<AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval); |
| node->dotToken = loc(2); |
| node->identifierToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ArgumentListOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| ArgumentListOpt: ArgumentList ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(1).ArgumentList->finish(); |
| } break; |
| ./ |
| |
| ArgumentList: AssignmentExpression ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::ArgumentList> (driver->nodePool(), sym(1).Expression); |
| } break; |
| ./ |
| |
| ArgumentList: ArgumentList T_COMMA AssignmentExpression ; |
| /. |
| case $rule_number: { |
| AST::ArgumentList *node = makeAstNode<AST::ArgumentList> (driver->nodePool(), sym(1).ArgumentList, sym(3).Expression); |
| node->commaToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| LeftHandSideExpression: NewExpression ; |
| LeftHandSideExpression: CallExpression ; |
| PostfixExpression: LeftHandSideExpression ; |
| |
| PostfixExpression: LeftHandSideExpression T_PLUS_PLUS ; |
| /. |
| case $rule_number: { |
| AST::PostIncrementExpression *node = makeAstNode<AST::PostIncrementExpression> (driver->nodePool(), sym(1).Expression); |
| node->incrementToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| PostfixExpression: LeftHandSideExpression T_MINUS_MINUS ; |
| /. |
| case $rule_number: { |
| AST::PostDecrementExpression *node = makeAstNode<AST::PostDecrementExpression> (driver->nodePool(), sym(1).Expression); |
| node->decrementToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UnaryExpression: PostfixExpression ; |
| |
| UnaryExpression: T_DELETE UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::DeleteExpression *node = makeAstNode<AST::DeleteExpression> (driver->nodePool(), sym(2).Expression); |
| node->deleteToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UnaryExpression: T_VOID UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::VoidExpression *node = makeAstNode<AST::VoidExpression> (driver->nodePool(), sym(2).Expression); |
| node->voidToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UnaryExpression: T_TYPEOF UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::TypeOfExpression *node = makeAstNode<AST::TypeOfExpression> (driver->nodePool(), sym(2).Expression); |
| node->typeofToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UnaryExpression: T_PLUS_PLUS UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::PreIncrementExpression *node = makeAstNode<AST::PreIncrementExpression> (driver->nodePool(), sym(2).Expression); |
| node->incrementToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UnaryExpression: T_MINUS_MINUS UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::PreDecrementExpression *node = makeAstNode<AST::PreDecrementExpression> (driver->nodePool(), sym(2).Expression); |
| node->decrementToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UnaryExpression: T_PLUS UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::UnaryPlusExpression *node = makeAstNode<AST::UnaryPlusExpression> (driver->nodePool(), sym(2).Expression); |
| node->plusToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UnaryExpression: T_MINUS UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::UnaryMinusExpression *node = makeAstNode<AST::UnaryMinusExpression> (driver->nodePool(), sym(2).Expression); |
| node->minusToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UnaryExpression: T_TILDE UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::TildeExpression *node = makeAstNode<AST::TildeExpression> (driver->nodePool(), sym(2).Expression); |
| node->tildeToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| UnaryExpression: T_NOT UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::NotExpression *node = makeAstNode<AST::NotExpression> (driver->nodePool(), sym(2).Expression); |
| node->notToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| MultiplicativeExpression: UnaryExpression ; |
| |
| MultiplicativeExpression: MultiplicativeExpression T_STAR UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Mul, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| MultiplicativeExpression: MultiplicativeExpression T_DIVIDE_ UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Div, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| MultiplicativeExpression: MultiplicativeExpression T_REMAINDER UnaryExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Mod, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| AdditiveExpression: MultiplicativeExpression ; |
| |
| AdditiveExpression: AdditiveExpression T_PLUS MultiplicativeExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Add, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| AdditiveExpression: AdditiveExpression T_MINUS MultiplicativeExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Sub, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ShiftExpression: AdditiveExpression ; |
| |
| ShiftExpression: ShiftExpression T_LT_LT AdditiveExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::LShift, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ShiftExpression: ShiftExpression T_GT_GT AdditiveExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::RShift, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ShiftExpression: ShiftExpression T_GT_GT_GT AdditiveExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::URShift, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpression: ShiftExpression ; |
| |
| RelationalExpression: RelationalExpression T_LT ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Lt, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpression: RelationalExpression T_GT ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Gt, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpression: RelationalExpression T_LE ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Le, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpression: RelationalExpression T_GE ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Ge, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpression: RelationalExpression T_INSTANCEOF ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::InstanceOf, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpression: RelationalExpression T_IN ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::In, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpressionNotIn: ShiftExpression ; |
| |
| RelationalExpressionNotIn: RelationalExpressionNotIn T_LT ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Lt, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpressionNotIn: RelationalExpressionNotIn T_GT ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Gt, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpressionNotIn: RelationalExpressionNotIn T_LE ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Le, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpressionNotIn: RelationalExpressionNotIn T_GE ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Ge, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| RelationalExpressionNotIn: RelationalExpressionNotIn T_INSTANCEOF ShiftExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::InstanceOf, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| EqualityExpression: RelationalExpression ; |
| |
| EqualityExpression: EqualityExpression T_EQ_EQ RelationalExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Equal, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| EqualityExpression: EqualityExpression T_NOT_EQ RelationalExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::NotEqual, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| EqualityExpression: EqualityExpression T_EQ_EQ_EQ RelationalExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::StrictEqual, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| EqualityExpression: EqualityExpression T_NOT_EQ_EQ RelationalExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::StrictNotEqual, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| EqualityExpressionNotIn: RelationalExpressionNotIn ; |
| |
| EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ RelationalExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Equal, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ RelationalExpressionNotIn; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::NotEqual, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ_EQ RelationalExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::StrictEqual, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ_EQ RelationalExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::StrictNotEqual, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| BitwiseANDExpression: EqualityExpression ; |
| |
| BitwiseANDExpression: BitwiseANDExpression T_AND EqualityExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::BitAnd, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| BitwiseANDExpressionNotIn: EqualityExpressionNotIn ; |
| |
| BitwiseANDExpressionNotIn: BitwiseANDExpressionNotIn T_AND EqualityExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::BitAnd, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| BitwiseXORExpression: BitwiseANDExpression ; |
| |
| BitwiseXORExpression: BitwiseXORExpression T_XOR BitwiseANDExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::BitXor, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| BitwiseXORExpressionNotIn: BitwiseANDExpressionNotIn ; |
| |
| BitwiseXORExpressionNotIn: BitwiseXORExpressionNotIn T_XOR BitwiseANDExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::BitXor, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| BitwiseORExpression: BitwiseXORExpression ; |
| |
| BitwiseORExpression: BitwiseORExpression T_OR BitwiseXORExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::BitOr, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| BitwiseORExpressionNotIn: BitwiseXORExpressionNotIn ; |
| |
| BitwiseORExpressionNotIn: BitwiseORExpressionNotIn T_OR BitwiseXORExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::BitOr, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| LogicalANDExpression: BitwiseORExpression ; |
| |
| LogicalANDExpression: LogicalANDExpression T_AND_AND BitwiseORExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::And, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| LogicalANDExpressionNotIn: BitwiseORExpressionNotIn ; |
| |
| LogicalANDExpressionNotIn: LogicalANDExpressionNotIn T_AND_AND BitwiseORExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::And, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| LogicalORExpression: LogicalANDExpression ; |
| |
| LogicalORExpression: LogicalORExpression T_OR_OR LogicalANDExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Or, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| LogicalORExpressionNotIn: LogicalANDExpressionNotIn ; |
| |
| LogicalORExpressionNotIn: LogicalORExpressionNotIn T_OR_OR LogicalANDExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| QSOperator::Or, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ConditionalExpression: LogicalORExpression ; |
| |
| ConditionalExpression: LogicalORExpression T_QUESTION AssignmentExpression T_COLON AssignmentExpression ; |
| /. |
| case $rule_number: { |
| AST::ConditionalExpression *node = makeAstNode<AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression, |
| sym(3).Expression, sym(5).Expression); |
| node->questionToken = loc(2); |
| node->colonToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ConditionalExpressionNotIn: LogicalORExpressionNotIn ; |
| |
| ConditionalExpressionNotIn: LogicalORExpressionNotIn T_QUESTION AssignmentExpressionNotIn T_COLON AssignmentExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::ConditionalExpression *node = makeAstNode<AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression, |
| sym(3).Expression, sym(5).Expression); |
| node->questionToken = loc(2); |
| node->colonToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| AssignmentExpression: ConditionalExpression ; |
| |
| AssignmentExpression: LeftHandSideExpression AssignmentOperator AssignmentExpression ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| sym(2).ival, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| AssignmentExpressionNotIn: ConditionalExpressionNotIn ; |
| |
| AssignmentExpressionNotIn: LeftHandSideExpression AssignmentOperator AssignmentExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression, |
| sym(2).ival, sym(3).Expression); |
| node->operatorToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::Assign; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_STAR_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceMul; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_DIVIDE_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceDiv; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_REMAINDER_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceMod; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_PLUS_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceAdd; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_MINUS_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceSub; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_LT_LT_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceLeftShift; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_GT_GT_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceRightShift; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_GT_GT_GT_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceURightShift; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_AND_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceAnd; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_XOR_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceXor; |
| } break; |
| ./ |
| |
| AssignmentOperator: T_OR_EQ ; |
| /. |
| case $rule_number: { |
| sym(1).ival = QSOperator::InplaceOr; |
| } break; |
| ./ |
| |
| Expression: AssignmentExpression ; |
| |
| Expression: Expression T_COMMA AssignmentExpression ; |
| /. |
| case $rule_number: { |
| AST::Expression *node = makeAstNode<AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression); |
| node->commaToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ExpressionOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| ExpressionOpt: Expression ; |
| |
| ExpressionNotIn: AssignmentExpressionNotIn ; |
| |
| ExpressionNotIn: ExpressionNotIn T_COMMA AssignmentExpressionNotIn ; |
| /. |
| case $rule_number: { |
| AST::Expression *node = makeAstNode<AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression); |
| node->commaToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ExpressionNotInOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| ExpressionNotInOpt: ExpressionNotIn ; |
| |
| Statement: Block ; |
| Statement: VariableStatement ; |
| Statement: EmptyStatement ; |
| Statement: ExpressionStatement ; |
| Statement: IfStatement ; |
| Statement: IterationStatement ; |
| Statement: ContinueStatement ; |
| Statement: BreakStatement ; |
| Statement: ReturnStatement ; |
| Statement: WithStatement ; |
| Statement: LabelledStatement ; |
| Statement: SwitchStatement ; |
| Statement: ThrowStatement ; |
| Statement: TryStatement ; |
| Statement: DebuggerStatement ; |
| |
| |
| Block: T_LBRACE StatementListOpt T_RBRACE ; |
| /. |
| case $rule_number: { |
| AST::Block *node = makeAstNode<AST::Block> (driver->nodePool(), sym(2).StatementList); |
| node->lbraceToken = loc(1); |
| node->rbraceToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| StatementList: Statement ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::StatementList> (driver->nodePool(), sym(1).Statement); |
| } break; |
| ./ |
| |
| StatementList: StatementList Statement ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::StatementList> (driver->nodePool(), sym(1).StatementList, sym(2).Statement); |
| } break; |
| ./ |
| |
| StatementListOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| StatementListOpt: StatementList ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(1).StatementList->finish (); |
| } break; |
| ./ |
| |
| VariableStatement: VariableDeclarationKind VariableDeclarationList T_AUTOMATIC_SEMICOLON ; -- automatic semicolon |
| VariableStatement: VariableDeclarationKind VariableDeclarationList T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::VariableStatement *node = makeAstNode<AST::VariableStatement> (driver->nodePool(), |
| sym(2).VariableDeclarationList->finish (/*readOnly=*/sym(1).ival == T_CONST)); |
| node->declarationKindToken = loc(1); |
| node->semicolonToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| VariableDeclarationKind: T_CONST ; |
| /. |
| case $rule_number: { |
| sym(1).ival = T_CONST; |
| } break; |
| ./ |
| |
| VariableDeclarationKind: T_VAR ; |
| /. |
| case $rule_number: { |
| sym(1).ival = T_VAR; |
| } break; |
| ./ |
| |
| VariableDeclarationList: VariableDeclaration ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration); |
| } break; |
| ./ |
| |
| VariableDeclarationList: VariableDeclarationList T_COMMA VariableDeclaration ; |
| /. |
| case $rule_number: { |
| AST::VariableDeclarationList *node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), |
| sym(1).VariableDeclarationList, sym(3).VariableDeclaration); |
| node->commaToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| VariableDeclarationListNotIn: VariableDeclarationNotIn ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration); |
| } break; |
| ./ |
| |
| VariableDeclarationListNotIn: VariableDeclarationListNotIn T_COMMA VariableDeclarationNotIn ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclarationList, sym(3).VariableDeclaration); |
| } break; |
| ./ |
| |
| VariableDeclaration: JsIdentifier InitialiserOpt ; |
| /. |
| case $rule_number: { |
| AST::VariableDeclaration *node = makeAstNode<AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression); |
| node->identifierToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| VariableDeclarationNotIn: JsIdentifier InitialiserNotInOpt ; |
| /. |
| case $rule_number: { |
| AST::VariableDeclaration *node = makeAstNode<AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression); |
| node->identifierToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| Initialiser: T_EQ AssignmentExpression ; |
| /. |
| case $rule_number: { |
| // ### TODO: AST for initializer |
| sym(1) = sym(2); |
| } break; |
| ./ |
| |
| InitialiserOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| InitialiserOpt: Initialiser ; |
| |
| InitialiserNotIn: T_EQ AssignmentExpressionNotIn ; |
| /. |
| case $rule_number: { |
| // ### TODO: AST for initializer |
| sym(1) = sym(2); |
| } break; |
| ./ |
| |
| InitialiserNotInOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| InitialiserNotInOpt: InitialiserNotIn ; |
| |
| EmptyStatement: T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::EmptyStatement *node = makeAstNode<AST::EmptyStatement> (driver->nodePool()); |
| node->semicolonToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ExpressionStatement: Expression T_AUTOMATIC_SEMICOLON ; -- automatic semicolon |
| ExpressionStatement: Expression T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::ExpressionStatement *node = makeAstNode<AST::ExpressionStatement> (driver->nodePool(), sym(1).Expression); |
| node->semicolonToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement T_ELSE Statement ; |
| /. |
| case $rule_number: { |
| AST::IfStatement *node = makeAstNode<AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement, sym(7).Statement); |
| node->ifToken = loc(1); |
| node->lparenToken = loc(2); |
| node->rparenToken = loc(4); |
| node->elseToken = loc(5); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement ; |
| /. |
| case $rule_number: { |
| AST::IfStatement *node = makeAstNode<AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement); |
| node->ifToken = loc(1); |
| node->lparenToken = loc(2); |
| node->rparenToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| |
| IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_AUTOMATIC_SEMICOLON ; -- automatic semicolon |
| IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::DoWhileStatement *node = makeAstNode<AST::DoWhileStatement> (driver->nodePool(), sym(2).Statement, sym(5).Expression); |
| node->doToken = loc(1); |
| node->whileToken = loc(3); |
| node->lparenToken = loc(4); |
| node->rparenToken = loc(6); |
| node->semicolonToken = loc(7); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| IterationStatement: T_WHILE T_LPAREN Expression T_RPAREN Statement ; |
| /. |
| case $rule_number: { |
| AST::WhileStatement *node = makeAstNode<AST::WhileStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement); |
| node->whileToken = loc(1); |
| node->lparenToken = loc(2); |
| node->rparenToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| IterationStatement: T_FOR T_LPAREN ExpressionNotInOpt T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ; |
| /. |
| case $rule_number: { |
| AST::ForStatement *node = makeAstNode<AST::ForStatement> (driver->nodePool(), sym(3).Expression, |
| sym(5).Expression, sym(7).Expression, sym(9).Statement); |
| node->forToken = loc(1); |
| node->lparenToken = loc(2); |
| node->firstSemicolonToken = loc(4); |
| node->secondSemicolonToken = loc(6); |
| node->rparenToken = loc(8); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationListNotIn T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ; |
| /. |
| case $rule_number: { |
| AST::LocalForStatement *node = makeAstNode<AST::LocalForStatement> (driver->nodePool(), |
| sym(4).VariableDeclarationList->finish (/*readOnly=*/false), sym(6).Expression, |
| sym(8).Expression, sym(10).Statement); |
| node->forToken = loc(1); |
| node->lparenToken = loc(2); |
| node->varToken = loc(3); |
| node->firstSemicolonToken = loc(5); |
| node->secondSemicolonToken = loc(7); |
| node->rparenToken = loc(9); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| IterationStatement: T_FOR T_LPAREN LeftHandSideExpression T_IN Expression T_RPAREN Statement ; |
| /. |
| case $rule_number: { |
| AST:: ForEachStatement *node = makeAstNode<AST::ForEachStatement> (driver->nodePool(), sym(3).Expression, |
| sym(5).Expression, sym(7).Statement); |
| node->forToken = loc(1); |
| node->lparenToken = loc(2); |
| node->inToken = loc(4); |
| node->rparenToken = loc(6); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationNotIn T_IN Expression T_RPAREN Statement ; |
| /. |
| case $rule_number: { |
| AST::LocalForEachStatement *node = makeAstNode<AST::LocalForEachStatement> (driver->nodePool(), |
| sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement); |
| node->forToken = loc(1); |
| node->lparenToken = loc(2); |
| node->varToken = loc(3); |
| node->inToken = loc(5); |
| node->rparenToken = loc(7); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ContinueStatement: T_CONTINUE T_AUTOMATIC_SEMICOLON ; -- automatic semicolon |
| ContinueStatement: T_CONTINUE T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::ContinueStatement *node = makeAstNode<AST::ContinueStatement> (driver->nodePool()); |
| node->continueToken = loc(1); |
| node->semicolonToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ContinueStatement: T_CONTINUE JsIdentifier T_AUTOMATIC_SEMICOLON ; -- automatic semicolon |
| ContinueStatement: T_CONTINUE JsIdentifier T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::ContinueStatement *node = makeAstNode<AST::ContinueStatement> (driver->nodePool(), sym(2).sval); |
| node->continueToken = loc(1); |
| node->identifierToken = loc(2); |
| node->semicolonToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| BreakStatement: T_BREAK T_AUTOMATIC_SEMICOLON ; -- automatic semicolon |
| BreakStatement: T_BREAK T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::BreakStatement *node = makeAstNode<AST::BreakStatement> (driver->nodePool()); |
| node->breakToken = loc(1); |
| node->semicolonToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| BreakStatement: T_BREAK JsIdentifier T_AUTOMATIC_SEMICOLON ; -- automatic semicolon |
| BreakStatement: T_BREAK JsIdentifier T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::BreakStatement *node = makeAstNode<AST::BreakStatement> (driver->nodePool(), sym(2).sval); |
| node->breakToken = loc(1); |
| node->identifierToken = loc(2); |
| node->semicolonToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ReturnStatement: T_RETURN ExpressionOpt T_AUTOMATIC_SEMICOLON ; -- automatic semicolon |
| ReturnStatement: T_RETURN ExpressionOpt T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::ReturnStatement *node = makeAstNode<AST::ReturnStatement> (driver->nodePool(), sym(2).Expression); |
| node->returnToken = loc(1); |
| node->semicolonToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| WithStatement: T_WITH T_LPAREN Expression T_RPAREN Statement ; |
| /. |
| case $rule_number: { |
| AST::WithStatement *node = makeAstNode<AST::WithStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement); |
| node->withToken = loc(1); |
| node->lparenToken = loc(2); |
| node->rparenToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| SwitchStatement: T_SWITCH T_LPAREN Expression T_RPAREN CaseBlock ; |
| /. |
| case $rule_number: { |
| AST::SwitchStatement *node = makeAstNode<AST::SwitchStatement> (driver->nodePool(), sym(3).Expression, sym(5).CaseBlock); |
| node->switchToken = loc(1); |
| node->lparenToken = loc(2); |
| node->rparenToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| CaseBlock: T_LBRACE CaseClausesOpt T_RBRACE ; |
| /. |
| case $rule_number: { |
| AST::CaseBlock *node = makeAstNode<AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses); |
| node->lbraceToken = loc(1); |
| node->rbraceToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| CaseBlock: T_LBRACE CaseClausesOpt DefaultClause CaseClausesOpt T_RBRACE ; |
| /. |
| case $rule_number: { |
| AST::CaseBlock *node = makeAstNode<AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses); |
| node->lbraceToken = loc(1); |
| node->rbraceToken = loc(5); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| CaseClauses: CaseClause ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::CaseClauses> (driver->nodePool(), sym(1).CaseClause); |
| } break; |
| ./ |
| |
| CaseClauses: CaseClauses CaseClause ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::CaseClauses> (driver->nodePool(), sym(1).CaseClauses, sym(2).CaseClause); |
| } break; |
| ./ |
| |
| CaseClausesOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| CaseClausesOpt: CaseClauses ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(1).CaseClauses->finish (); |
| } break; |
| ./ |
| |
| CaseClause: T_CASE Expression T_COLON StatementListOpt ; |
| /. |
| case $rule_number: { |
| AST::CaseClause *node = makeAstNode<AST::CaseClause> (driver->nodePool(), sym(2).Expression, sym(4).StatementList); |
| node->caseToken = loc(1); |
| node->colonToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| DefaultClause: T_DEFAULT T_COLON StatementListOpt ; |
| /. |
| case $rule_number: { |
| AST::DefaultClause *node = makeAstNode<AST::DefaultClause> (driver->nodePool(), sym(3).StatementList); |
| node->defaultToken = loc(1); |
| node->colonToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| LabelledStatement: T_SIGNAL T_COLON Statement ; |
| /.case $rule_number:./ |
| |
| LabelledStatement: T_PROPERTY T_COLON Statement ; |
| /. |
| case $rule_number: { |
| AST::LabelledStatement *node = makeAstNode<AST::LabelledStatement> (driver->nodePool(), driver->intern(lexer->characterBuffer(), lexer->characterCount()), sym(3).Statement); |
| node->identifierToken = loc(1); |
| node->colonToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| LabelledStatement: T_IDENTIFIER T_COLON Statement ; |
| /. |
| case $rule_number: { |
| AST::LabelledStatement *node = makeAstNode<AST::LabelledStatement> (driver->nodePool(), sym(1).sval, sym(3).Statement); |
| node->identifierToken = loc(1); |
| node->colonToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| ThrowStatement: T_THROW Expression T_AUTOMATIC_SEMICOLON ; -- automatic semicolon |
| ThrowStatement: T_THROW Expression T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::ThrowStatement *node = makeAstNode<AST::ThrowStatement> (driver->nodePool(), sym(2).Expression); |
| node->throwToken = loc(1); |
| node->semicolonToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| TryStatement: T_TRY Block Catch ; |
| /. |
| case $rule_number: { |
| AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch); |
| node->tryToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| TryStatement: T_TRY Block Finally ; |
| /. |
| case $rule_number: { |
| AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Finally); |
| node->tryToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| TryStatement: T_TRY Block Catch Finally ; |
| /. |
| case $rule_number: { |
| AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch, sym(4).Finally); |
| node->tryToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| Catch: T_CATCH T_LPAREN JsIdentifier T_RPAREN Block ; |
| /. |
| case $rule_number: { |
| AST::Catch *node = makeAstNode<AST::Catch> (driver->nodePool(), sym(3).sval, sym(5).Block); |
| node->catchToken = loc(1); |
| node->lparenToken = loc(2); |
| node->identifierToken = loc(3); |
| node->rparenToken = loc(4); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| Finally: T_FINALLY Block ; |
| /. |
| case $rule_number: { |
| AST::Finally *node = makeAstNode<AST::Finally> (driver->nodePool(), sym(2).Block); |
| node->finallyToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| DebuggerStatement: T_DEBUGGER T_AUTOMATIC_SEMICOLON ; -- automatic semicolon |
| DebuggerStatement: T_DEBUGGER T_SEMICOLON ; |
| /. |
| case $rule_number: { |
| AST::DebuggerStatement *node = makeAstNode<AST::DebuggerStatement> (driver->nodePool()); |
| node->debuggerToken = loc(1); |
| node->semicolonToken = loc(2); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| FunctionDeclaration: T_FUNCTION JsIdentifier T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ; |
| /. |
| case $rule_number: { |
| AST::FunctionDeclaration *node = makeAstNode<AST::FunctionDeclaration> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody); |
| node->functionToken = loc(1); |
| node->identifierToken = loc(2); |
| node->lparenToken = loc(3); |
| node->rparenToken = loc(5); |
| node->lbraceToken = loc(6); |
| node->rbraceToken = loc(8); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| FunctionExpression: T_FUNCTION IdentifierOpt T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ; |
| /. |
| case $rule_number: { |
| AST::FunctionExpression *node = makeAstNode<AST::FunctionExpression> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody); |
| node->functionToken = loc(1); |
| if (sym(2).sval) |
| node->identifierToken = loc(2); |
| node->lparenToken = loc(3); |
| node->rparenToken = loc(5); |
| node->lbraceToken = loc(6); |
| node->rbraceToken = loc(8); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| FormalParameterList: JsIdentifier ; |
| /. |
| case $rule_number: { |
| AST::FormalParameterList *node = makeAstNode<AST::FormalParameterList> (driver->nodePool(), sym(1).sval); |
| node->identifierToken = loc(1); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| FormalParameterList: FormalParameterList T_COMMA JsIdentifier ; |
| /. |
| case $rule_number: { |
| AST::FormalParameterList *node = makeAstNode<AST::FormalParameterList> (driver->nodePool(), sym(1).FormalParameterList, sym(3).sval); |
| node->commaToken = loc(2); |
| node->identifierToken = loc(3); |
| sym(1).Node = node; |
| } break; |
| ./ |
| |
| FormalParameterListOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| FormalParameterListOpt: FormalParameterList ; |
| /. |
| case $rule_number: { |
| sym(1).Node = sym(1).FormalParameterList->finish (); |
| } break; |
| ./ |
| |
| FunctionBodyOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| FunctionBodyOpt: FunctionBody ; |
| |
| FunctionBody: SourceElements ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::FunctionBody> (driver->nodePool(), sym(1).SourceElements->finish ()); |
| } break; |
| ./ |
| |
| Program: SourceElements ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::Program> (driver->nodePool(), sym(1).SourceElements->finish ()); |
| } break; |
| ./ |
| |
| SourceElements: SourceElement ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::SourceElements> (driver->nodePool(), sym(1).SourceElement); |
| } break; |
| ./ |
| |
| SourceElements: SourceElements SourceElement ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::SourceElements> (driver->nodePool(), sym(1).SourceElements, sym(2).SourceElement); |
| } break; |
| ./ |
| |
| SourceElement: Statement ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::StatementSourceElement> (driver->nodePool(), sym(1).Statement); |
| } break; |
| ./ |
| |
| SourceElement: FunctionDeclaration ; |
| /. |
| case $rule_number: { |
| sym(1).Node = makeAstNode<AST::FunctionSourceElement> (driver->nodePool(), sym(1).FunctionDeclaration); |
| } break; |
| ./ |
| |
| IdentifierOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).sval = 0; |
| } break; |
| ./ |
| |
| IdentifierOpt: JsIdentifier ; |
| |
| PropertyNameAndValueListOpt: ; |
| /. |
| case $rule_number: { |
| sym(1).Node = 0; |
| } break; |
| ./ |
| |
| PropertyNameAndValueListOpt: PropertyNameAndValueList ; |
| |
| /. |
| } // switch |
| action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT); |
| } // if |
| } while (action != 0); |
| |
| if (first_token == last_token) { |
| const int errorState = state_stack[tos]; |
| |
| // automatic insertion of `;' |
| if (yytoken != -1 && t_action(errorState, T_AUTOMATIC_SEMICOLON) && automatic(driver, yytoken)) { |
| SavedToken &tk = token_buffer[0]; |
| tk.token = yytoken; |
| tk.dval = yylval; |
| tk.loc = yylloc; |
| |
| yylloc = yyprevlloc; |
| yylloc.offset += yylloc.length; |
| yylloc.startColumn += yylloc.length; |
| yylloc.length = 0; |
| |
| //const QString msg = qApp->translate("QDeclarativeParser", "Missing `;'"); |
| //diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, yylloc, msg)); |
| |
| first_token = &token_buffer[0]; |
| last_token = &token_buffer[1]; |
| |
| yytoken = T_SEMICOLON; |
| yylval = 0; |
| |
| action = errorState; |
| |
| goto _Lcheck_token; |
| } |
| |
| hadErrors = true; |
| |
| token_buffer[0].token = yytoken; |
| token_buffer[0].dval = yylval; |
| token_buffer[0].loc = yylloc; |
| |
| token_buffer[1].token = yytoken = lexer->lex(); |
| token_buffer[1].dval = yylval = lexer->dval(); |
| token_buffer[1].loc = yylloc = location(lexer); |
| |
| if (t_action(errorState, yytoken)) { |
| QString msg; |
| int token = token_buffer[0].token; |
| if (token < 0 || token >= TERMINAL_COUNT) |
| msg = qApp->translate("QDeclarativeParser", "Syntax error"); |
| else |
| msg = qApp->translate("QDeclarativeParser", "Unexpected token `%1'").arg(QLatin1String(spell[token])); |
| diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg)); |
| |
| action = errorState; |
| goto _Lcheck_token; |
| } |
| |
| static int tokens[] = { |
| T_PLUS, |
| T_EQ, |
| |
| T_COMMA, |
| T_COLON, |
| T_SEMICOLON, |
| |
| T_RPAREN, T_RBRACKET, T_RBRACE, |
| |
| T_NUMERIC_LITERAL, |
| T_IDENTIFIER, |
| |
| T_LPAREN, T_LBRACKET, T_LBRACE, |
| |
| EOF_SYMBOL |
| }; |
| |
| for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) { |
| int a = t_action(errorState, *tk); |
| if (a > 0 && t_action(a, yytoken)) { |
| const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[*tk])); |
| diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg)); |
| |
| yytoken = *tk; |
| yylval = 0; |
| yylloc = token_buffer[0].loc; |
| yylloc.length = 0; |
| |
| first_token = &token_buffer[0]; |
| last_token = &token_buffer[2]; |
| |
| action = errorState; |
| goto _Lcheck_token; |
| } |
| } |
| |
| for (int tk = 1; tk < TERMINAL_COUNT; ++tk) { |
| if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM || |
| tk == T_FEED_JS_STATEMENT || tk == T_FEED_JS_EXPRESSION || |
| tk == T_FEED_JS_SOURCE_ELEMENT) |
| continue; |
| |
| int a = t_action(errorState, tk); |
| if (a > 0 && t_action(a, yytoken)) { |
| const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[tk])); |
| diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg)); |
| |
| yytoken = tk; |
| yylval = 0; |
| yylloc = token_buffer[0].loc; |
| yylloc.length = 0; |
| |
| action = errorState; |
| goto _Lcheck_token; |
| } |
| } |
| |
| const QString msg = qApp->translate("QDeclarativeParser", "Syntax error"); |
| diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg)); |
| } |
| |
| return false; |
| } |
| |
| QT_QML_END_NAMESPACE |
| |
| |
| ./ |
| /: |
| QT_QML_END_NAMESPACE |
| |
| |
| |
| #endif // QDECLARATIVEJSPARSER_P_H |
| :/ |