From 58d35f8a64445f3540da10ebb7761de0a2a44536 Mon Sep 17 00:00:00 2001 From: Ulf Hermann Date: Fri, 4 Oct 2019 16:11:02 +0200 Subject: [PATCH] QmlJS: Update QML parser using the one from qtdeclarative 5.15 We need to do this because the new "required" keyword should be recognized by Qt Creator. This is not a verbatim copy of the QML parser from qtdeclarative. A few data structures have changed that would require large scale changes in otherwise unrelated parts of the code. For example, all Visitors need to handle recursion depth errors now and the DiagnosticMessage only has line and column now, no longer begin and legth. Change-Id: Iea5b04e27b07e0cba55d64b844315af9828acbf7 Reviewed-by: Simon Hausmann Reviewed-by: Thomas Hartmann Reviewed-by: Eike Ziller --- src/libs/qmljs/parser/qmljs.g | 652 ++-- src/libs/qmljs/parser/qmljsast.cpp | 184 +- src/libs/qmljs/parser/qmljsast_p.h | 361 +- src/libs/qmljs/parser/qmljsastfwd_p.h | 4 + src/libs/qmljs/parser/qmljsastvisitor.cpp | 2 +- src/libs/qmljs/parser/qmljsastvisitor_p.h | 47 +- src/libs/qmljs/parser/qmljsgrammar.cpp | 3902 +++++++++++---------- src/libs/qmljs/parser/qmljsgrammar_p.h | 234 +- src/libs/qmljs/parser/qmljskeywords_p.h | 12 + src/libs/qmljs/parser/qmljslexer.cpp | 197 +- src/libs/qmljs/parser/qmljslexer_p.h | 8 + src/libs/qmljs/parser/qmljsparser.cpp | 2192 ++++++------ src/libs/qmljs/parser/qmljsparser_p.h | 50 +- src/libs/qmljs/qmljscheck.cpp | 12 +- 14 files changed, 4344 insertions(+), 3513 deletions(-) diff --git a/src/libs/qmljs/parser/qmljs.g b/src/libs/qmljs/parser/qmljs.g index c9dc94de920..c9dd6dae52b 100644 --- a/src/libs/qmljs/parser/qmljs.g +++ b/src/libs/qmljs/parser/qmljs.g @@ -49,6 +49,7 @@ %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_STAR "function *" %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" @@ -58,6 +59,7 @@ %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_VERSION_NUMBER "version number" %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 "%" @@ -87,6 +89,7 @@ %token T_STATIC "static" %token T_EXPORT "export" %token T_FROM "from" +%token T_REQUIRED "required" --- template strings %token T_NO_SUBSTITUTION_TEMPLATE"(no subst template)" @@ -119,8 +122,9 @@ %token T_FOR_LOOKAHEAD_OK "(for lookahead ok)" --%left T_PLUS T_MINUS -%nonassoc T_IDENTIFIER T_COLON T_SIGNAL T_PROPERTY T_READONLY T_ON T_SET T_GET T_OF T_STATIC T_FROM T_AS +%nonassoc T_IDENTIFIER T_COLON T_SIGNAL T_PROPERTY T_READONLY T_ON T_SET T_GET T_OF T_STATIC T_FROM T_AS T_REQUIRED %nonassoc REDUCE_HERE +%right T_THEN T_ELSE %start TopLevel @@ -297,6 +301,9 @@ public: AST::ExportsList *ExportsList; AST::ExportClause *ExportClause; AST::ExportDeclaration *ExportDeclaration; + AST::TypeAnnotation *TypeAnnotation; + AST::TypeArgumentList *TypeArgumentList; + AST::Type *Type; AST::UiProgram *UiProgram; AST::UiHeaderItemList *UiHeaderItemList; @@ -314,6 +321,7 @@ public: AST::UiArrayMemberList *UiArrayMemberList; AST::UiQualifiedId *UiQualifiedId; AST::UiEnumMemberList *UiEnumMemberList; + AST::UiVersionSpecifier *UiVersionSpecifier; }; public: @@ -392,6 +400,9 @@ protected: inline QStringRef &stringRef(int index) { return string_stack [tos + index - 1]; } + inline QStringRef &rawStringRef(int index) + { return rawString_stack [tos + index - 1]; } + inline AST::SourceLocation &loc(int index) { return location_stack [tos + index - 1]; } @@ -400,13 +411,25 @@ protected: void pushToken(int token); int lookaheadToken(Lexer *lexer); + static DiagnosticMessage compileError(const AST::SourceLocation &location, + const QString &message, Severity::Enum kind = Severity::Error) + { + DiagnosticMessage error; + error.loc = location; + error.message = message; + error.kind = kind; + return error; + } + void syntaxError(const AST::SourceLocation &location, const char *message) { - diagnostic_messages.append(DiagnosticMessage(Severity::Error, location, QLatin1String(message))); + diagnostic_messages.append(compileError(location, QLatin1String(message))); } void syntaxError(const AST::SourceLocation &location, const QString &message) { - diagnostic_messages.append(DiagnosticMessage(Severity::Error, location, message)); + diagnostic_messages.append(compileError(location, message)); } + bool ensureNoFunctionTypeAnnotations(AST::TypeAnnotation *returnTypeAnnotation, AST::FormalParameterList *formals); + protected: Engine *driver; MemoryPool *pool; @@ -416,6 +439,7 @@ protected: int *state_stack = nullptr; AST::SourceLocation *location_stack = nullptr; QVector string_stack; + QVector rawString_stack; AST::Node *program = nullptr; @@ -427,11 +451,13 @@ protected: double dval; AST::SourceLocation loc; QStringRef spell; + QStringRef raw; }; int yytoken = -1; double yylval = 0.; QStringRef yytokenspell; + QStringRef yytokenraw; AST::SourceLocation yylloc; AST::SourceLocation yyprevlloc; @@ -493,6 +519,7 @@ void Parser::reallocateStack() state_stack = reinterpret_cast (realloc(state_stack, stack_size * sizeof(int))); location_stack = reinterpret_cast (realloc(location_stack, stack_size * sizeof(AST::SourceLocation))); string_stack.resize(stack_size); + rawString_stack.resize(stack_size); } Parser::Parser(Engine *engine): @@ -550,9 +577,12 @@ AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr) void Parser::pushToken(int token) { + Q_ASSERT(last_token); + Q_ASSERT(last_token < &token_buffer[TOKEN_BUFFER_SIZE]); last_token->token = yytoken; last_token->dval = yylval; last_token->spell = yytokenspell; + last_token->raw = yytokenraw; last_token->loc = yylloc; ++last_token; yytoken = token; @@ -564,11 +594,27 @@ int Parser::lookaheadToken(Lexer *lexer) yytoken = lexer->lex(); yylval = lexer->tokenValue(); yytokenspell = lexer->tokenSpell(); + yytokenraw = lexer->rawString(); yylloc = location(lexer); } return yytoken; } +bool Parser::ensureNoFunctionTypeAnnotations(AST::TypeAnnotation *returnValueAnnotation, AST::FormalParameterList *formals) +{ + for (auto formal = formals; formal; formal = formal->next) { + if (formal->element && formal->element->typeAnnotation) { + syntaxError(formal->element->typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in function parameters in JavaScript functions"); + return false; + } + } + if (returnValueAnnotation) { + syntaxError(returnValueAnnotation->firstSourceLocation(), "Type annotations are not permitted for the return value of JavaScript functions"); + return false; + } + return true; +} + //#define PARSER_DEBUG bool Parser::parse(int startToken) @@ -616,11 +662,13 @@ bool Parser::parse(int startToken) yytoken = lexer->lex(); yylval = lexer->tokenValue(); yytokenspell = lexer->tokenSpell(); + yytokenraw = lexer->rawString(); yylloc = location(lexer); } else { yytoken = first_token->token; yylval = first_token->dval; yytokenspell = first_token->spell; + yytokenraw = first_token->raw; yylloc = first_token->loc; ++first_token; if (first_token == last_token) @@ -641,6 +689,7 @@ bool Parser::parse(int startToken) yytoken = -1; sym(1).dval = yylval; stringRef(1) = yytokenspell; + rawStringRef(1) = yytokenraw; loc(1) = yylloc; } else { --tos; @@ -755,8 +804,10 @@ UiHeaderItemList: UiHeaderItemList UiImport; PragmaId: JsIdentifier; -UiPragma: T_PRAGMA PragmaId T_AUTOMATIC_SEMICOLON; -UiPragma: T_PRAGMA PragmaId T_SEMICOLON; +Semicolon: T_AUTOMATIC_SEMICOLON; +Semicolon: T_SEMICOLON; + +UiPragma: T_PRAGMA PragmaId Semicolon; /. case $rule_number: { AST::UiPragma *pragma = new (pool) AST::UiPragma(stringRef(2)); @@ -768,28 +819,52 @@ UiPragma: T_PRAGMA PragmaId T_SEMICOLON; ImportId: MemberExpression; -UiImport: UiImportHead T_AUTOMATIC_SEMICOLON; -UiImport: UiImportHead T_SEMICOLON; +UiImport: UiImportHead 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; +UiVersionSpecifier: T_VERSION_NUMBER T_DOT T_VERSION_NUMBER; /. case $rule_number: { - sym(1).UiImport->versionToken = loc(2); + auto version = new (pool) AST::UiVersionSpecifier(sym(1).dval, sym(3).dval); + version->majorToken = loc(1); + version->minorToken = loc(3); + sym(1).UiVersionSpecifier = version; + } break; +./ + + +UiVersionSpecifier: T_VERSION_NUMBER; +/. + case $rule_number: { + auto version = new (pool) AST::UiVersionSpecifier(sym(1).dval, 0); + version->majorToken = loc(1); + sym(1).UiVersionSpecifier = version; + } break; +./ + +UiImport: UiImportHead UiVersionSpecifier Semicolon; +/. + case $rule_number: { + auto versionToken = loc(2); + auto version = sym(2).UiVersionSpecifier; + sym(1).UiImport->version = version; + if (version->minorToken.isValid()) { + versionToken.length += version->minorToken.length + (version->minorToken.offset - versionToken.offset - versionToken.length); + } + sym(1).UiImport->versionToken = versionToken; sym(1).UiImport->semicolonToken = loc(3); } break; ./ -UiImport: UiImportHead T_NUMERIC_LITERAL T_AS QmlIdentifier T_AUTOMATIC_SEMICOLON; -UiImport: UiImportHead T_NUMERIC_LITERAL T_AS QmlIdentifier T_SEMICOLON; +UiImport: UiImportHead UiVersionSpecifier T_AS QmlIdentifier Semicolon; /. case $rule_number: { sym(1).UiImport->versionToken = loc(2); + sym(1).UiImport->version = sym(2).UiVersionSpecifier; sym(1).UiImport->asToken = loc(3); sym(1).UiImport->importIdToken = loc(4); sym(1).UiImport->importId = stringRef(4); @@ -797,8 +872,7 @@ UiImport: UiImportHead T_NUMERIC_LITERAL T_AS QmlIdentifier T_SEMICOLON; } break; ./ -UiImport: UiImportHead T_AS QmlIdentifier T_AUTOMATIC_SEMICOLON; -UiImport: UiImportHead T_AS QmlIdentifier T_SEMICOLON; +UiImport: UiImportHead T_AS QmlIdentifier Semicolon; /. case $rule_number: { sym(1).UiImport->asToken = loc(2); @@ -826,7 +900,7 @@ UiImportHead: T_IMPORT ImportId; if (node) { node->importToken = loc(1); } else { - diagnostic_messages.append(DiagnosticMessage(Severity::Error, loc(1), + diagnostic_messages.append(compileError(loc(1), QLatin1String("Expected a qualified name id or a string literal"))); return false; // ### remove me @@ -1031,6 +1105,17 @@ UiParameterListOpt: UiParameterList; } break; ./ +UiParameterList: QmlIdentifier T_COLON UiPropertyType; +/. + case $rule_number: { + AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(3).UiQualifiedId->finish(), stringRef(1)); + node->identifierToken = loc(1); + node->colonToken = loc(2); + node->propertyTypeToken = loc(3); + sym(1).Node = node; + } break; +./ + UiParameterList: UiPropertyType QmlIdentifier; /. case $rule_number: { @@ -1041,6 +1126,18 @@ UiParameterList: UiPropertyType QmlIdentifier; } break; ./ +UiParameterList: UiParameterList T_COMMA QmlIdentifier T_COLON UiPropertyType; +/. + case $rule_number: { + AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiParameterList, sym(5).UiQualifiedId->finish(), stringRef(3)); + node->propertyTypeToken = loc(5); + node->commaToken = loc(2); + node->identifierToken = loc(3); + node->colonToken = loc(4); + sym(1).Node = node; + } break; +./ + UiParameterList: UiParameterList T_COMMA UiPropertyType QmlIdentifier; /. case $rule_number: { @@ -1052,8 +1149,7 @@ UiParameterList: UiParameterList T_COMMA UiPropertyType QmlIdentifier; } 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; +UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN Semicolon; /. case $rule_number: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(nullptr, stringRef(2)); @@ -1067,8 +1163,7 @@ UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_SEM } break; ./ -UiObjectMember: T_SIGNAL T_IDENTIFIER T_AUTOMATIC_SEMICOLON; -UiObjectMember: T_SIGNAL T_IDENTIFIER T_SEMICOLON; +UiObjectMember: T_SIGNAL T_IDENTIFIER Semicolon; /. case $rule_number: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(nullptr, stringRef(2)); @@ -1081,8 +1176,7 @@ UiObjectMember: T_SIGNAL T_IDENTIFIER T_SEMICOLON; } break; ./ -UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier T_AUTOMATIC_SEMICOLON; -UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier T_SEMICOLON; +UiObjectMemberListPropertyNoInitialiser: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier Semicolon; /. case $rule_number: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(4).UiQualifiedId->finish(), stringRef(6)); @@ -1096,8 +1190,19 @@ UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier T } break; ./ -UiObjectMember: T_PROPERTY UiPropertyType QmlIdentifier T_AUTOMATIC_SEMICOLON; -UiObjectMember: T_PROPERTY UiPropertyType QmlIdentifier T_SEMICOLON; +UiObjectMember: UiObjectMemberListPropertyNoInitialiser; + +UiObjectMember: T_READONLY UiObjectMemberListPropertyNoInitialiser; +/. + case $rule_number: { + AST::UiPublicMember *node = sym(2).UiPublicMember; + node->isReadonlyMember = true; + node->readonlyToken = loc(1); + sym(1).Node = node; + } break; +./ + +UiObjectMemberPropertyNoInitialiser: T_PROPERTY UiPropertyType QmlIdentifier Semicolon; /. case $rule_number: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(2).UiQualifiedId->finish(), stringRef(3)); @@ -1109,39 +1214,47 @@ UiObjectMember: T_PROPERTY UiPropertyType QmlIdentifier T_SEMICOLON; } break; ./ -UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType QmlIdentifier T_AUTOMATIC_SEMICOLON; -UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType QmlIdentifier T_SEMICOLON; + +UiObjectMember: UiObjectMemberPropertyNoInitialiser; + +UiObjectMember: T_DEFAULT UiObjectMemberPropertyNoInitialiser; /. case $rule_number: { - AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4)); + AST::UiPublicMember *node = sym(2).UiPublicMember; 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_DEFAULT T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier T_AUTOMATIC_SEMICOLON; -UiObjectMember: T_DEFAULT T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier T_SEMICOLON; +UiObjectMember: T_DEFAULT UiObjectMemberListPropertyNoInitialiser; /. case $rule_number: { - AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(5).UiQualifiedId->finish(), stringRef(7)); + AST::UiPublicMember *node = sym(2).UiPublicMember; node->isDefaultMember = true; node->defaultToken = loc(1); - node->typeModifier = stringRef(3); - node->propertyToken = loc(2); - node->typeModifierToken = loc(2); - node->typeToken = loc(4); - node->identifierToken = loc(7); - node->semicolonToken = loc(8); sym(1).Node = node; } break; ./ -UiObjectMember: T_PROPERTY UiPropertyType QmlIdentifier T_COLON UiScriptStatement; +OptionalSemicolon: | Semicolon; +/. +/* we need OptionalSemicolon because UiScriptStatement might already parse the last semicolon + and then we would miss a semicolon (see tests/auto/quick/qquickvisualdatamodel/data/objectlist.qml)*/ + ./ + +UiObjectMember: T_REQUIRED UiObjectMemberPropertyNoInitialiser; +/. + case $rule_number: { + AST::UiPublicMember *node = sym(2).UiPublicMember; + node->requiredToken = loc(1); + node->isRequired = true; + sym(1).Node = node; + } break; +./ + + +UiObjectMemberWithScriptStatement: T_PROPERTY UiPropertyType QmlIdentifier T_COLON UiScriptStatement OptionalSemicolon; /. case $rule_number: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(2).UiQualifiedId->finish(), stringRef(3), sym(5).Statement); @@ -1153,35 +1266,29 @@ UiObjectMember: T_PROPERTY UiPropertyType QmlIdentifier T_COLON UiScriptStatemen } break; ./ -UiObjectMember: T_READONLY T_PROPERTY UiPropertyType QmlIdentifier T_COLON UiScriptStatement; +UiObjectMember: UiObjectMemberWithScriptStatement; + +UiObjectMember: T_READONLY UiObjectMemberWithScriptStatement; /. case $rule_number: { - AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4), sym(6).Statement); + AST::UiPublicMember *node = sym(2).UiPublicMember; node->isReadonlyMember = true; node->readonlyToken = loc(1); - node->propertyToken = loc(2); - node->typeToken = loc(3); - node->identifierToken = loc(4); - node->colonToken = loc(5); sym(1).Node = node; } break; ./ -UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType QmlIdentifier T_COLON UiScriptStatement; +UiObjectMember: T_DEFAULT UiObjectMemberWithScriptStatement; /. case $rule_number: { - AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4), sym(6).Statement); + AST::UiPublicMember *node = sym(2).UiPublicMember; node->isDefaultMember = true; node->defaultToken = loc(1); - node->propertyToken = loc(2); - node->typeToken = loc(3); - node->identifierToken = loc(4); - node->colonToken = loc(5); sym(1).Node = node; } break; ./ -UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET; +UiObjectMemberWithArray: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET Semicolon; /. case $rule_number: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(4).UiQualifiedId->finish(), stringRef(6)); @@ -1207,7 +1314,19 @@ UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier T } break; ./ -UiObjectMember: T_PROPERTY UiPropertyType QmlIdentifier T_COLON ExpressionStatementLookahead UiQualifiedId UiObjectInitializer; +UiObjectMember: UiObjectMemberWithArray; + +UiObjectMember: T_READONLY UiObjectMemberWithArray; +/. + case $rule_number: { + AST::UiPublicMember *node = sym(2).UiPublicMember; + node->isReadonlyMember = true; + node->readonlyToken = loc(1); + sym(1).Node = node; + } break; +./ + +UiObjectMemberExpressionStatementLookahead: T_PROPERTY UiPropertyType QmlIdentifier T_COLON ExpressionStatementLookahead UiQualifiedId UiObjectInitializer Semicolon; /. case $rule_number: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(2).UiQualifiedId->finish(), stringRef(3)); @@ -1230,32 +1349,27 @@ UiObjectMember: T_PROPERTY UiPropertyType QmlIdentifier T_COLON ExpressionStatem } break; ./ -UiObjectMember: T_READONLY T_PROPERTY UiPropertyType QmlIdentifier T_COLON ExpressionStatementLookahead UiQualifiedId UiObjectInitializer; +UiObjectMember: UiObjectMemberExpressionStatementLookahead; + +UiObjectMember: T_READONLY UiObjectMemberExpressionStatementLookahead; /. case $rule_number: { - AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4)); + AST::UiPublicMember *node = sym(2).UiPublicMember; node->isReadonlyMember = true; node->readonlyToken = loc(1); - node->propertyToken = loc(2); - node->typeToken = loc(3); - node->identifierToken = loc(4); - node->semicolonToken = loc(5); // insert a fake ';' before ':' - - AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(4)); - propertyName->identifierToken = loc(4); - propertyName->next = 0; - - AST::UiObjectBinding *binding = new (pool) AST::UiObjectBinding( - propertyName, sym(7).UiQualifiedId, sym(8).UiObjectInitializer); - binding->colonToken = loc(5); - - node->binding = binding; - sym(1).Node = node; } break; ./ -UiObjectMember: FunctionDeclaration; +UiObjectMember: GeneratorDeclaration; +/. + case $rule_number: { + auto node = new (pool) AST::UiSourceElement(sym(1).Node); + sym(1).Node = node; + } break; +./ + +UiObjectMember: FunctionDeclarationWithTypes; /. case $rule_number: { sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node); @@ -1273,8 +1387,8 @@ UiQualifiedId: MemberExpression; /. case $rule_number: { if (AST::ArrayMemberExpression *mem = AST::cast(sym(1).Expression)) { - diagnostic_messages.append(DiagnosticMessage(Severity::Warning, mem->lbracketToken, - QLatin1String("Ignored annotation"))); + diagnostic_messages.append(compileError(mem->lbracketToken, + QLatin1String("Ignored annotation"), Severity::Warning)); sym(1).Expression = mem->base; } @@ -1284,7 +1398,7 @@ UiQualifiedId: MemberExpression; } else { sym(1).UiQualifiedId = 0; - diagnostic_messages.append(DiagnosticMessage(Severity::Error, loc(1), + diagnostic_messages.append(compileError(loc(1), QLatin1String("Expected a qualified name id"))); return false; // ### recover @@ -1354,6 +1468,7 @@ QmlIdentifier: T_GET; QmlIdentifier: T_SET; QmlIdentifier: T_FROM; QmlIdentifier: T_OF; +QmlIdentifier: T_REQUIRED; JsIdentifier: T_IDENTIFIER; JsIdentifier: T_PROPERTY; @@ -1366,10 +1481,68 @@ JsIdentifier: T_FROM; JsIdentifier: T_STATIC; JsIdentifier: T_OF; JsIdentifier: T_AS; +JsIdentifier: T_REQUIRED; IdentifierReference: JsIdentifier; BindingIdentifier: IdentifierReference; +-------------------------------------------------------------------------------------------------------- +-- Types +-------------------------------------------------------------------------------------------------------- + +TypeArguments: Type; +/. + case $rule_number: { + sym(1).TypeArgumentList = new (pool) AST::TypeArgumentList(sym(1).Type); + } break; +./ + +TypeArguments: TypeArguments T_COMMA Type; +/. + case $rule_number: { + sym(1).TypeArgumentList = new (pool) AST::TypeArgumentList(sym(1).TypeArgumentList, sym(3).Type); + } break; +./ + +Type: UiQualifiedId T_LT TypeArguments T_GT; +/. + case $rule_number: { + sym(1).Type = new (pool) AST::Type(sym(1).UiQualifiedId, sym(3).TypeArgumentList->finish()); + } break; +./ + +Type: T_RESERVED_WORD; +/. + case $rule_number: { + AST::UiQualifiedId *id = new (pool) AST::UiQualifiedId(stringRef(1)); + id->identifierToken = loc(1); + sym(1).Type = new (pool) AST::Type(id->finish()); + } break; +./ + +Type: UiQualifiedId; +/. + case $rule_number: { + sym(1).Type = new (pool) AST::Type(sym(1).UiQualifiedId); + } break; +./ + +TypeAnnotation: T_COLON Type; +/. + case $rule_number: { + sym(1).TypeAnnotation = new (pool) AST::TypeAnnotation(sym(2).Type); + sym(1).TypeAnnotation->colonToken = loc(1); + } break; +./ + +TypeAnnotationOpt: TypeAnnotation; +TypeAnnotationOpt: ; +/. + case $rule_number: { + sym(1).TypeAnnotation = nullptr; + } break; +./ + -------------------------------------------------------------------------------------------------------- -- Expressions -------------------------------------------------------------------------------------------------------- @@ -1531,7 +1704,7 @@ RegularExpressionLiteral: T_DIVIDE_EQ; scan_regexp: { bool rx = lexer->scanRegExp(prefix); if (!rx) { - diagnostic_messages.append(DiagnosticMessage(Severity::Error, location(lexer), lexer->errorMessage())); + diagnostic_messages.append(compileError(location(lexer), lexer->errorMessage())); return false; } @@ -1759,10 +1932,6 @@ PropertyDefinition: PropertyName T_COLON AssignmentExpression_In; /. case $rule_number: { AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, sym(3).Expression); - if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression)) { - if (!AST::cast(sym(1).PropertyName)) - f->name = driver->newStringRef(sym(1).PropertyName->asString()); - } if (auto *c = asAnonymousClassDefinition(sym(3).Expression)) { if (!AST::cast(sym(1).PropertyName)) c->name = driver->newStringRef(sym(1).PropertyName->asString()); @@ -1887,7 +2056,7 @@ TemplateLiteral: T_NO_SUBSTITUTION_TEMPLATE; TemplateSpans: T_TEMPLATE_TAIL; /. case $rule_number: { - AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), nullptr); + AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), rawStringRef(1), nullptr); node->literalToken = loc(1); sym(1).Node = node; } break; @@ -1899,7 +2068,7 @@ TemplateSpans: T_TEMPLATE_MIDDLE Expression TemplateSpans; TemplateLiteral: T_TEMPLATE_HEAD Expression TemplateSpans; /. case $rule_number: { - AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), sym(2).Expression); + AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), rawStringRef(1), sym(2).Expression); node->next = sym(3).Template; node->literalToken = loc(1); sym(1).Node = node; @@ -2704,8 +2873,7 @@ StatementListItem: Statement; } break; ./ -StatementListItem: ExpressionStatementLookahead T_FORCE_DECLARATION Declaration T_AUTOMATIC_SEMICOLON; -StatementListItem: ExpressionStatementLookahead T_FORCE_DECLARATION Declaration T_SEMICOLON; +StatementListItem: ExpressionStatementLookahead T_FORCE_DECLARATION Declaration Semicolon; /. case $rule_number: { sym(1).Node = new (pool) AST::StatementList(sym(3).FunctionDeclaration); @@ -2755,14 +2923,20 @@ VarDeclaration: Var VariableDeclarationList; VarDeclaration_In: Var VariableDeclarationList_In; /. case $rule_number: { - AST::VariableStatement *node = new (pool) AST::VariableStatement(sym(2).VariableDeclarationList->finish(sym(1).scope)); + AST::VariableDeclarationList *declarations = sym(2).VariableDeclarationList->finish(sym(1).scope); + for (auto it = declarations; it; it = it->next) { + if (it->declaration && it->declaration->typeAnnotation) { + syntaxError(it->declaration->typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in variable declarations"); + return false; + } + } + AST::VariableStatement *node = new (pool) AST::VariableStatement(declarations); node->declarationKindToken = loc(1); sym(1).Node = node; } break; ./ -VariableStatement: VarDeclaration_In T_AUTOMATIC_SEMICOLON; -VariableStatement: VarDeclaration_In T_SEMICOLON; +VariableStatement: VarDeclaration_In Semicolon; BindingList: LexicalBinding_In; /. case $rule_number: Q_FALLTHROUGH(); ./ @@ -2792,22 +2966,22 @@ VariableDeclarationList_In: VariableDeclarationList_In T_COMMA VariableDeclarati } break; ./ -LexicalBinding: BindingIdentifier InitializerOpt; +LexicalBinding: BindingIdentifier TypeAnnotationOpt InitializerOpt; /. case $rule_number: Q_FALLTHROUGH(); ./ -LexicalBinding_In: BindingIdentifier InitializerOpt_In; +LexicalBinding_In: BindingIdentifier TypeAnnotationOpt InitializerOpt_In; /. case $rule_number: Q_FALLTHROUGH(); ./ -VariableDeclaration: BindingIdentifier InitializerOpt; +VariableDeclaration: BindingIdentifier TypeAnnotationOpt InitializerOpt; /. case $rule_number: Q_FALLTHROUGH(); ./ -VariableDeclaration_In: BindingIdentifier InitializerOpt_In; +VariableDeclaration_In: BindingIdentifier TypeAnnotationOpt InitializerOpt_In; /. case $rule_number: { - auto *node = new (pool) AST::PatternElement(stringRef(1), sym(2).Expression); + auto *node = new (pool) AST::PatternElement(stringRef(1), sym(2).TypeAnnotation, sym(3).Expression); node->identifierToken = loc(1); sym(1).Node = node; // if initializer is an anonymous function expression, we need to assign identifierref as it's name - if (auto *f = asAnonymousFunctionDefinition(sym(2).Expression)) + if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression)) f->name = stringRef(1); - if (auto *c = asAnonymousClassDefinition(sym(2).Expression)) + if (auto *c = asAnonymousClassDefinition(sym(3).Expression)) c->name = stringRef(1); } break; ./ @@ -2957,15 +3131,15 @@ BindingProperty: PropertyName T_COLON BindingPattern InitializerOpt_In; } break; ./ -BindingElement: BindingIdentifier InitializerOpt_In; +BindingElement: BindingIdentifier TypeAnnotationOpt InitializerOpt_In; /. case $rule_number: { - AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1), sym(2).Expression); + AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1), sym(2).TypeAnnotation, sym(3).Expression); node->identifierToken = loc(1); // if initializer is an anonymous function expression, we need to assign identifierref as it's name - if (auto *f = asAnonymousFunctionDefinition(sym(2).Expression)) + if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression)) f->name = stringRef(1); - if (auto *c = asAnonymousClassDefinition(sym(2).Expression)) + if (auto *c = asAnonymousClassDefinition(sym(3).Expression)) c->name = stringRef(1); sym(1).Node = node; } break; @@ -2982,7 +3156,7 @@ BindingElement: BindingPattern InitializerOpt_In; BindingRestElement: T_ELLIPSIS BindingIdentifier; /. case $rule_number: { - AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(2), nullptr, AST::PatternElement::RestElement); + AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(2), /*type annotation*/nullptr, nullptr, AST::PatternElement::RestElement); node->identifierToken = loc(2); sym(1).Node = node; } break; @@ -3027,13 +3201,12 @@ ExpressionStatementLookahead: ; int token = lookaheadToken(lexer); if (token == T_LBRACE) pushToken(T_FORCE_BLOCK); - else if (token == T_FUNCTION || token == T_CLASS || token == T_LET || token == T_CONST) + else if (token == T_FUNCTION || token == T_FUNCTION_STAR || token == T_CLASS || token == T_LET || token == T_CONST) pushToken(T_FORCE_DECLARATION); } break; ./ -ExpressionStatement: Expression_In T_AUTOMATIC_SEMICOLON; -ExpressionStatement: Expression_In T_SEMICOLON; +ExpressionStatement: Expression_In Semicolon; /. case $rule_number: { AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(sym(1).Expression); @@ -3066,9 +3239,8 @@ IfStatement: T_IF T_LPAREN Expression_In T_RPAREN Statement; ./ -IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression_In T_RPAREN T_AUTOMATIC_SEMICOLON; IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression_In T_RPAREN T_COMPATIBILITY_SEMICOLON; -- for JSC/V8 compatibility -IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression_In T_RPAREN T_SEMICOLON; +IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression_In T_RPAREN Semicolon; /. case $rule_number: { AST::DoWhileStatement *node = new (pool) AST::DoWhileStatement(sym(2).Statement, sym(5).Expression); @@ -3172,12 +3344,16 @@ IterationStatement: T_FOR T_LPAREN ForDeclaration InOrOf Expression_In T_RPAREN } break; ./ -ForDeclaration: LetOrConst BindingIdentifier; +ForDeclaration: LetOrConst BindingIdentifier TypeAnnotationOpt; /. case $rule_number: Q_FALLTHROUGH(); ./ -ForDeclaration: Var BindingIdentifier; +ForDeclaration: Var BindingIdentifier TypeAnnotationOpt; /. case $rule_number: { - auto *node = new (pool) AST::PatternElement(stringRef(2), nullptr); + if (auto typeAnnotation = sym(3).TypeAnnotation) { + syntaxError(typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in variable declarations"); + return false; + } + auto *node = new (pool) AST::PatternElement(stringRef(2), sym(3).TypeAnnotation, nullptr); node->identifierToken = loc(2); node->scope = sym(1).scope; node->isForDeclaration = true; @@ -3197,8 +3373,7 @@ ForDeclaration: Var BindingPattern; } break; ./ -ContinueStatement: T_CONTINUE T_AUTOMATIC_SEMICOLON; -ContinueStatement: T_CONTINUE T_SEMICOLON; +ContinueStatement: T_CONTINUE Semicolon; /. case $rule_number: { AST::ContinueStatement *node = new (pool) AST::ContinueStatement(); @@ -3208,8 +3383,7 @@ ContinueStatement: T_CONTINUE T_SEMICOLON; } break; ./ -ContinueStatement: T_CONTINUE IdentifierReference T_AUTOMATIC_SEMICOLON; -ContinueStatement: T_CONTINUE IdentifierReference T_SEMICOLON; +ContinueStatement: T_CONTINUE IdentifierReference Semicolon; /. case $rule_number: { AST::ContinueStatement *node = new (pool) AST::ContinueStatement(stringRef(2)); @@ -3220,8 +3394,7 @@ ContinueStatement: T_CONTINUE IdentifierReference T_SEMICOLON; } break; ./ -BreakStatement: T_BREAK T_AUTOMATIC_SEMICOLON; -BreakStatement: T_BREAK T_SEMICOLON; +BreakStatement: T_BREAK Semicolon; /. case $rule_number: { AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef()); @@ -3231,8 +3404,7 @@ BreakStatement: T_BREAK T_SEMICOLON; } break; ./ -BreakStatement: T_BREAK IdentifierReference T_AUTOMATIC_SEMICOLON; -BreakStatement: T_BREAK IdentifierReference T_SEMICOLON; +BreakStatement: T_BREAK IdentifierReference Semicolon; /. case $rule_number: { AST::BreakStatement *node = new (pool) AST::BreakStatement(stringRef(2)); @@ -3243,8 +3415,7 @@ BreakStatement: T_BREAK IdentifierReference T_SEMICOLON; } break; ./ -ReturnStatement: T_RETURN ExpressionOpt_In T_AUTOMATIC_SEMICOLON; -ReturnStatement: T_RETURN ExpressionOpt_In T_SEMICOLON; +ReturnStatement: T_RETURN ExpressionOpt_In Semicolon; /. case $rule_number: { if (!functionNestingLevel) { @@ -3368,8 +3539,7 @@ LabelledItem: ExpressionStatementLookahead T_FORCE_DECLARATION FunctionDeclarati } break; ./ -ThrowStatement: T_THROW Expression_In T_AUTOMATIC_SEMICOLON; -ThrowStatement: T_THROW Expression_In T_SEMICOLON; +ThrowStatement: T_THROW Expression_In Semicolon; /. case $rule_number: { AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression); @@ -3446,8 +3616,7 @@ CatchParameter: BindingPattern; } break; ./ -DebuggerStatement: T_DEBUGGER T_AUTOMATIC_SEMICOLON; -- automatic semicolon -DebuggerStatement: T_DEBUGGER T_SEMICOLON; +DebuggerStatement: T_DEBUGGER Semicolon; /. case $rule_number: { AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement(); @@ -3464,59 +3633,85 @@ DebuggerStatement: T_DEBUGGER T_SEMICOLON; -- otherwise conflict. Function: T_FUNCTION %prec REDUCE_HERE; -FunctionDeclaration: Function BindingIdentifier T_LPAREN FormalParameters T_RPAREN FunctionLBrace FunctionBody FunctionRBrace; +FunctionDeclaration: Function BindingIdentifier T_LPAREN FormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace; /. case $rule_number: { - AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList)) + return false; + AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList, + /*type annotation*/nullptr); node->functionToken = loc(1); node->identifierToken = loc(2); node->lparenToken = loc(3); node->rparenToken = loc(5); + node->lbraceToken = loc(7); + node->rbraceToken = loc(9); + sym(1).Node = node; + } break; +./ + +FunctionDeclarationWithTypes: Function BindingIdentifier T_LPAREN FormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace; +/. + case $rule_number: { + AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList, + sym(6).TypeAnnotation); + node->functionToken = loc(1); + node->identifierToken = loc(2); + node->lparenToken = loc(3); + node->rparenToken = loc(5); + node->lbraceToken = loc(7); + node->rbraceToken = loc(9); + sym(1).Node = node; + } break; +./ + +FunctionDeclaration_Default: FunctionDeclaration; +FunctionDeclaration_Default: Function T_LPAREN FormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace; +/. + case $rule_number: { + if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList)) + return false; + AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(3).FormalParameterList, sym(7).StatementList, + /*type annotation*/nullptr); + node->functionToken = loc(1); + node->lparenToken = loc(2); + node->rparenToken = loc(4); node->lbraceToken = loc(6); node->rbraceToken = loc(8); sym(1).Node = node; } break; ./ - -FunctionDeclaration_Default: FunctionDeclaration; -FunctionDeclaration_Default: Function T_LPAREN FormalParameters T_RPAREN FunctionLBrace FunctionBody FunctionRBrace; +FunctionExpression: T_FUNCTION BindingIdentifier T_LPAREN FormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace; /. case $rule_number: { - AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList); - node->functionToken = loc(1); - node->lparenToken = loc(2); - node->rparenToken = loc(4); - node->lbraceToken = loc(5); - node->rbraceToken = loc(7); - sym(1).Node = node; - } break; -./ - -FunctionExpression: T_FUNCTION BindingIdentifier T_LPAREN FormalParameters T_RPAREN FunctionLBrace FunctionBody FunctionRBrace; -/. - case $rule_number: { - AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList)) + return false; + AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList, + /*type annotation*/nullptr); node->functionToken = loc(1); if (! stringRef(2).isNull()) node->identifierToken = loc(2); node->lparenToken = loc(3); node->rparenToken = loc(5); - node->lbraceToken = loc(6); - node->rbraceToken = loc(8); + node->lbraceToken = loc(7); + node->rbraceToken = loc(9); sym(1).Node = node; } break; ./ -FunctionExpression: T_FUNCTION T_LPAREN FormalParameters T_RPAREN FunctionLBrace FunctionBody FunctionRBrace; +FunctionExpression: T_FUNCTION T_LPAREN FormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace; /. case $rule_number: { - AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList); + if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList)) + return false; + AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(7).StatementList, + /*type annotation*/nullptr); node->functionToken = loc(1); node->lparenToken = loc(2); node->rparenToken = loc(4); - node->lbraceToken = loc(5); - node->rbraceToken = loc(7); + node->lbraceToken = loc(6); + node->rbraceToken = loc(8); sym(1).Node = node; } break; ./ @@ -3626,7 +3821,7 @@ ArrowFunction_In: ArrowParameters T_ARROW ConciseBodyLookahead T_FORCE_BLOCK Fun ArrowParameters: BindingIdentifier; /. case $rule_number: { - AST::PatternElement *e = new (pool) AST::PatternElement(stringRef(1), nullptr, AST::PatternElement::Binding); + AST::PatternElement *e = new (pool) AST::PatternElement(stringRef(1), /*type annotation*/nullptr, nullptr, AST::PatternElement::Binding); e->identifierToken = loc(1); sym(1).FormalParameterList = (new (pool) AST::FormalParameterList(nullptr, e))->finish(pool); } break; @@ -3660,62 +3855,70 @@ ConciseBodyLookahead: ; } break; ./ -MethodDefinition: PropertyName T_LPAREN StrictFormalParameters T_RPAREN FunctionLBrace FunctionBody FunctionRBrace; +MethodDefinition: PropertyName T_LPAREN StrictFormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace; /. case $rule_number: { - AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(1), sym(3).FormalParameterList, sym(6).StatementList); + if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList)) + return false; + AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(1), sym(3).FormalParameterList, sym(7).StatementList); f->functionToken = sym(1).PropertyName->firstSourceLocation(); f->lparenToken = loc(2); f->rparenToken = loc(4); - f->lbraceToken = loc(5); - f->rbraceToken = loc(7); - AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, f); + f->lbraceToken = loc(6); + f->rbraceToken = loc(8); + AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, f, AST::PatternProperty::Method); node->colonToken = loc(2); sym(1).Node = node; } break; ./ -MethodDefinition: T_STAR PropertyName GeneratorLParen StrictFormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace; +MethodDefinition: T_STAR PropertyName GeneratorLParen StrictFormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace GeneratorBody GeneratorRBrace; /. case $rule_number: { - AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList)) + return false; + AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList); f->functionToken = sym(2).PropertyName->firstSourceLocation(); f->lparenToken = loc(3); f->rparenToken = loc(5); - f->lbraceToken = loc(6); - f->rbraceToken = loc(8); + f->lbraceToken = loc(7); + f->rbraceToken = loc(9); f->isGenerator = true; - AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f); + AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Method); node->colonToken = loc(2); sym(1).Node = node; } break; ./ -MethodDefinition: T_GET PropertyName T_LPAREN T_RPAREN FunctionLBrace FunctionBody FunctionRBrace; +MethodDefinition: T_GET PropertyName T_LPAREN T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace; /. case $rule_number: { - AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), nullptr, sym(6).StatementList); + if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, /*formals*/nullptr)) + return false; + AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), nullptr, sym(7).StatementList); f->functionToken = sym(2).PropertyName->firstSourceLocation(); f->lparenToken = loc(3); f->rparenToken = loc(4); - f->lbraceToken = loc(5); - f->rbraceToken = loc(7); + f->lbraceToken = loc(6); + f->rbraceToken = loc(8); AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Getter); node->colonToken = loc(2); sym(1).Node = node; } break; ./ -MethodDefinition: T_SET PropertyName T_LPAREN PropertySetParameterList T_RPAREN FunctionLBrace FunctionBody FunctionRBrace; +MethodDefinition: T_SET PropertyName T_LPAREN PropertySetParameterList T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace; /. case $rule_number: { - AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList)) + return false; + AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList); f->functionToken = sym(2).PropertyName->firstSourceLocation(); f->lparenToken = loc(3); f->rparenToken = loc(5); - f->lbraceToken = loc(6); - f->rbraceToken = loc(8); + f->lbraceToken = loc(7); + f->rbraceToken = loc(9); AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Setter); node->colonToken = loc(2); sym(1).Node = node; @@ -3746,27 +3949,45 @@ GeneratorRBrace: T_RBRACE; } break; ./ -GeneratorDeclaration: Function T_STAR BindingIdentifier GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace; +FunctionStar: T_FUNCTION_STAR %prec REDUCE_HERE; + +GeneratorDeclaration: FunctionStar BindingIdentifier GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace; /. case $rule_number: { - AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(3), sym(5).FormalParameterList, sym(8).StatementList); + AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); node->functionToken = loc(1); - node->identifierToken = loc(3); - node->lparenToken = loc(4); - node->rparenToken = loc(6); - node->lbraceToken = loc(7); - node->rbraceToken = loc(9); + node->identifierToken = loc(2); + node->lparenToken = loc(3); + node->rparenToken = loc(5); + node->lbraceToken = loc(6); + node->rbraceToken = loc(8); node->isGenerator = true; sym(1).Node = node; } break; ./ GeneratorDeclaration_Default: GeneratorDeclaration; -GeneratorDeclaration_Default: Function T_STAR GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace; +GeneratorDeclaration_Default: FunctionStar GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace; /. case $rule_number: { - AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(4).FormalParameterList, sym(7).StatementList); + AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList); node->functionToken = loc(1); + node->lparenToken = loc(2); + node->rparenToken = loc(4); + node->lbraceToken = loc(5); + node->rbraceToken = loc(7); + node->isGenerator = true; + sym(1).Node = node; + } break; +./ + +GeneratorExpression: T_FUNCTION_STAR BindingIdentifier GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace; +/. + case $rule_number: { + AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + node->functionToken = loc(1); + if (!stringRef(2).isNull()) + node->identifierToken = loc(2); node->lparenToken = loc(3); node->rparenToken = loc(5); node->lbraceToken = loc(6); @@ -3776,31 +3997,15 @@ GeneratorDeclaration_Default: Function T_STAR GeneratorLParen FormalParameters T } break; ./ -GeneratorExpression: T_FUNCTION T_STAR BindingIdentifier GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace; +GeneratorExpression: T_FUNCTION_STAR GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace; /. case $rule_number: { - AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(3), sym(5).FormalParameterList, sym(8).StatementList); + AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList); node->functionToken = loc(1); - if (!stringRef(3).isNull()) - node->identifierToken = loc(3); - node->lparenToken = loc(4); - node->rparenToken = loc(6); - node->lbraceToken = loc(7); - node->rbraceToken = loc(9); - node->isGenerator = true; - sym(1).Node = node; - } break; -./ - -GeneratorExpression: T_FUNCTION T_STAR GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace; -/. - case $rule_number: { - AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(4).FormalParameterList, sym(7).StatementList); - node->functionToken = loc(1); - node->lparenToken = loc(3); - node->rparenToken = loc(5); - node->lbraceToken = loc(6); - node->rbraceToken = loc(8); + node->lparenToken = loc(2); + node->rparenToken = loc(4); + node->lbraceToken = loc(5); + node->rbraceToken = loc(7); node->isGenerator = true; sym(1).Node = node; } break; @@ -3941,8 +4146,12 @@ ClassElementList: ClassElement; ClassElementList: ClassElementList ClassElement; /. case $rule_number: { - if (sym(2).Node) - sym(1).ClassElementList = sym(1).ClassElementList->append(sym(2).ClassElementList); + if (sym(1).Node) { + if (sym(2).Node) + sym(1).ClassElementList = sym(1).ClassElementList->append(sym(2).ClassElementList); + } else if (sym(2).Node) { + sym(1).Node = sym(2).Node; + } } break; ./ @@ -4018,13 +4227,10 @@ ModuleItemList: ModuleItemList ModuleItem; } break; ./ -ModuleItem: ImportDeclaration T_AUTOMATIC_SEMICOLON; + +ModuleItem: ImportDeclaration Semicolon; /. case $rule_number: Q_FALLTHROUGH(); ./ -ModuleItem: ImportDeclaration T_SEMICOLON; -/. case $rule_number: Q_FALLTHROUGH(); ./ -ModuleItem: ExportDeclaration T_AUTOMATIC_SEMICOLON; -/. case $rule_number: Q_FALLTHROUGH(); ./ -ModuleItem: ExportDeclaration T_SEMICOLON; +ModuleItem: ExportDeclaration Semicolon; /. case $rule_number: { sym(1).StatementList = new (pool) AST::StatementList(sym(1).Node); @@ -4184,7 +4390,7 @@ ExportDeclarationLookahead: ; /. case $rule_number: { int token = lookaheadToken(lexer); - if (token == T_FUNCTION || token == T_CLASS) + if (token == T_FUNCTION || token == T_FUNCTION_STAR || token == T_CLASS) pushToken(T_FORCE_DECLARATION); } break; ./ @@ -4352,6 +4558,7 @@ ExportSpecifier: IdentifierName T_AS IdentifierName; tk.token = yytoken; tk.dval = yylval; tk.spell = yytokenspell; + tk.raw = yytokenraw; tk.loc = yylloc; yylloc = yyprevlloc; @@ -4360,7 +4567,7 @@ ExportSpecifier: IdentifierName T_AS IdentifierName; yylloc.length = 0; //const QString msg = QCoreApplication::translate("QmlParser", "Missing `;'"); - //diagnostic_messages.append(DiagnosticMessage(Severity::Warning, yylloc, msg)); + //diagnostic_messages.append(compileError(yyloc, msg, Severity::Warning)); first_token = &token_buffer[0]; last_token = &token_buffer[1]; @@ -4378,21 +4585,26 @@ ExportSpecifier: IdentifierName T_AS IdentifierName; token_buffer[0].token = yytoken; token_buffer[0].dval = yylval; token_buffer[0].spell = yytokenspell; + token_buffer[0].raw = yytokenraw; token_buffer[0].loc = yylloc; token_buffer[1].token = yytoken = lexer->lex(); token_buffer[1].dval = yylval = lexer->tokenValue(); token_buffer[1].spell = yytokenspell = lexer->tokenSpell(); + token_buffer[1].raw = yytokenraw = lexer->rawString(); token_buffer[1].loc = yylloc = location(lexer); if (t_action(errorState, yytoken)) { +#ifdef PARSER_DEBUG + qDebug() << "Parse error, trying to recover."; +#endif QString msg; int token = token_buffer[0].token; if (token < 0 || token >= TERMINAL_COUNT) msg = QCoreApplication::translate("QmlParser", "Syntax error"); else msg = QCoreApplication::translate("QmlParser", "Unexpected token `%1'").arg(QLatin1String(spell[token])); - diagnostic_messages.append(DiagnosticMessage(Severity::Error, token_buffer[0].loc, msg)); + diagnostic_messages.append(compileError(token_buffer[0].loc, msg)); action = errorState; goto _Lcheck_token; @@ -4419,18 +4631,13 @@ ExportSpecifier: IdentifierName T_AS IdentifierName; for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) { int a = t_action(errorState, *tk); if (a > 0 && t_action(a, yytoken)) { +#ifdef PARSER_DEBUG + qDebug() << "Parse error, trying to recover (2)."; +#endif const QString msg = QCoreApplication::translate("QmlParser", "Expected token `%1'").arg(QLatin1String(spell[*tk])); - diagnostic_messages.append(DiagnosticMessage(Severity::Error, token_buffer[0].loc, msg)); + diagnostic_messages.append(compileError(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; + pushToken(*tk); goto _Lcheck_token; } } @@ -4443,20 +4650,15 @@ ExportSpecifier: IdentifierName T_AS IdentifierName; int a = t_action(errorState, tk); if (a > 0 && t_action(a, yytoken)) { const QString msg = QCoreApplication::translate("QmlParser", "Expected token `%1'").arg(QLatin1String(spell[tk])); - diagnostic_messages.append(DiagnosticMessage(Severity::Error, token_buffer[0].loc, msg)); + diagnostic_messages.append(compileError(token_buffer[0].loc, msg)); - yytoken = tk; - yylval = 0; - yylloc = token_buffer[0].loc; - yylloc.length = 0; - - action = errorState; + pushToken(tk); goto _Lcheck_token; } } const QString msg = QCoreApplication::translate("QmlParser", "Syntax error"); - diagnostic_messages.append(DiagnosticMessage(Severity::Error, token_buffer[0].loc, msg)); + diagnostic_messages.append(compileError(token_buffer[0].loc, msg)); } return false; diff --git a/src/libs/qmljs/parser/qmljsast.cpp b/src/libs/qmljs/parser/qmljsast.cpp index 5ec1df21a9d..0869de97ef4 100644 --- a/src/libs/qmljs/parser/qmljsast.cpp +++ b/src/libs/qmljs/parser/qmljsast.cpp @@ -51,21 +51,6 @@ ClassExpression *asAnonymousClassDefinition(Node *n) return c; } - -void Node::accept(Visitor *visitor) -{ - if (visitor->preVisit(this)) { - accept0(visitor); - } - visitor->postVisit(this); -} - -void Node::accept(Node *node, Visitor *visitor) -{ - if (node) - node->accept(visitor); -} - ExpressionNode *Node::expressionCast() { return nullptr; @@ -106,6 +91,12 @@ ClassExpression *Node::asClassDefinition() return nullptr; } +bool Node::ignoreRecursionDepth() const +{ + static const bool doIgnore = qEnvironmentVariableIsSet("QV4_CRASH_ON_STACKOVERFLOW"); + return doIgnore; +} + ExpressionNode *ExpressionNode::expressionCast() { return this; @@ -132,7 +123,7 @@ FormalParameterList *ExpressionNode::reparseAsFormalParameterList(MemoryPool *po } AST::PatternElement *binding = nullptr; if (AST::IdentifierExpression *idExpr = AST::cast(expr)) { - binding = new (pool) AST::PatternElement(idExpr->name, rhs); + binding = new (pool) AST::PatternElement(idExpr->name, /*type annotation*/nullptr, rhs); binding->identifierToken = idExpr->identifierToken; } else if (AST::Pattern *p = expr->patternCast()) { SourceLocation loc; @@ -239,12 +230,11 @@ void StringLiteral::accept0(Visitor *visitor) void TemplateLiteral::accept0(Visitor *visitor) { - if (visitor->visit(this)) { - if (next) - accept(next, visitor); + bool accepted = true; + for (TemplateLiteral *it = this; it && accepted; it = it->next) { + accepted = visitor->visit(it); + visitor->endVisit(it); } - - visitor->endVisit(this); } void NumericLiteral::accept0(Visitor *visitor) @@ -451,6 +441,8 @@ bool PatternProperty::convertLiteralToAssignmentPattern(MemoryPool *pool, Source *errorMessage = QString::fromLatin1("Invalid getter/setter in destructuring expression."); return false; } + if (type == Method) + type = Literal; Q_ASSERT(type == Literal); return PatternElement::convertLiteralToAssignmentPattern(pool, errorLocation, errorMessage); } @@ -960,6 +952,7 @@ void FunctionDeclaration::accept0(Visitor *visitor) { if (visitor->visit(this)) { accept(formals, visitor); + accept(typeAnnotation, visitor); accept(body, visitor); } @@ -970,6 +963,7 @@ void FunctionExpression::accept0(Visitor *visitor) { if (visitor->visit(this)) { accept(formals, visitor); + accept(typeAnnotation, visitor); accept(body, visitor); } @@ -981,9 +975,9 @@ FunctionExpression *FunctionExpression::asFunctionDefinition() return this; } -QStringList FormalParameterList::formals() const +BoundNames FormalParameterList::formals() const { - QStringList formals; + BoundNames formals; int i = 0; for (const FormalParameterList *it = this; it; it = it->next) { if (it->element) { @@ -991,18 +985,18 @@ QStringList FormalParameterList::formals() const int duplicateIndex = formals.indexOf(name); if (duplicateIndex >= 0) { // change the name of the earlier argument to enforce the lookup semantics from the spec - formals[duplicateIndex] += QLatin1String("#") + QString::number(i); + formals[duplicateIndex].id += QLatin1String("#") + QString::number(i); } - formals += name; + formals += {name, it->element->typeAnnotation}; } ++i; } return formals; } -QStringList FormalParameterList::boundNames() const +BoundNames FormalParameterList::boundNames() const { - QStringList names; + BoundNames names; for (const FormalParameterList *it = this; it; it = it->next) { if (it->element) it->element->boundNames(&names); @@ -1012,13 +1006,13 @@ QStringList FormalParameterList::boundNames() const void FormalParameterList::accept0(Visitor *visitor) { - if (visitor->visit(this)) { - accept(element, visitor); - if (next) - accept(next, visitor); + bool accepted = true; + for (FormalParameterList *it = this; it && accepted; it = it->next) { + accepted = visitor->visit(it); + if (accepted) + accept(it->element, visitor); + visitor->endVisit(it); } - - visitor->endVisit(this); } FormalParameterList *FormalParameterList::finish(QmlJS::MemoryPool *pool) @@ -1270,6 +1264,35 @@ void UiQualifiedId::accept0(Visitor *visitor) visitor->endVisit(this); } +void Type::accept0(Visitor *visitor) +{ + if (visitor->visit(this)) { + accept(typeId, visitor); + accept(typeArguments, visitor); + } + + visitor->endVisit(this); +} + +void TypeArgumentList::accept0(Visitor *visitor) +{ + if (visitor->visit(this)) { + for (TypeArgumentList *it = this; it; it = it->next) + accept(it->typeId, visitor); + } + + visitor->endVisit(this); +} + +void TypeAnnotation::accept0(Visitor *visitor) +{ + if (visitor->visit(this)) { + accept(type, visitor); + } + + visitor->endVisit(this); +} + void UiImport::accept0(Visitor *visitor) { if (visitor->visit(this)) { @@ -1289,12 +1312,14 @@ void UiPragma::accept0(Visitor *visitor) void UiHeaderItemList::accept0(Visitor *visitor) { - if (visitor->visit(this)) { - accept(headerItem, visitor); - accept(next, visitor); - } + bool accepted = true; + for (UiHeaderItemList *it = this; it && accepted; it = it->next) { + accepted = visitor->visit(it); + if (accepted) + accept(it->headerItem, visitor); - visitor->endVisit(this); + visitor->endVisit(it); + } } @@ -1338,13 +1363,14 @@ void PatternElement::accept0(Visitor *visitor) { if (visitor->visit(this)) { accept(bindingTarget, visitor); + accept(typeAnnotation, visitor); accept(initializer, visitor); } visitor->endVisit(this); } -void PatternElement::boundNames(QStringList *names) +void PatternElement::boundNames(BoundNames *names) { if (bindingTarget) { if (PatternElementList *e = elementList()) @@ -1352,23 +1378,24 @@ void PatternElement::boundNames(QStringList *names) else if (PatternPropertyList *p = propertyList()) p->boundNames(names); } else { - names->append(bindingIdentifier.toString()); + names->append({bindingIdentifier.toString(), typeAnnotation}); } } void PatternElementList::accept0(Visitor *visitor) { - if (visitor->visit(this)) { - accept(elision, visitor); - accept(element, visitor); - if (next) - accept(next, visitor); + bool accepted = true; + for (PatternElementList *it = this; it && accepted; it = it->next) { + accepted = visitor->visit(it); + if (accepted) { + accept(it->elision, visitor); + accept(it->element, visitor); + } + visitor->endVisit(it); } - - visitor->endVisit(this); } -void PatternElementList::boundNames(QStringList *names) +void PatternElementList::boundNames(BoundNames *names) { for (PatternElementList *it = this; it; it = it->next) { if (it->element) @@ -1381,29 +1408,30 @@ void PatternProperty::accept0(Visitor *visitor) if (visitor->visit(this)) { accept(name, visitor); accept(bindingTarget, visitor); + accept(typeAnnotation, visitor); accept(initializer, visitor); } visitor->endVisit(this); } -void PatternProperty::boundNames(QStringList *names) +void PatternProperty::boundNames(BoundNames *names) { PatternElement::boundNames(names); } void PatternPropertyList::accept0(Visitor *visitor) { - if (visitor->visit(this)) { - accept(property, visitor); - if (next) - accept(next, visitor); + bool accepted = true; + for (PatternPropertyList *it = this; it && accepted; it = it->next) { + accepted = visitor->visit(it); + if (accepted) + accept(it->property, visitor); + visitor->endVisit(it); } - - visitor->endVisit(this); } -void PatternPropertyList::boundNames(QStringList *names) +void PatternPropertyList::boundNames(BoundNames *names) { for (PatternPropertyList *it = this; it; it = it->next) it->property->boundNames(names); @@ -1445,13 +1473,14 @@ void ClassDeclaration::accept0(Visitor *visitor) void ClassElementList::accept0(Visitor *visitor) { - if (visitor->visit(this)) { - accept(property, visitor); - if (next) - accept(next, visitor); - } + bool accepted = true; + for (ClassElementList *it = this; it && accepted; it = it->next) { + accepted = visitor->visit(it); + if (accepted) + accept(it->property, visitor); - visitor->endVisit(this); + visitor->endVisit(it); + } } ClassElementList *ClassElementList::finish() @@ -1471,6 +1500,37 @@ LeftHandSideExpression *LeftHandSideExpression::leftHandSideExpressionCast() return this; } +void UiVersionSpecifier::accept0(Visitor *visitor) +{ + if (visitor->visit(this)) { + } + visitor->endVisit(this); +} + +QString Type::toString() const +{ + QString result; + toString(&result); + return result; +} + +void Type::toString(QString *out) const +{ + for (QmlJS::AST::UiQualifiedId *it = typeId; it; it = it->next) { + out->append(it->name); + + if (it->next) + out->append(QLatin1Char('.')); + } + + if (typeArguments) { + out->append(QLatin1Char('<')); + if (auto subType = static_cast(typeArguments)->typeId) + subType->toString(out); + out->append(QLatin1Char('>')); + }; +} + } } // namespace QmlJS::AST QT_QML_END_NAMESPACE diff --git a/src/libs/qmljs/parser/qmljsast_p.h b/src/libs/qmljs/parser/qmljsast_p.h index 048c27d4707..aa9aea87784 100644 --- a/src/libs/qmljs/parser/qmljsast_p.h +++ b/src/libs/qmljs/parser/qmljsast_p.h @@ -218,7 +218,9 @@ public: Kind_PatternElementList, Kind_PatternProperty, Kind_PatternPropertyList, - + Kind_Type, + Kind_TypeArgumentList, + Kind_TypeAnnotation, Kind_UiArrayBinding, Kind_UiImport, @@ -236,7 +238,8 @@ public: Kind_UiSourceElement, Kind_UiHeaderItemList, Kind_UiEnumDeclaration, - Kind_UiEnumMemberList + Kind_UiEnumMemberList, + Kind_UiVersionSpecifier }; inline Node() {} @@ -256,11 +259,35 @@ public: virtual FunctionExpression *asFunctionDefinition(); virtual ClassExpression *asClassDefinition(); - void accept(Visitor *visitor); - static void accept(Node *node, Visitor *visitor); + bool ignoreRecursionDepth() const; + inline void accept(Visitor *visitor) + { + Visitor::RecursionDepthCheck recursionCheck(visitor); + + // Stack overflow is uncommon, ignoreRecursionDepth() only returns true if + // QV4_CRASH_ON_STACKOVERFLOW is set, and ignoreRecursionDepth() needs to be out of line. + // Therefore, check for ignoreRecursionDepth() _after_ calling the inline recursionCheck(). + if (recursionCheck() || ignoreRecursionDepth()) { + if (visitor->preVisit(this)) + accept0(visitor); + visitor->postVisit(this); + } else { + visitor->throwRecursionDepthError(); + } + } + + inline static void accept(Node *node, Visitor *visitor) + { + if (node) + node->accept(visitor); + } + + // ### Remove when we can. This is part of the qmldevtools library, though. inline static void acceptChild(Node *node, Visitor *visitor) - { return accept(node, visitor); } // ### remove + { + return accept(node, visitor); + } virtual void accept0(Visitor *visitor) = 0; virtual SourceLocation firstSourceLocation() const = 0; @@ -270,6 +297,139 @@ public: int kind = Kind_Undefined; }; +template +T lastListElement(T head) +{ + auto current = head; + while (current->next) + current = current->next; + return current; +} + +class QML_PARSER_EXPORT UiQualifiedId: public Node +{ +public: + QMLJS_DECLARE_AST_NODE(UiQualifiedId) + + UiQualifiedId(const QStringRef &name) + : next(this), name(name) + { kind = K; } + + UiQualifiedId(UiQualifiedId *previous, const QStringRef &name) + : name(name) + { + kind = K; + next = previous->next; + previous->next = this; + } + + UiQualifiedId *finish() + { + UiQualifiedId *head = next; + next = nullptr; + return head; + } + + void accept0(Visitor *visitor) override; + + SourceLocation firstSourceLocation() const override + { return identifierToken; } + + SourceLocation lastSourceLocation() const override + { return lastListElement(this)->identifierToken; } + +// attributes + UiQualifiedId *next; + QStringRef name; + SourceLocation identifierToken; +}; + +class QML_PARSER_EXPORT Type: public Node +{ +public: + QMLJS_DECLARE_AST_NODE(Type) + + Type(UiQualifiedId *typeId, Node *typeArguments = nullptr) + : typeId(typeId) + , typeArguments(typeArguments) + { kind = K; } + + void accept0(Visitor *visitor) override; + + SourceLocation firstSourceLocation() const override + { return typeId->firstSourceLocation(); } + + SourceLocation lastSourceLocation() const override + { return typeArguments ? typeArguments->lastSourceLocation() : typeId->lastSourceLocation(); } + + QString toString() const; + void toString(QString *out) const; + +// attributes + UiQualifiedId *typeId; + Node *typeArguments; // TypeArgumentList +}; + + +class QML_PARSER_EXPORT TypeArgumentList: public Node +{ +public: + QMLJS_DECLARE_AST_NODE(TypeArgumentList) + + TypeArgumentList(Type *typeId) + : typeId(typeId) + , next(nullptr) + { kind = K; } + + TypeArgumentList(TypeArgumentList *previous, Type *typeId) + : typeId(typeId) + { + kind = K; + next = previous->next; + previous->next = this; + } + + void accept0(Visitor *visitor) override; + + SourceLocation firstSourceLocation() const override + { return typeId->firstSourceLocation(); } + + SourceLocation lastSourceLocation() const override + { return lastListElement(this)->typeId->lastSourceLocation(); } + + inline TypeArgumentList *finish() + { + TypeArgumentList *front = next; + next = nullptr; + return front; + } + +// attributes + Type *typeId; + TypeArgumentList *next; +}; + +class QML_PARSER_EXPORT TypeAnnotation: public Node +{ +public: + QMLJS_DECLARE_AST_NODE(TypeAnnotation) + + TypeAnnotation(Type *type) + : type(type) + { kind = K; } + + void accept0(Visitor *visitor) override; + + SourceLocation firstSourceLocation() const override + { return colonToken; } + + SourceLocation lastSourceLocation() const override + { return type->lastSourceLocation(); } + +// attributes + Type *type; + SourceLocation colonToken; +}; class QML_PARSER_EXPORT ExpressionNode: public Node { public: @@ -459,7 +619,30 @@ public: SourceLocation literalToken; }; -class QML_PARSER_EXPORT StringLiteral: public LeftHandSideExpression +class QML_PARSER_EXPORT UiVersionSpecifier : public Node +{ +public: + QMLJS_DECLARE_AST_NODE(UiVersionSpecifier) + + UiVersionSpecifier(int majorum, int minorum) : majorVersion(majorum), minorVersion(minorum) { kind = K; } + + void accept0(Visitor *visitor) override; + + SourceLocation firstSourceLocation() const override { return majorToken; } + + SourceLocation lastSourceLocation() const override + { + return minorToken.isValid() ? minorToken : majorToken; + } + + // attributes: + int majorVersion; + int minorVersion; + SourceLocation majorToken; + SourceLocation minorToken; +}; + +class QML_PARSER_EXPORT StringLiteral : public LeftHandSideExpression { public: QMLJS_DECLARE_AST_NODE(StringLiteral) @@ -485,19 +668,23 @@ class QML_PARSER_EXPORT TemplateLiteral : public LeftHandSideExpression public: QMLJS_DECLARE_AST_NODE(TemplateLiteral) - TemplateLiteral(const QStringRef &str, ExpressionNode *e) - : value(str), expression(e), next(nullptr) + TemplateLiteral(const QStringRef &str, const QStringRef &raw, ExpressionNode *e) + : value(str), rawValue(raw), expression(e), next(nullptr) { kind = K; } SourceLocation firstSourceLocation() const override { return literalToken; } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : (expression ? expression->lastSourceLocation() : literalToken); } + { + auto last = lastListElement(this); + return (last->expression ? last->expression->lastSourceLocation() : last->literalToken); + } void accept0(Visitor *visitor) override; QStringRef value; + QStringRef rawValue; ExpressionNode *expression; TemplateLiteral *next; SourceLocation literalToken; @@ -614,7 +801,7 @@ public: { return commaToken; } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : commaToken; } + { return lastListElement(this)->commaToken; } inline Elision *finish () { @@ -647,6 +834,34 @@ public: SourceLocation propertyNameToken; }; +struct QML_PARSER_EXPORT BoundName +{ + QString id; + TypeAnnotation *typeAnnotation = nullptr; + BoundName(const QString &id, TypeAnnotation *typeAnnotation) + : id(id), typeAnnotation(typeAnnotation) + {} + BoundName() = default; + QString typeName() const { return typeAnnotation ? typeAnnotation->type->toString() : QString(); } +}; + +struct BoundNames : public QVector +{ + int indexOf(const QString &name, int from = 0) const + { + auto found = std::find_if(constBegin() + from, constEnd(), + [name](const BoundName &it) { return it.id == name; }); + if (found == constEnd()) + return -1; + return found - constBegin(); + } + + bool contains(const QString &name) const + { + return indexOf(name) != -1; + } +}; + class QML_PARSER_EXPORT PatternElement : public Node { public: @@ -655,6 +870,7 @@ public: enum Type { // object literal types Literal, + Method, Getter, Setter, @@ -670,8 +886,9 @@ public: : initializer(i), type(t) { kind = K; } - PatternElement(const QStringRef &n, ExpressionNode *i = nullptr, Type t = Binding) + PatternElement(const QStringRef &n, TypeAnnotation *typeAnnotation = nullptr, ExpressionNode *i = nullptr, Type t = Binding) : bindingIdentifier(n), initializer(i), type(t) + , typeAnnotation(typeAnnotation) { Q_ASSERT(t >= RestElement); kind = K; @@ -691,7 +908,7 @@ public: { return identifierToken.isValid() ? identifierToken : (bindingTarget ? bindingTarget->firstSourceLocation() : initializer->firstSourceLocation()); } SourceLocation lastSourceLocation() const override - { return initializer ? initializer->lastSourceLocation() : (bindingTarget ? bindingTarget->lastSourceLocation() : identifierToken); } + { return initializer ? initializer->lastSourceLocation() : (bindingTarget ? bindingTarget->lastSourceLocation() : (typeAnnotation ? typeAnnotation->lastSourceLocation() : identifierToken)); } ExpressionNode *destructuringTarget() const { return bindingTarget; } Pattern *destructuringPattern() const { return bindingTarget ? bindingTarget->patternCast() : nullptr; } @@ -701,7 +918,7 @@ public: bool isVariableDeclaration() const { return scope != VariableScope::NoScope; } bool isLexicallyScoped() const { return scope == VariableScope::Let || scope == VariableScope::Const; } - virtual void boundNames(QStringList *names); + virtual void boundNames(BoundNames *names); // attributes SourceLocation identifierToken; @@ -709,6 +926,7 @@ public: ExpressionNode *bindingTarget = nullptr; ExpressionNode *initializer = nullptr; Type type = Literal; + TypeAnnotation *typeAnnotation = nullptr; // when used in a VariableDeclarationList VariableScope scope = VariableScope::NoScope; bool isForDeclaration = false; @@ -738,13 +956,16 @@ public: void accept0(Visitor *visitor) override; - void boundNames(QStringList *names); + void boundNames(BoundNames *names); SourceLocation firstSourceLocation() const override { return elision ? elision->firstSourceLocation() : element->firstSourceLocation(); } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : (element ? element->lastSourceLocation() : elision->lastSourceLocation()); } + { + auto last = lastListElement(this); + return last->element ? last->element->lastSourceLocation() : last->elision->lastSourceLocation(); + } Elision *elision = nullptr; PatternElement *element = nullptr; @@ -761,7 +982,7 @@ public: { kind = K; } PatternProperty(PropertyName *name, const QStringRef &n, ExpressionNode *i = nullptr) - : PatternElement(n, i), name(name) + : PatternElement(n, /*type annotation*/nullptr, i), name(name) { kind = K; } PatternProperty(PropertyName *name, Pattern *pattern, ExpressionNode *i = nullptr) @@ -778,7 +999,7 @@ public: return loc.isValid() ? loc : name->lastSourceLocation(); } - void boundNames(QStringList *names) override; + void boundNames(BoundNames *names) override; bool convertLiteralToAssignmentPattern(MemoryPool *pool, SourceLocation *errorLocation, QString *errorMessage) override; // attributes @@ -806,7 +1027,7 @@ public: void accept0(Visitor *visitor) override; - void boundNames(QStringList *names); + void boundNames(BoundNames *names); inline PatternPropertyList *finish () { @@ -819,7 +1040,7 @@ public: { return property->firstSourceLocation(); } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : property->lastSourceLocation(); } + { return lastListElement(this)->property->lastSourceLocation(); } PatternProperty *property; PatternPropertyList *next; @@ -1428,7 +1649,9 @@ public: { return statement->firstSourceLocation(); } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : statement->lastSourceLocation(); } + { + return lastListElement(this)->statement->lastSourceLocation(); + } inline StatementList *finish () { @@ -1543,7 +1766,7 @@ public: { return expression->firstSourceLocation(); } SourceLocation lastSourceLocation() const override - { return semicolonToken.isValid() ? semicolonToken : expression->lastSourceLocation(); } + { return expression->lastSourceLocation(); } // attributes ExpressionNode *expression; @@ -1921,7 +2144,9 @@ public: { return clause->firstSourceLocation(); } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : clause->lastSourceLocation(); } + { + return lastListElement(this)->clause->lastSourceLocation(); + } inline CaseClauses *finish () { @@ -2096,8 +2321,9 @@ class QML_PARSER_EXPORT FunctionExpression: public ExpressionNode public: QMLJS_DECLARE_AST_NODE(FunctionExpression) - FunctionExpression(const QStringRef &n, FormalParameterList *f, StatementList *b): - name (n), formals (f), body (b) + FunctionExpression(const QStringRef &n, FormalParameterList *f, StatementList *b, TypeAnnotation *typeAnnotation = nullptr): + name (n), formals (f), body (b), + typeAnnotation(typeAnnotation) { kind = K; } void accept0(Visitor *visitor) override; @@ -2116,6 +2342,7 @@ public: bool isGenerator = false; FormalParameterList *formals; StatementList *body; + TypeAnnotation *typeAnnotation; SourceLocation functionToken; SourceLocation identifierToken; SourceLocation lparenToken; @@ -2129,8 +2356,8 @@ class QML_PARSER_EXPORT FunctionDeclaration: public FunctionExpression public: QMLJS_DECLARE_AST_NODE(FunctionDeclaration) - FunctionDeclaration(const QStringRef &n, FormalParameterList *f, StatementList *b): - FunctionExpression(n, f, b) + FunctionDeclaration(const QStringRef &n, FormalParameterList *f, StatementList *b, TypeAnnotation *typeAnnotation = nullptr): + FunctionExpression(n, f, b, typeAnnotation) { kind = K; } void accept0(Visitor *visitor) override; @@ -2200,9 +2427,9 @@ public: return false; } - QStringList formals() const; + BoundNames formals() const; - QStringList boundNames() const; + BoundNames boundNames() const; void accept0(Visitor *visitor) override; @@ -2210,7 +2437,9 @@ public: { return element->firstSourceLocation(); } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : element->lastSourceLocation(); } + { + return lastListElement(this)->element->lastSourceLocation(); + } FormalParameterList *finish(MemoryPool *pool); @@ -2387,7 +2616,9 @@ public: { return importSpecifierToken; } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : importSpecifierToken; } + { + return lastListElement(this)->importSpecifierToken; + } // attributes SourceLocation importSpecifierToken; @@ -2624,7 +2855,7 @@ public: SourceLocation firstSourceLocation() const override { return exportSpecifier->firstSourceLocation(); } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : exportSpecifier->lastSourceLocation(); } + { return lastListElement(this)->exportSpecifier->lastSourceLocation(); } // attributes ExportSpecifier *exportSpecifier; @@ -2751,44 +2982,6 @@ public: SourceLocation semicolonToken; }; -class QML_PARSER_EXPORT UiQualifiedId: public Node -{ -public: - QMLJS_DECLARE_AST_NODE(UiQualifiedId) - - UiQualifiedId(const QStringRef &name) - : next(this), name(name) - { kind = K; } - - UiQualifiedId(UiQualifiedId *previous, const QStringRef &name) - : name(name) - { - kind = K; - next = previous->next; - previous->next = this; - } - - UiQualifiedId *finish() - { - UiQualifiedId *head = next; - next = nullptr; - return head; - } - - void accept0(Visitor *visitor) override; - - SourceLocation firstSourceLocation() const override - { return identifierToken; } - - SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : identifierToken; } - -// attributes - UiQualifiedId *next; - QStringRef name; - SourceLocation identifierToken; -}; - class QML_PARSER_EXPORT UiImport: public Node { public: @@ -2820,6 +3013,7 @@ public: SourceLocation asToken; SourceLocation importIdToken; SourceLocation semicolonToken; + UiVersionSpecifier *version = nullptr; }; class QML_PARSER_EXPORT UiObjectMember: public Node @@ -2854,7 +3048,7 @@ public: { return member->firstSourceLocation(); } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : member->lastSourceLocation(); } + { return lastListElement(this)->member->lastSourceLocation(); } UiObjectMemberList *finish() { @@ -2933,7 +3127,7 @@ public: { return headerItem->firstSourceLocation(); } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : headerItem->lastSourceLocation(); } + { return lastListElement(this)->headerItem->lastSourceLocation(); } // attributes Node *headerItem; @@ -2997,7 +3191,7 @@ public: { return member->firstSourceLocation(); } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : member->lastSourceLocation(); } + { return lastListElement(this)->member->lastSourceLocation(); } UiArrayMemberList *finish() { @@ -3055,10 +3249,13 @@ public: void accept0(Visitor *) override; SourceLocation firstSourceLocation() const override - { return propertyTypeToken; } + { return colonToken.isValid() ? identifierToken : propertyTypeToken; } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : identifierToken; } + { + auto last = lastListElement(this); + return (last->colonToken.isValid() ? last->propertyTypeToken : last->identifierToken); + } inline UiParameterList *finish () { @@ -3074,6 +3271,7 @@ public: SourceLocation commaToken; SourceLocation propertyTypeToken; SourceLocation identifierToken; + SourceLocation colonToken; }; class QML_PARSER_EXPORT UiPublicMember: public UiObjectMember @@ -3100,6 +3298,8 @@ public: return defaultToken; else if (readonlyToken.isValid()) return readonlyToken; + else if (requiredToken.isValid()) + return requiredToken; return propertyToken; } @@ -3123,10 +3323,13 @@ public: UiObjectMember *binding; // initialized with a QML object or array. bool isDefaultMember; bool isReadonlyMember; + bool isRequired = false; UiParameterList *parameters; + // TODO: merge source locations SourceLocation defaultToken; SourceLocation readonlyToken; SourceLocation propertyToken; + SourceLocation requiredToken; SourceLocation typeModifierToken; SourceLocation typeToken; SourceLocation identifierToken; @@ -3168,7 +3371,7 @@ public: SourceLocation firstSourceLocation() const override { - if (FunctionDeclaration *funDecl = cast(sourceElement)) + if (FunctionExpression *funDecl = sourceElement->asFunctionDefinition()) return funDecl->firstSourceLocation(); else if (VariableStatement *varStmt = cast(sourceElement)) return varStmt->firstSourceLocation(); @@ -3178,7 +3381,7 @@ public: SourceLocation lastSourceLocation() const override { - if (FunctionDeclaration *funDecl = cast(sourceElement)) + if (FunctionExpression *funDecl = sourceElement->asFunctionDefinition()) return funDecl->lastSourceLocation(); else if (VariableStatement *varStmt = cast(sourceElement)) return varStmt->lastSourceLocation(); @@ -3310,8 +3513,10 @@ public: { return memberToken; } SourceLocation lastSourceLocation() const override - { return next ? next->lastSourceLocation() : - valueToken.isValid() ? valueToken : memberToken; } + { + auto last = lastListElement(this); + return last->valueToken.isValid() ? last->valueToken : last->memberToken; + } void accept0(Visitor *visitor) override; diff --git a/src/libs/qmljs/parser/qmljsastfwd_p.h b/src/libs/qmljs/parser/qmljsastfwd_p.h index cfe97485c3e..86d04ad25dc 100644 --- a/src/libs/qmljs/parser/qmljsastfwd_p.h +++ b/src/libs/qmljs/parser/qmljsastfwd_p.h @@ -163,6 +163,9 @@ class NestedExpression; class ClassExpression; class ClassDeclaration; class ClassElementList; +class TypeArgumentList; +class Type; +class TypeAnnotation; // ui elements class UiProgram; @@ -183,6 +186,7 @@ class UiQualifiedId; class UiHeaderItemList; class UiEnumDeclaration; class UiEnumMemberList; +class UiVersionSpecifier; } } // namespace AST diff --git a/src/libs/qmljs/parser/qmljsastvisitor.cpp b/src/libs/qmljs/parser/qmljsastvisitor.cpp index 6615af238f7..c5028337efb 100644 --- a/src/libs/qmljs/parser/qmljsastvisitor.cpp +++ b/src/libs/qmljs/parser/qmljsastvisitor.cpp @@ -29,7 +29,7 @@ QT_QML_BEGIN_NAMESPACE namespace QmlJS { namespace AST { -Visitor::Visitor() +Visitor::Visitor(quint16 parentRecursionDepth) : m_recursionDepth(parentRecursionDepth) { } diff --git a/src/libs/qmljs/parser/qmljsastvisitor_p.h b/src/libs/qmljs/parser/qmljsastvisitor_p.h index 940e2e77516..1bb88082463 100644 --- a/src/libs/qmljs/parser/qmljsastvisitor_p.h +++ b/src/libs/qmljs/parser/qmljsastvisitor_p.h @@ -46,7 +46,33 @@ namespace QmlJS { namespace AST { class QML_PARSER_EXPORT Visitor { public: - Visitor(); + class RecursionDepthCheck + { + Q_DISABLE_COPY(RecursionDepthCheck) + public: + RecursionDepthCheck(RecursionDepthCheck &&) = delete; + RecursionDepthCheck &operator=(RecursionDepthCheck &&) = delete; + + RecursionDepthCheck(Visitor *visitor) : m_visitor(visitor) + { + ++(m_visitor->m_recursionDepth); + } + + ~RecursionDepthCheck() + { + --(m_visitor->m_recursionDepth); + } + + bool operator()() const { + return m_visitor->m_recursionDepth < s_recursionLimit; + } + + private: + static const quint16 s_recursionLimit = 4096; + Visitor *m_visitor; + }; + + Visitor(quint16 parentRecursionDepth = 0); virtual ~Visitor(); virtual bool preVisit(Node *) { return true; } @@ -70,6 +96,7 @@ public: virtual bool visit(UiQualifiedId *) { return true; } virtual bool visit(UiEnumDeclaration *) { return true; } virtual bool visit(UiEnumMemberList *) { return true; } + virtual bool visit(UiVersionSpecifier *) { return true; } virtual void endVisit(UiProgram *) {} virtual void endVisit(UiImport *) {} @@ -88,6 +115,7 @@ public: virtual void endVisit(UiQualifiedId *) {} virtual void endVisit(UiEnumDeclaration *) {} virtual void endVisit(UiEnumMemberList *) { } + virtual void endVisit(UiVersionSpecifier *) {} // QmlJS virtual bool visit(ThisExpression *) { return true; } @@ -359,6 +387,23 @@ public: virtual bool visit(DebuggerStatement *) { return true; } virtual void endVisit(DebuggerStatement *) {} + + virtual bool visit(Type *) { return true; } + virtual void endVisit(Type *) {} + + virtual bool visit(TypeArgumentList *) { return true; } + virtual void endVisit(TypeArgumentList *) {} + + virtual bool visit(TypeAnnotation *) { return true; } + virtual void endVisit(TypeAnnotation *) {} + + virtual void throwRecursionDepthError() {} + + quint16 recursionDepth() const { return m_recursionDepth; } + +protected: + quint16 m_recursionDepth = 0; + friend class RecursionDepthCheck; }; } } // namespace AST diff --git a/src/libs/qmljs/parser/qmljsgrammar.cpp b/src/libs/qmljs/parser/qmljsgrammar.cpp index 3c5387f6b75..e0fdfd0103c 100644 --- a/src/libs/qmljs/parser/qmljsgrammar.cpp +++ b/src/libs/qmljs/parser/qmljsgrammar.cpp @@ -34,1314 +34,1275 @@ QT_BEGIN_NAMESPACE const char *const QmlJSGrammar::spell [] = { "end of file", "&", "&&", "&=", "break", "case", "catch", ":", ",", "continue", "default", "delete", "/", "/=", "do", ".", "else", "=", "==", "===", - "finally", "for", "function", ">=", ">", ">>", ">>=", ">>>", ">>>=", "identifier", - "if", "in", "instanceof", "{", "[", "<=", "(", "<", "<<", "<<=", - "-", "-=", "--", "new", "!", "!=", "!==", "numeric literal", "|", "|=", - "||", "+", "+=", "++", "?", "}", "]", "%", "%=", "return", - ")", ";", 0, "*", "**", "**=", "*=", "string literal", "property", "signal", - "readonly", "switch", "this", "throw", "~", "try", "typeof", "var", "void", "while", - "with", "^", "^=", "null", "true", "false", "const", "let", "debugger", "reserved word", - "multiline string literal", "comment", 0, "=>", "enum", "...", "yield", "super", "class", "extends", - "static", "export", "from", "(no subst template)", "(template head)", "(template middle)", "(template tail)", "public", "import", "pragma", - "as", "of", "get", "set", 0, 0, 0, 0, 0, 0, - 0, "(force decl)", "(force block)", "(for lookahead ok)", 0, 0, -#ifndef QLALR_NO_QMLJSGRAMMAR_DEBUG_INFO -"TopLevel", "UiProgram", "Statement", "Expression", - "UiObjectMember", "Script", "Module", "UiHeaderItemListOpt", "UiRootMember", "Empty", "UiHeaderItemList", "UiPragma", "UiImport", "PragmaId", - "JsIdentifier", "ImportId", "MemberExpression", "UiImportHead", "QmlIdentifier", "UiObjectDefinition", "UiObjectMemberList", "UiArrayMemberList", "UiObjectInitializer", "UiQualifiedId", - "ExpressionStatementLookahead", "UiObjectLiteral", "UiPropertyDefinitionList", "UiScriptStatement", "ExpressionStatement", "Block", "EmptyStatement", "IfStatement", "WithStatement", "SwitchStatement", - "TryStatement", "UiPropertyType", "UiParameterListOpt", "UiParameterList", "FunctionDeclaration", "VariableStatement", "EnumMemberList", "IdentifierReference", "BindingIdentifier", "PrimaryExpression", - "Literal", "ArrayLiteral", "ObjectLiteral", "FunctionExpression", "ClassExpression", "GeneratorExpression", "RegularExpressionLiteral", "TemplateLiteral", "CoverParenthesizedExpressionAndArrowParameterList", "Expression_In", - "BindingRestElement", "BindingRestElementOpt", "ElisionOpt", "ElementList", "AssignmentExpression_In", "Elision", "SpreadElement", "AssignmentExpression", "PropertyDefinitionList", "UiPropertyDefinition", - "PropertyDefinition", "CoverInitializedName", "Initializer_In", "UiPropertyName", "PropertyName", "MethodDefinition", "LiteralPropertyName", "ComputedPropertyName", "IdentifierName", "ReservedIdentifier", - "Initializer", "InitializerOpt", "InitializerOpt_In", "TemplateSpans", "Super", "NewTarget", "MetaProperty", "Arguments", "NewExpression", "CallExpression", - "ArgumentList", "LeftHandSideExpression", "UpdateExpression", "UnaryExpression", "ExponentiationExpression", "MultiplicativeExpression", "MultiplicativeOperator", "AdditiveExpression", "ShiftExpression", "RelationalExpression_In", - "RelationalExpression", "RelationalOperator", "EqualityExpression_In", "EqualityExpression", "EqualityOperator", "BitwiseANDExpression", "BitwiseANDExpression_In", "BitwiseXORExpression", "BitwiseXORExpression_In", "BitwiseORExpression", - "BitwiseORExpression_In", "LogicalANDExpression", "LogicalANDExpression_In", "LogicalORExpression", "LogicalORExpression_In", "ConditionalExpression", "ConditionalExpression_In", "YieldExpression", "YieldExpression_In", "ArrowFunction", - "ArrowFunction_In", "AssignmentOperator", "ExpressionOpt", "ExpressionOpt_In", "BlockStatement", "BreakableStatement", "ContinueStatement", "BreakStatement", "ReturnStatement", "LabelledStatement", - "ThrowStatement", "DebuggerStatement", "Declaration", "HoistableDeclaration", "ClassDeclaration", "LexicalDeclaration_In", "GeneratorDeclaration", "HoistableDeclaration_Default", "FunctionDeclaration_Default", "GeneratorDeclaration_Default", - "IterationStatement", "StatementListOpt", "StatementList", "StatementListItem", "LetOrConst", "Var", "LexicalDeclaration", "BindingList", "BindingList_In", "VarDeclaration", - "VariableDeclarationList", "VarDeclaration_In", "VariableDeclarationList_In", "LexicalBinding_In", "VariableDeclaration", "VariableDeclaration_In", "LexicalBinding", "BindingPattern", "ObjectBindingPattern", "ArrayBindingPattern", - "BindingPropertyList", "BindingElementList", "BindingProperty", "BindingElisionElement", "BindingElement", "InOrOf", "ForDeclaration", "CaseBlock", "CaseClausesOpt", "DefaultClause", - "CaseClauses", "CaseClause", "LabelledItem", "Catch", "Finally", "CatchParameter", "Function", "FormalParameters", "FunctionLBrace", "FunctionBody", - "FunctionRBrace", "StrictFormalParameters", "FormalParameterList", "FormalParameter", "ArrowParameters", "ConciseBodyLookahead", "GeneratorLParen", "GeneratorBody", "GeneratorRBrace", "PropertySetParameterList", - "ClassHeritageOpt", "ClassLBrace", "ClassBodyOpt", "ClassRBrace", "ClassDeclaration_Default", "ClassStaticQualifier", "ClassElementList", "ClassElement", "ScriptBody", "ModuleBodyOpt", - "ModuleBody", "ModuleItemList", "ModuleItem", "ImportDeclaration", "ExportDeclaration", "ImportClause", "FromClause", "ModuleSpecifier", "ImportedDefaultBinding", "NameSpaceImport", - "NamedImports", "ImportedBinding", "ImportsList", "ImportSpecifier", "ExportDeclarationLookahead", "ExportClause", "ExportsList", "ExportSpecifier", "$accept" -#endif // QLALR_NO_QMLJSGRAMMAR_DEBUG_INFO - + "finally", "for", "function *", "function", ">=", ">", ">>", ">>=", ">>>", ">>>=", + "identifier", "if", "in", "instanceof", "{", "[", "<=", "(", "<", "<<", + "<<=", "-", "-=", "--", "new", "!", "!=", "!==", "numeric literal", "|", + "version number", "|=", "||", "+", "+=", "++", "?", "}", "]", "%", + "%=", "return", ")", ";", 0, "*", "**", "**=", "*=", "string literal", + "property", "signal", "readonly", "switch", "this", "throw", "~", "try", "typeof", "var", + "void", "while", "with", "^", "^=", "null", "true", "false", "const", "let", + "debugger", "reserved word", "multiline string literal", "comment", 0, "=>", "enum", "...", "yield", "super", + "class", "extends", "static", "export", "from", "required", "(no subst template)", "(template head)", "(template middle)", "(template tail)", + "public", "import", "pragma", "as", "of", "get", "set", 0, 0, 0, + 0, 0, 0, 0, "(force decl)", "(force block)", "(for lookahead ok)", 0, 0, 0 }; const short QmlJSGrammar::lhs [] = { - 126, 126, 126, 126, 126, 126, 127, 133, 133, 136, - 136, 136, 136, 139, 137, 137, 141, 138, 138, 138, - 138, 138, 138, 138, 138, 143, 135, 134, 146, 146, - 147, 147, 148, 148, 145, 130, 130, 130, 130, 151, - 151, 153, 153, 153, 153, 153, 153, 153, 153, 153, - 130, 161, 161, 161, 161, 162, 162, 163, 163, 130, - 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, - 130, 130, 130, 130, 130, 130, 130, 130, 130, 149, - 130, 166, 166, 166, 166, 144, 144, 144, 144, 144, - 144, 144, 144, 144, 140, 140, 140, 140, 140, 140, - 140, 140, 140, 140, 140, 167, 168, 169, 169, 169, - 169, 169, 169, 169, 169, 169, 169, 169, 178, 178, - 178, 178, 170, 170, 170, 170, 170, 170, 176, 176, - 171, 171, 171, 183, 183, 183, 183, 183, 185, 185, - 182, 182, 186, 172, 172, 172, 152, 188, 152, 188, - 190, 190, 191, 189, 190, 190, 194, 194, 196, 193, - 196, 193, 196, 198, 198, 199, 199, 199, 199, 199, - 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, - 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, - 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, - 199, 199, 199, 197, 200, 192, 201, 202, 201, 202, - 177, 203, 203, 177, 142, 204, 142, 142, 205, 142, - 142, 142, 142, 206, 208, 208, 209, 142, 209, 209, - 209, 209, 209, 207, 207, 207, 210, 210, 210, 210, - 211, 211, 212, 212, 212, 212, 212, 213, 213, 213, - 213, 213, 213, 213, 213, 214, 214, 215, 215, 216, - 216, 216, 217, 217, 217, 218, 218, 218, 218, 219, - 220, 219, 220, 221, 221, 221, 221, 221, 219, 222, - 223, 222, 223, 224, 224, 224, 224, 225, 226, 225, - 226, 227, 228, 227, 228, 229, 230, 229, 230, 231, - 232, 231, 232, 233, 234, 233, 234, 235, 236, 235, - 236, 187, 184, 187, 184, 187, 184, 187, 184, 187, - 184, 241, 241, 241, 241, 241, 241, 241, 241, 241, - 241, 241, 241, 129, 179, 129, 179, 242, 243, 242, - 243, 128, 128, 128, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 252, 252, 252, 253, 253, - 257, 257, 245, 245, 244, 155, 262, 262, 263, 263, - 263, 261, 261, 264, 264, 265, 266, 255, 269, 271, - 165, 165, 267, 268, 270, 272, 267, 268, 270, 272, - 276, 273, 274, 275, 276, 273, 274, 275, 277, 277, - 278, 278, 278, 279, 279, 279, 280, 280, 281, 281, - 283, 282, 282, 282, 284, 284, 180, 180, 181, 181, - 156, 150, 154, 154, 157, 157, 260, 260, 260, 260, - 260, 260, 260, 285, 285, 260, 260, 286, 286, 286, - 286, 246, 246, 246, 246, 247, 247, 247, 247, 248, - 248, 158, 159, 287, 287, 290, 290, 288, 288, 291, - 289, 249, 292, 292, 250, 250, 160, 160, 160, 293, - 294, 295, 295, 251, 251, 296, 164, 258, 258, 173, - 173, 301, 297, 297, 297, 297, 297, 302, 302, 303, - 298, 300, 299, 239, 240, 239, 240, 304, 304, 305, - 195, 195, 195, 195, 309, 306, 308, 256, 259, 259, - 175, 175, 307, 237, 238, 237, 238, 237, 238, 254, - 174, 314, 174, 314, 311, 313, 315, 310, 310, 312, - 312, 316, 316, 317, 317, 317, 131, 131, 318, 132, - 320, 319, 319, 321, 321, 322, 322, 322, 322, 322, - 323, 323, 325, 325, 325, 325, 325, 328, 329, 330, - 330, 330, 326, 332, 332, 333, 333, 327, 331, 334, - 324, 324, 324, 324, 324, 324, 324, 324, 335, 335, - 335, 336, 336, 337, 337, 338 + 130, 130, 130, 130, 130, 130, 131, 137, 137, 140, + 140, 140, 140, 143, 145, 145, 141, 146, 142, 149, + 149, 142, 142, 142, 148, 139, 138, 152, 152, 153, + 153, 154, 154, 151, 134, 134, 134, 134, 157, 157, + 159, 159, 159, 159, 159, 159, 159, 159, 159, 134, + 167, 167, 167, 167, 168, 168, 169, 169, 169, 169, + 134, 134, 170, 134, 134, 171, 134, 134, 134, 172, + 172, 134, 173, 134, 134, 134, 174, 134, 134, 175, + 134, 134, 134, 134, 134, 155, 134, 179, 179, 179, + 179, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 144, 144, 144, 144, 144, 144, 144, 144, 144, + 144, 144, 144, 180, 181, 182, 182, 183, 183, 183, + 184, 185, 185, 186, 186, 186, 186, 186, 186, 186, + 186, 186, 186, 186, 195, 195, 195, 195, 187, 187, + 187, 187, 187, 187, 193, 193, 188, 188, 188, 200, + 200, 200, 200, 200, 202, 202, 199, 199, 203, 189, + 189, 189, 158, 205, 158, 205, 207, 207, 208, 206, + 207, 207, 211, 211, 213, 210, 213, 210, 213, 215, + 215, 216, 216, 216, 216, 216, 216, 216, 216, 216, + 216, 216, 216, 216, 216, 216, 216, 216, 216, 216, + 216, 216, 216, 216, 216, 216, 216, 216, 216, 216, + 216, 216, 216, 216, 216, 216, 216, 216, 216, 214, + 217, 209, 218, 219, 218, 219, 194, 220, 220, 194, + 147, 221, 147, 147, 222, 147, 147, 147, 147, 223, + 225, 225, 226, 147, 226, 226, 226, 226, 226, 224, + 224, 224, 227, 227, 227, 227, 228, 228, 229, 229, + 229, 229, 229, 230, 230, 230, 230, 230, 230, 230, + 230, 231, 231, 232, 232, 233, 233, 233, 234, 234, + 234, 235, 235, 235, 235, 236, 237, 236, 237, 238, + 238, 238, 238, 238, 236, 239, 240, 239, 240, 241, + 241, 241, 241, 242, 243, 242, 243, 244, 245, 244, + 245, 246, 247, 246, 247, 248, 249, 248, 249, 250, + 251, 250, 251, 252, 253, 252, 253, 204, 201, 204, + 201, 204, 201, 204, 201, 204, 201, 258, 258, 258, + 258, 258, 258, 258, 258, 258, 258, 258, 258, 133, + 196, 133, 196, 259, 260, 259, 260, 132, 132, 132, + 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, + 132, 269, 269, 269, 270, 270, 274, 274, 262, 262, + 261, 161, 279, 279, 280, 280, 278, 278, 281, 281, + 282, 283, 272, 286, 288, 178, 284, 285, 287, 289, + 284, 285, 287, 289, 293, 290, 291, 292, 293, 290, + 291, 292, 294, 294, 295, 295, 295, 296, 296, 296, + 297, 297, 298, 298, 300, 299, 299, 299, 301, 301, + 197, 197, 198, 198, 162, 156, 160, 163, 163, 277, + 277, 277, 277, 277, 277, 302, 302, 277, 277, 303, + 303, 303, 303, 263, 263, 264, 264, 265, 164, 165, + 304, 304, 307, 307, 305, 305, 308, 306, 266, 309, + 309, 267, 166, 166, 166, 310, 311, 312, 312, 268, + 313, 273, 177, 275, 275, 190, 190, 318, 314, 314, + 314, 314, 314, 319, 319, 320, 315, 317, 316, 256, + 257, 256, 257, 321, 321, 322, 212, 212, 212, 212, + 326, 323, 325, 327, 176, 276, 276, 192, 192, 324, + 254, 255, 254, 255, 254, 255, 271, 191, 332, 191, + 332, 329, 331, 333, 328, 328, 330, 330, 334, 334, + 335, 335, 335, 135, 135, 336, 136, 338, 337, 337, + 339, 339, 340, 340, 340, 341, 341, 343, 343, 343, + 343, 343, 346, 347, 348, 348, 348, 344, 350, 350, + 351, 351, 345, 349, 352, 342, 342, 342, 342, 342, + 342, 342, 342, 353, 353, 353, 354, 354, 355, 355, + 356 }; const short QmlJSGrammar::rhs [] = { 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, - 1, 2, 2, 1, 3, 3, 1, 2, 2, 3, - 3, 5, 5, 4, 4, 2, 0, 1, 1, 2, - 1, 3, 2, 3, 2, 1, 6, 5, 4, 4, - 5, 3, 3, 3, 2, 2, 2, 2, 2, 2, - 3, 1, 1, 1, 3, 0, 1, 2, 4, 6, - 6, 3, 3, 7, 7, 4, 4, 5, 5, 8, - 8, 5, 6, 6, 10, 7, 8, 1, 1, 1, - 5, 1, 3, 3, 5, 1, 1, 1, 1, 1, + 1, 2, 2, 1, 1, 1, 3, 1, 2, 3, + 1, 3, 5, 4, 2, 0, 1, 1, 2, 1, + 3, 2, 3, 2, 1, 6, 5, 4, 4, 5, + 3, 3, 3, 2, 2, 2, 2, 2, 2, 3, + 1, 1, 1, 3, 0, 1, 3, 2, 5, 4, + 6, 3, 7, 1, 2, 4, 1, 2, 2, 0, + 1, 2, 6, 1, 2, 2, 11, 1, 2, 8, + 1, 2, 1, 1, 1, 1, 5, 1, 3, 3, + 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, - 3, 5, 1, 1, 1, 1, 1, 1, 1, 1, - 3, 3, 5, 1, 2, 2, 4, 4, 1, 2, - 0, 1, 2, 2, 3, 4, 1, 1, 3, 3, - 1, 1, 2, 3, 3, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 3, 2, 2, 0, 0, 1, 1, - 1, 1, 3, 3, 1, 1, 4, 4, 3, 3, - 3, 1, 5, 1, 1, 2, 2, 2, 4, 4, - 4, 4, 3, 0, 1, 2, 1, 2, 3, 4, - 1, 1, 1, 2, 2, 2, 2, 1, 2, 2, - 2, 2, 2, 2, 2, 1, 3, 1, 3, 1, - 1, 1, 1, 3, 3, 1, 3, 3, 3, 1, - 1, 3, 3, 1, 1, 1, 1, 1, 3, 1, - 1, 3, 3, 1, 1, 1, 1, 1, 1, 3, - 3, 1, 1, 3, 3, 1, 1, 3, 3, 1, - 1, 3, 3, 1, 1, 3, 3, 1, 1, 5, - 5, 1, 1, 1, 1, 1, 1, 3, 3, 3, + 1, 1, 1, 1, 1, 1, 3, 4, 1, 1, + 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 3, 2, 3, 5, 1, 1, + 1, 1, 1, 1, 1, 1, 3, 3, 5, 1, + 2, 2, 4, 4, 1, 2, 0, 1, 2, 2, + 3, 4, 1, 1, 3, 3, 1, 1, 2, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 3, 3, 0, 0, 1, - 1, 3, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 3, 1, 2, 1, 4, - 4, 1, 1, 1, 1, 1, 2, 2, 2, 2, - 2, 2, 1, 1, 1, 1, 3, 3, 3, 3, - 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, - 0, 1, 2, 2, 1, 4, 1, 3, 1, 3, - 2, 2, 4, 4, 2, 2, 2, 2, 0, 1, - 1, 0, 2, 2, 7, 5, 7, 7, 7, 5, - 9, 9, 9, 1, 1, 7, 7, 2, 2, 2, - 2, 2, 2, 3, 3, 2, 2, 3, 3, 3, - 3, 5, 5, 3, 5, 1, 2, 0, 1, 4, - 3, 3, 1, 3, 3, 3, 3, 3, 4, 5, - 2, 1, 1, 2, 2, 1, 8, 1, 7, 8, - 7, 1, 0, 1, 1, 2, 3, 1, 3, 1, - 1, 1, 1, 4, 4, 7, 7, 1, 1, 0, - 7, 8, 7, 8, 1, 1, 1, 9, 1, 8, - 9, 8, 1, 1, 1, 3, 3, 2, 2, 6, - 6, 5, 5, 1, 1, 1, 1, 0, 2, 0, - 1, 1, 2, 1, 2, 1, 0, 1, 1, 1, - 1, 0, 1, 1, 2, 2, 2, 2, 2, 1, - 3, 2, 1, 1, 1, 3, 3, 1, 3, 2, - 3, 4, 2, 1, 3, 1, 3, 1, 1, 0, - 3, 3, 2, 2, 2, 5, 5, 4, 2, 3, - 4, 1, 3, 1, 3, 2 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, + 2, 2, 0, 0, 1, 1, 1, 1, 3, 3, + 1, 1, 4, 4, 3, 3, 3, 1, 5, 1, + 1, 2, 2, 2, 4, 4, 4, 4, 3, 0, + 1, 2, 1, 2, 3, 4, 1, 1, 1, 2, + 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, + 2, 1, 3, 1, 3, 1, 1, 1, 1, 3, + 3, 1, 3, 3, 3, 1, 1, 3, 3, 1, + 1, 1, 1, 1, 3, 1, 1, 3, 3, 1, + 1, 1, 1, 1, 1, 3, 3, 1, 1, 3, + 3, 1, 1, 3, 3, 1, 1, 3, 3, 1, + 1, 3, 3, 1, 1, 5, 5, 1, 1, 1, + 1, 1, 1, 3, 3, 3, 3, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 3, 3, 0, 0, 1, 1, 3, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 3, 1, 2, 1, 4, 1, 1, 1, 1, + 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, + 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, + 2, 2, 3, 3, 0, 1, 2, 2, 1, 4, + 1, 3, 1, 3, 2, 2, 4, 4, 3, 2, + 2, 2, 0, 1, 1, 0, 2, 7, 5, 7, + 7, 5, 9, 9, 9, 1, 1, 7, 7, 3, + 3, 2, 2, 2, 3, 2, 3, 3, 5, 5, + 3, 5, 1, 2, 0, 1, 4, 3, 3, 1, + 3, 3, 3, 3, 4, 5, 2, 1, 1, 2, + 1, 9, 9, 1, 8, 9, 8, 1, 0, 1, + 1, 2, 3, 1, 3, 1, 1, 1, 1, 4, + 4, 7, 7, 1, 1, 0, 8, 9, 8, 9, + 1, 1, 1, 1, 8, 1, 7, 8, 7, 1, + 1, 1, 3, 3, 2, 2, 6, 6, 5, 5, + 1, 1, 1, 1, 0, 2, 0, 1, 1, 2, + 1, 2, 1, 0, 1, 1, 1, 1, 0, 1, + 1, 2, 2, 2, 1, 3, 2, 1, 1, 1, + 3, 3, 1, 3, 2, 3, 4, 2, 1, 3, + 1, 3, 1, 1, 0, 3, 3, 2, 2, 2, + 5, 5, 4, 2, 3, 4, 1, 3, 1, 3, + 2 }; - -#ifndef QLALR_NO_QMLJSGRAMMAR_DEBUG_INFO -const int QmlJSGrammar::rule_info [] = { - 126, 115, 127, 126, 117, 128, 126, 118, 129, 126, 116, 130, 126, 119, 131, 126, 120, 132, 127, 133, 134, 133, 135, 133, 136, 136, 137, - 136, 138, 136, 136, 137, 136, 136, 138, 139, 140, 137, 109, 139, 62, 137, 109, 139, 61, 141, 142, 138, 143, 62, 138, 143, 61, 138, 143, 47, 62, - 138, 143, 47, 61, 138, 143, 47, 110, 144, 62, 138, 143, 47, 110, 144, 61, 138, 143, 110, 144, 62, 138, 143, 110, 144, 61, 143, 108, 141, 135, 134, 145, 146, 130, 146, 146, 130, - 147, 145, 147, 147, 8, 145, 148, 33, 55, 148, 33, 146, 55, 145, 149, 148, 130, 145, 130, 149, 7, 150, 34, 147, 56, 130, 149, 7, 150, 149, 148, 130, 149, 124, 149, 148, 151, 33, 150, 152, 55, - 151, 33, 150, 152, 8, 55, 153, 150, 121, 154, 153, 150, 122, 155, 153, 150, 122, 151, 153, 150, 156, 153, 150, 154, 153, 150, 157, 153, 150, 158, 153, 150, 159, 153, 150, 160, - 130, 149, 7, 153, 161, 77, 161, 89, 161, 29, 161, 161, 15, 29, 162, 162, 163, 163, 161, 144, 163, 163, 8, 161, 144, 130, 69, 29, 36, 162, 60, 62, - 130, 69, 29, 36, 162, 60, 61, 130, 69, 29, 62, 130, 69, 29, 61, 130, 68, 29, 37, 161, 24, 144, 62, 130, 68, 29, 37, 161, 24, 144, 61, 130, 68, 161, 144, 62, 130, 68, 161, 144, 61, 130, 10, 68, 161, 144, 62, 130, 10, 68, 161, 144, 61, 130, 10, 68, 29, 37, 161, 24, 144, 62, - 130, 10, 68, 29, 37, 161, 24, 144, 61, 130, 68, 161, 144, 7, 153, 130, 70, 68, 161, 144, 7, 153, 130, 10, 68, 161, 144, 7, 153, 130, 68, 29, 37, 161, 24, 144, 7, 34, 147, 56, 130, 68, 161, 144, 7, 150, 149, 148, 130, 70, 68, 161, 144, 7, 150, 149, 148, 130, 164, 130, 165, 149, 142, - 130, 94, 29, 33, 166, 55, 166, 29, 166, 29, 17, 47, 166, 166, 8, 29, 166, 166, 8, 29, 17, 47, 144, 29, 144, 68, 144, 69, 144, 70, 144, 124, - 144, 112, 144, 113, 144, 102, 144, 111, 140, 29, 140, 68, 140, 69, 140, 70, 140, 124, 140, 112, - 140, 113, 140, 102, 140, 100, 140, 111, 140, 110, 167, 140, 168, 167, 169, 72, 169, 167, 169, 170, - 169, 171, 169, 172, 169, 173, 169, 174, 169, 175, 169, 176, 169, 177, 169, 178, 178, 36, 179, 60, 178, 36, 60, - 178, 36, 180, 60, 178, 36, 179, 8, 181, 60, 170, 83, 170, 84, 170, 85, 170, 47, 170, 90, 170, 67, 176, 12, 176, 13, - 171, 34, 182, 56, 171, 34, 183, 56, 171, 34, 183, 8, 182, 56, 183, 184, 183, 185, 184, 183, 182, 186, 183, 183, 8, 182, 184, 183, 183, 8, 182, 186, 185, 8, 185, 185, 8, - 182, 182, 185, 186, 95, 187, 172, 33, 55, 172, 33, 188, 55, 172, 33, 188, 8, 55, 152, 189, 188, 190, 152, 152, 8, 189, 188, 188, 8, 190, - 190, 167, 190, 191, 191, 167, 192, 189, 193, 7, 184, 190, 194, 7, 184, 190, 195, 194, 196, 194, 197, 196, 198, 193, 67, - 196, 67, 193, 47, 196, 47, 198, 167, 198, 199, 199, 4, 199, 5, 199, 6, 199, 9, 199, 10, - 199, 11, 199, 14, 199, 16, 199, 94, 199, 85, 199, 20, 199, 21, 199, 22, 199, 30, 199, 31, - 199, 32, 199, 43, 199, 83, 199, 59, 199, 71, 199, 72, 199, 73, 199, 84, 199, 75, 199, 76, - 199, 77, 199, 78, 199, 79, 199, 86, 199, 87, 199, 88, 199, 89, 199, 97, 199, 80, 199, 98, - 199, 99, 199, 101, 199, 108, 197, 34, 184, 56, 200, 17, 187, 192, 17, 184, 201, 202, 201, 200, 202, 192, - 177, 103, 203, 106, 203, 105, 129, 203, 177, 104, 129, 203, 142, 169, 204, 97, 142, 204, 34, 179, 56, 142, 142, 34, 179, 56, 205, 43, 15, 29, 142, 204, 15, 198, - 142, 142, 15, 198, 142, 206, 142, 43, 142, 36, 207, 60, 206, 205, 208, 142, 208, 43, 208, 209, 209, 177, 142, 142, 177, 209, 142, 36, 207, 60, 209, 204, 36, 207, 60, - 209, 209, 36, 207, 60, 209, 209, 34, 179, 56, 209, 209, 15, 198, 207, 207, 210, 207, 210, 8, 210, 184, 210, 95, 184, 210, 210, 8, 184, 210, 210, 8, 95, 184, - 211, 208, 211, 209, 212, 211, 212, 211, 53, 212, 211, 42, 212, 53, 213, 212, 42, 213, 213, 212, 213, 11, 213, 213, 78, 213, - 213, 76, 213, 213, 51, 213, 213, 40, 213, 213, 74, 213, 213, 44, 213, 214, 213, 214, 212, 64, 214, 215, 214, 215, 215, 216, 214, 216, 63, - 216, 12, 216, 57, 217, 215, 217, 217, 51, 215, 217, 217, 40, 215, 218, 217, 218, 218, 38, 217, 218, 218, 25, 217, 218, 218, 27, 217, 219, 218, - 220, 218, 219, 219, 221, 218, 220, 220, 221, 218, 221, 37, 221, 24, 221, 35, 221, 23, 221, 32, 219, 219, 31, 218, 222, 219, - 223, 220, 222, 222, 224, 219, 223, 223, 224, 220, 224, 18, 224, 45, 224, 19, 224, 46, 225, 223, 226, 222, 225, 225, 1, 223, - 226, 226, 1, 222, 227, 225, 228, 226, 227, 227, 81, 225, 228, 228, 81, 226, 229, 227, 230, 228, 229, 229, 48, 227, 230, 230, 48, 228, 231, 229, - 232, 230, 231, 231, 2, 229, 232, 232, 2, 230, 233, 231, 234, 232, 233, 233, 50, 231, 234, 234, 50, 232, 235, 233, 236, 234, 235, 233, 54, 184, 7, 187, - 236, 234, 54, 184, 7, 184, 187, 235, 184, 236, 187, 237, 184, 238, 187, 239, 184, 240, 187, 211, 17, 187, 184, 211, 17, 184, 187, 211, 241, 187, - 184, 211, 241, 184, 241, 66, 241, 65, 241, 13, 241, 58, 241, 52, 241, 41, 241, 39, 241, 26, 241, 28, - 241, 3, 241, 82, 241, 49, 129, 187, 179, 184, 129, 129, 8, 187, 179, 179, 8, 184, 242, 243, 242, 129, - 243, 179, 128, 150, 122, 244, 128, 150, 165, 128, 150, 156, 128, 150, 154, 128, 150, 157, 128, 150, 245, 128, 150, 246, 128, 150, 247, 128, 150, 248, - 128, 150, 158, 128, 150, 249, 128, 150, 250, 128, 150, 160, 128, 150, 251, 252, 253, 252, 254, 252, 255, 253, 164, 253, 256, - 257, 258, 257, 259, 245, 260, 245, 159, 244, 155, 155, 33, 261, 55, 262, 263, 262, 262, 263, 263, 128, 263, 150, 121, 252, 62, - 263, 150, 121, 252, 61, 261, 150, 261, 262, 264, 87, 264, 86, 265, 77, 266, 264, 267, 255, 264, 268, 269, 265, 270, 271, 265, 272, - 165, 271, 62, 165, 271, 61, 267, 273, 268, 273, 270, 274, 272, 275, 267, 267, 8, 276, 268, 268, 8, 273, 270, 270, 8, 274, 272, 272, 8, 275, - 276, 168, 201, 273, 168, 202, 274, 168, 201, 275, 168, 202, 276, 277, 200, 273, 277, 192, 274, 277, 200, 275, 277, 192, 277, 33, 278, 55, 277, 34, 279, 56, - 278, 278, 280, 278, 280, 8, 279, 182, 181, 279, 281, 279, 281, 8, 182, 181, 280, 282, 280, 280, 8, 282, 281, 283, 281, 281, 8, 283, - 283, 182, 284, 282, 168, 202, 282, 194, 7, 168, 202, 282, 194, 7, 277, 202, 284, 168, 202, 284, 277, 202, 180, 95, 168, 180, 95, 277, 181, 181, 180, - 156, 61, 150, 154, 179, 62, 154, 179, 61, 157, 30, 36, 179, 60, 128, 16, 128, 157, 30, 36, 179, 60, 128, 260, 14, 128, 79, 36, 179, 60, 62, 260, 14, 128, 79, 36, 179, 60, 92, 260, 14, 128, 79, 36, 179, 60, 61, 260, 79, 36, 179, 60, 128, - 260, 21, 36, 242, 61, 243, 61, 243, 60, 128, 260, 21, 36, 269, 61, 243, 61, 243, 60, 128, 260, 21, 36, 266, 61, 243, 61, 243, 60, 128, 285, 31, 285, 111, 260, 21, 36, 211, 285, 179, 60, 128, 260, 21, 36, 286, 285, 179, 60, 128, 286, 264, 168, 286, 265, 168, 286, 264, 277, - 286, 265, 277, 246, 9, 62, 246, 9, 61, 246, 9, 167, 62, 246, 9, 167, 61, 247, 4, 62, 247, 4, 61, 247, 4, 167, 62, 247, 4, 167, 61, 248, 59, 243, 62, - 248, 59, 243, 61, 158, 80, 36, 179, 60, 128, 159, 71, 36, 179, 60, 287, 287, 33, 288, 55, 287, 33, 288, 289, 288, 55, 290, 291, 290, 290, 291, 288, 288, 290, 291, 5, 179, 7, 261, - 289, 10, 7, 261, 249, 167, 7, 292, 292, 128, 292, 150, 121, 164, 250, 73, 179, 62, 250, 73, 179, 61, 160, 75, 155, 293, 160, 75, 155, 294, 160, 75, 155, 293, 294, 293, 6, 36, 295, 60, 155, - 294, 20, 155, 295, 168, 295, 277, 251, 88, 62, 251, 88, 61, 296, 22, 164, 296, 168, 36, 297, 60, 298, 299, 300, 258, 164, 258, 296, 36, 297, 60, 298, 299, 300, 173, 22, 168, 36, 297, 60, 298, 299, 300, - 173, 22, 36, 297, 60, 298, 299, 300, 301, 297, 297, 297, 180, 297, 302, 297, 302, 8, 297, 302, 8, 180, 302, 284, 302, 302, 8, 284, 303, 284, - 298, 33, 300, 55, 299, 261, 239, 304, 93, 305, 187, 240, 304, 93, 305, 184, 239, 304, 93, 305, 122, 298, 299, 300, 240, 304, 93, 305, 122, 298, 299, 300, 304, 168, 304, 178, 305, - 195, 194, 36, 301, 60, 298, 299, 300, 195, 63, 194, 306, 301, 60, 298, 307, 308, 195, 112, 194, 36, 60, 298, 299, 300, 195, 113, 194, 36, 309, 60, 298, 299, 300, 309, 303, 306, 36, 308, 55, 256, 296, 63, 168, 306, 297, 60, 298, 307, 308, 259, 256, 259, 296, 63, 306, 297, 60, 298, 307, 308, - 175, 22, 63, 168, 306, 297, 60, 298, 307, 308, 175, 22, 63, 306, 297, 60, 298, 307, 308, 307, 299, 237, 96, 238, 96, 237, 96, 63, 187, 238, 96, 63, 184, 237, 96, 187, 238, 96, 184, 254, 98, 168, 310, 311, 312, 313, - 174, 98, 168, 310, 311, 312, 313, 314, 98, 310, 311, 312, 313, 174, 98, 310, 311, 312, 313, 314, 254, 311, 33, 313, 55, 315, 100, 310, 310, 99, 211, 312, - 312, 316, 316, 317, 316, 316, 317, 317, 195, 317, 315, 195, 317, 61, 131, 131, 318, 318, 262, 132, 319, - 320, 321, 319, 319, 320, 321, 322, 321, 321, 322, 322, 323, 62, 322, 323, 61, 322, 324, 62, 322, 324, 61, 322, 263, - 323, 108, 325, 326, 323, 108, 327, 325, 328, 325, 329, 325, 330, 325, 328, 8, 329, 325, 328, 8, 330, 328, 331, 329, 63, 110, 331, 330, 33, 55, - 330, 33, 332, 55, 330, 33, 332, 8, 55, 326, 102, 327, 332, 333, 332, 332, 8, 333, 333, 331, 333, 198, 110, 331, 327, 67, 331, 168, 334, - 324, 101, 63, 326, 324, 101, 335, 326, 324, 101, 335, 324, 101, 165, 324, 101, 252, 324, 101, 10, 334, 121, 257, 324, 101, 10, 334, 121, 314, 324, 101, 10, 334, 184, 335, 33, 55, 335, 33, 336, 55, - 335, 33, 336, 8, 55, 336, 337, 336, 336, 8, 337, 337, 198, 337, 198, 110, 198, 338, 126, 0 -}; - -const int QmlJSGrammar::rule_index [] = { - 0, 3, 6, 9, 12, 15, 18, 21, 23, 25, - 27, 29, 32, 35, 37, 41, 45, 47, 50, 53, - 57, 61, 67, 73, 78, 83, 86, 87, 89, 91, - 94, 96, 100, 103, 107, 110, 112, 119, 125, 130, - 135, 141, 145, 149, 153, 156, 159, 162, 165, 168, - 171, 175, 177, 179, 181, 185, 186, 188, 191, 196, - 203, 210, 214, 218, 226, 234, 239, 244, 250, 256, - 265, 274, 280, 287, 294, 305, 313, 322, 324, 326, - 328, 334, 336, 340, 344, 350, 352, 354, 356, 358, - 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, - 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, - 400, 402, 404, 406, 408, 410, 412, 414, 416, 420, - 423, 427, 433, 435, 437, 439, 441, 443, 445, 447, - 449, 453, 457, 463, 465, 468, 471, 476, 481, 483, - 486, 487, 489, 492, 495, 499, 504, 506, 508, 512, - 516, 518, 520, 523, 527, 531, 533, 535, 537, 539, - 541, 543, 545, 547, 549, 551, 553, 555, 557, 559, - 561, 563, 565, 567, 569, 571, 573, 575, 577, 579, - 581, 583, 585, 587, 589, 591, 593, 595, 597, 599, - 601, 603, 605, 607, 609, 611, 613, 615, 617, 619, - 621, 623, 625, 627, 631, 634, 637, 638, 639, 641, - 643, 645, 647, 651, 655, 657, 659, 664, 669, 673, - 677, 681, 683, 689, 691, 693, 696, 699, 702, 707, - 712, 717, 722, 726, 727, 729, 732, 734, 737, 741, - 746, 748, 750, 752, 755, 758, 761, 764, 766, 769, - 772, 775, 778, 781, 784, 787, 789, 793, 795, 799, - 801, 803, 805, 807, 811, 815, 817, 821, 825, 829, - 831, 833, 837, 841, 843, 845, 847, 849, 851, 855, - 857, 859, 863, 867, 869, 871, 873, 875, 877, 879, - 883, 887, 889, 891, 895, 899, 901, 903, 907, 911, - 913, 915, 919, 923, 925, 927, 931, 935, 937, 939, - 945, 951, 953, 955, 957, 959, 961, 963, 967, 971, - 975, 979, 981, 983, 985, 987, 989, 991, 993, 995, - 997, 999, 1001, 1003, 1005, 1007, 1011, 1015, 1016, 1017, - 1019, 1021, 1025, 1028, 1031, 1034, 1037, 1040, 1043, 1046, - 1049, 1052, 1055, 1058, 1061, 1064, 1066, 1068, 1070, 1072, - 1074, 1076, 1078, 1080, 1082, 1084, 1088, 1090, 1093, 1095, - 1100, 1105, 1107, 1109, 1111, 1113, 1115, 1118, 1121, 1124, - 1127, 1130, 1133, 1135, 1137, 1139, 1141, 1145, 1149, 1153, - 1157, 1160, 1163, 1166, 1169, 1172, 1175, 1178, 1181, 1185, - 1189, 1190, 1192, 1195, 1198, 1200, 1205, 1207, 1211, 1213, - 1217, 1220, 1223, 1228, 1233, 1236, 1239, 1242, 1245, 1246, - 1248, 1250, 1251, 1254, 1257, 1265, 1271, 1279, 1287, 1295, - 1301, 1311, 1321, 1331, 1333, 1335, 1343, 1351, 1354, 1357, - 1360, 1363, 1366, 1369, 1373, 1377, 1380, 1383, 1387, 1391, - 1395, 1399, 1405, 1411, 1415, 1421, 1423, 1426, 1427, 1429, - 1434, 1438, 1442, 1444, 1448, 1452, 1456, 1460, 1464, 1469, - 1475, 1478, 1480, 1482, 1485, 1488, 1490, 1499, 1501, 1509, - 1518, 1526, 1528, 1529, 1531, 1533, 1536, 1540, 1542, 1546, - 1548, 1550, 1552, 1554, 1559, 1564, 1572, 1580, 1582, 1584, - 1585, 1593, 1602, 1610, 1619, 1621, 1623, 1625, 1635, 1637, - 1646, 1656, 1665, 1667, 1669, 1671, 1675, 1679, 1682, 1685, - 1692, 1699, 1705, 1711, 1713, 1715, 1717, 1719, 1720, 1723, - 1724, 1726, 1728, 1731, 1733, 1736, 1738, 1739, 1741, 1743, - 1745, 1747, 1748, 1750, 1752, 1755, 1758, 1761, 1764, 1767, - 1769, 1773, 1776, 1778, 1780, 1782, 1786, 1790, 1792, 1796, - 1799, 1803, 1808, 1811, 1813, 1817, 1819, 1823, 1825, 1827, - 1828, 1832, 1836, 1839, 1842, 1845, 1851, 1857, 1862, 1865, - 1869, 1874, 1876, 1880, 1882, 1886 -}; -#endif // QLALR_NO_QMLJSGRAMMAR_DEBUG_INFO - const short QmlJSGrammar::action_default [] = { - 0, 0, 422, 422, 422, 0, 27, 0, 266, 111, - 316, 0, 334, 498, 292, 300, 296, 242, 114, 312, - 118, 288, 258, 3, 113, 115, 109, 106, 243, 110, - 304, 308, 225, 222, 263, 241, 224, 112, 215, 116, - 281, 271, 0, 105, 528, 0, 129, 130, 125, 102, - 0, 100, 95, 0, 141, 0, 0, 0, 127, 0, - 0, 211, 123, 126, 104, 99, 0, 0, 96, 98, - 101, 97, 103, 128, 216, 0, 108, 0, 124, 0, - 0, 514, 117, 256, 248, 314, 0, 0, 118, 109, - 243, 265, 245, 244, 0, 261, 262, 260, 259, 264, - 500, 0, 494, 0, 422, 491, 372, 0, 369, 422, - 367, 493, 317, 0, 335, 293, 301, 297, 349, 347, - 313, 348, 355, 344, 289, 345, 0, 109, 346, 363, - 352, 243, 305, 309, 280, 350, 270, 364, 0, 0, - 0, 422, 0, 0, 0, 0, 339, 421, 0, 0, - 0, 376, 0, 0, 515, 353, 354, 0, 0, 343, - 351, 315, 500, 0, 495, 0, 422, 0, 497, 492, - 0, 291, 0, 284, 286, 285, 287, 282, 0, 277, - 275, 0, 278, 276, 274, 272, 0, 0, 0, 268, - 269, 267, 279, 0, 299, 0, 295, 423, 0, 424, - 337, 422, 0, 462, 463, 0, 0, 464, 476, 0, - 107, 483, 488, 208, 208, 484, 485, 0, 0, 401, - 141, 415, 210, 0, 206, 416, 486, 489, 487, 0, - 422, 0, 477, 417, 418, 208, 407, 402, 158, 159, - 107, 157, 0, 0, 165, 166, 167, 168, 200, 194, - 169, 196, 170, 171, 172, 173, 174, 202, 201, 175, - 176, 177, 178, 179, 203, 180, 181, 0, 195, 182, - 183, 163, 197, 184, 161, 198, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 199, 412, 403, 408, 399, - 0, 208, 208, 413, 414, 0, 204, 0, 405, 409, - 142, 419, 139, 400, 141, 410, 419, 411, 420, 406, - 140, 404, 0, 331, 324, 0, 329, 330, 328, 327, - 333, 326, 325, 322, 323, 332, 321, 319, 0, 303, - 0, 0, 307, 0, 0, 311, 0, 446, 447, 448, - 449, 0, 442, 443, 444, 445, 474, 475, 0, 0, - 0, 0, 0, 0, 427, 428, 429, 338, 340, 0, - 0, 243, 0, 0, 375, 374, 0, 0, 0, 336, - 339, 0, 341, 339, 0, 422, 431, 0, 434, 435, - 0, 422, 437, 0, 0, 0, 320, 0, 422, 436, - 318, 438, 377, 440, 383, 392, 0, 207, 0, 387, - 209, 391, 0, 205, 395, 396, 339, 0, 339, 0, - 422, 433, 439, 441, 385, 379, 393, 397, 0, 207, - 0, 389, 339, 0, 339, 0, 422, 432, 365, 342, - 422, 0, 366, 357, 0, 0, 359, 360, 356, 0, - 358, 0, 370, 371, 0, 0, 483, 506, 0, 0, - 422, 513, 0, 508, 507, 208, 378, 0, 384, 0, - 388, 528, 0, 0, 530, 525, 0, 532, 531, 0, - 164, 534, 0, 100, 536, 101, 0, 527, 520, 526, - 533, 535, 483, 482, 0, 0, 422, 0, 501, 0, - 0, 0, 422, 0, 503, 0, 0, 490, 505, 0, - 0, 422, 0, 504, 0, 483, 0, 0, 422, 0, - 502, 529, 0, 0, 422, 426, 422, 425, 0, 450, - 451, 0, 0, 0, 453, 458, 456, 459, 0, 0, - 457, 458, 0, 454, 0, 455, 422, 461, 0, 422, - 460, 0, 465, 466, 0, 467, 468, 0, 0, 469, - 0, 472, 473, 0, 0, 470, 471, 0, 0, 422, - 430, 0, 0, 422, 452, 519, 0, 517, 208, 0, - 380, 386, 394, 398, 0, 390, 381, 382, 496, 0, - 368, 0, 290, 0, 283, 0, 273, 0, 298, 0, - 294, 0, 0, 234, 227, 233, 0, 232, 235, 0, - 237, 0, 236, 239, 0, 240, 231, 238, 0, 302, - 0, 0, 306, 0, 0, 310, 0, 0, 234, 228, - 221, 0, 218, 0, 229, 0, 0, 234, 220, 0, - 217, 0, 230, 528, 0, 0, 530, 0, 521, 530, - 0, 523, 249, 248, 0, 483, 0, 483, 0, 0, - 422, 0, 480, 0, 0, 422, 0, 481, 0, 483, - 483, 0, 0, 422, 0, 511, 0, 0, 422, 0, - 512, 152, 151, 156, 148, 0, 0, 144, 153, 0, - 145, 150, 146, 0, 155, 134, 0, 142, 0, 141, - 132, 0, 137, 138, 0, 133, 143, 135, 136, 131, - 0, 0, 120, 121, 419, 119, 0, 122, 253, 247, - 225, 226, 0, 0, 234, 0, 223, 219, 255, 252, - 246, 0, 0, 212, 214, 0, 213, 254, 251, 250, - 518, 0, 516, 0, 257, 0, 0, 6, 543, 540, - 544, 422, 550, 0, 0, 548, 549, 546, 547, 545, - 575, 573, 570, 0, 0, 574, 572, 0, 563, 568, - 0, 578, 0, 524, 577, 0, 478, 361, 509, 362, - 576, 528, 483, 0, 0, 0, 422, 0, 479, 483, - 0, 0, 422, 0, 510, 0, 530, 0, 522, 582, - 0, 584, 579, 0, 580, 583, 581, 0, 585, 571, - 569, 0, 558, 553, 552, 554, 555, 0, 0, 551, - 0, 556, 557, 0, 564, 566, 0, 560, 0, 567, - 0, 561, 565, 562, 0, 559, 5, 538, 422, 2, - 78, 80, 0, 0, 476, 0, 96, 98, 97, 36, - 4, 0, 79, 0, 54, 53, 52, 0, 0, 54, - 0, 0, 0, 55, 0, 93, 91, 86, 94, 90, - 87, 89, 92, 88, 70, 71, 0, 68, 422, 69, - 0, 74, 45, 46, 47, 49, 0, 0, 50, 48, - 43, 422, 44, 372, 126, 128, 147, 0, 0, 0, - 40, 162, 41, 160, 149, 0, 154, 42, 0, 0, - 0, 82, 0, 81, 84, 0, 85, 0, 83, 0, - 54, 0, 0, 0, 0, 0, 64, 0, 65, 0, - 0, 31, 0, 0, 75, 32, 0, 35, 33, 29, - 0, 34, 30, 0, 66, 422, 67, 0, 72, 225, - 0, 76, 0, 0, 0, 422, 0, 73, 225, 0, - 77, 0, 62, 56, 63, 57, 0, 0, 0, 0, - 59, 0, 60, 61, 58, 422, 0, 0, 51, 141, - 0, 0, 37, 38, 0, 39, 8, 0, 0, 9, - 0, 11, 0, 10, 1, 26, 17, 14, 0, 15, - 16, 13, 12, 28, 7, 0, 18, 0, 19, 0, - 24, 25, 0, 20, 21, 0, 22, 23, 586 + 0, 0, 436, 436, 436, 0, 26, 0, 282, 127, + 332, 0, 350, 504, 308, 316, 312, 258, 130, 328, + 134, 304, 274, 3, 129, 131, 125, 114, 259, 126, + 320, 324, 241, 238, 279, 257, 240, 128, 231, 132, + 297, 287, 0, 112, 535, 0, 145, 146, 141, 109, + 0, 0, 107, 102, 0, 157, 0, 0, 0, 143, + 0, 0, 227, 139, 142, 111, 106, 0, 0, 103, + 105, 113, 108, 104, 110, 144, 232, 0, 124, 0, + 140, 0, 0, 521, 133, 272, 264, 330, 0, 0, + 134, 125, 259, 281, 261, 260, 0, 277, 278, 276, + 275, 280, 506, 0, 500, 0, 436, 497, 387, 0, + 385, 436, 383, 499, 333, 0, 351, 309, 317, 313, + 365, 363, 329, 364, 371, 360, 305, 361, 0, 125, + 362, 379, 368, 259, 321, 325, 296, 366, 286, 380, + 0, 0, 0, 436, 0, 0, 0, 0, 355, 435, + 0, 0, 0, 391, 0, 0, 522, 369, 370, 0, + 0, 359, 367, 331, 506, 0, 501, 0, 436, 0, + 503, 498, 0, 307, 0, 300, 302, 301, 303, 298, + 0, 293, 291, 0, 294, 292, 290, 288, 0, 0, + 0, 284, 285, 283, 295, 0, 315, 0, 311, 437, + 15, 0, 16, 353, 436, 0, 469, 470, 0, 0, + 471, 481, 0, 115, 489, 494, 123, 224, 490, 491, + 0, 0, 415, 157, 0, 122, 224, 86, 0, 0, + 119, 121, 120, 0, 0, 244, 237, 180, 181, 182, + 183, 184, 216, 210, 185, 212, 186, 187, 188, 189, + 190, 218, 217, 191, 192, 193, 194, 195, 219, 196, + 197, 211, 198, 199, 213, 200, 214, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 215, 0, 234, 0, + 0, 236, 0, 233, 0, 0, 250, 251, 0, 253, + 0, 252, 255, 0, 256, 239, 254, 235, 0, 116, + 0, 0, 118, 117, 429, 226, 0, 222, 430, 492, + 495, 493, 123, 0, 436, 0, 482, 431, 432, 224, + 421, 416, 174, 175, 115, 173, 0, 0, 0, 179, + 177, 426, 417, 422, 413, 0, 224, 224, 427, 428, + 0, 220, 0, 419, 423, 158, 433, 155, 414, 157, + 424, 433, 425, 434, 420, 156, 418, 0, 347, 340, + 0, 345, 346, 344, 343, 349, 342, 341, 338, 339, + 348, 337, 335, 0, 319, 0, 0, 323, 0, 0, + 327, 0, 456, 457, 0, 454, 455, 480, 0, 0, + 0, 0, 0, 0, 441, 440, 354, 356, 0, 0, + 259, 0, 0, 390, 389, 0, 0, 0, 352, 355, + 0, 357, 355, 0, 436, 443, 0, 446, 447, 0, + 436, 449, 0, 0, 0, 336, 0, 436, 448, 334, + 123, 392, 452, 397, 450, 406, 0, 123, 0, 401, + 223, 225, 405, 0, 221, 409, 410, 355, 0, 355, + 0, 436, 445, 123, 453, 399, 394, 451, 407, 411, + 0, 123, 0, 403, 223, 355, 0, 355, 0, 436, + 444, 381, 358, 436, 0, 382, 373, 0, 375, 0, + 376, 372, 0, 374, 0, 514, 386, 0, 489, 512, + 0, 0, 436, 520, 0, 515, 513, 123, 393, 0, + 398, 224, 0, 402, 535, 0, 0, 537, 532, 0, + 539, 538, 0, 541, 0, 107, 543, 108, 0, 534, + 527, 533, 540, 542, 489, 488, 0, 123, 0, 436, + 0, 507, 0, 0, 123, 0, 436, 0, 509, 0, + 0, 496, 511, 0, 123, 0, 436, 0, 510, 0, + 489, 0, 123, 0, 436, 0, 508, 536, 0, 0, + 436, 439, 436, 438, 0, 458, 0, 0, 0, 460, + 465, 463, 466, 0, 0, 464, 465, 0, 461, 0, + 462, 436, 468, 0, 436, 467, 0, 472, 0, 473, + 474, 0, 0, 475, 0, 478, 479, 0, 0, 476, + 477, 0, 0, 436, 442, 0, 0, 436, 459, 526, + 0, 524, 123, 0, 395, 400, 224, 408, 412, 0, + 404, 396, 502, 0, 384, 0, 306, 0, 299, 0, + 289, 0, 314, 0, 310, 0, 0, 250, 243, 249, + 0, 248, 0, 247, 0, 318, 0, 0, 322, 0, + 0, 326, 250, 0, 245, 250, 0, 246, 535, 0, + 0, 537, 0, 528, 537, 0, 530, 265, 264, 0, + 489, 489, 0, 123, 0, 436, 0, 486, 0, 123, + 0, 436, 0, 487, 0, 489, 489, 0, 0, 436, + 0, 518, 0, 0, 436, 0, 519, 168, 167, 172, + 164, 0, 0, 160, 169, 0, 161, 166, 162, 0, + 171, 150, 0, 158, 0, 157, 148, 0, 153, 154, + 0, 149, 159, 151, 152, 147, 0, 0, 136, 137, + 433, 135, 0, 138, 269, 263, 241, 242, 271, 268, + 262, 0, 0, 228, 230, 0, 229, 270, 267, 266, + 525, 0, 523, 0, 273, 0, 0, 6, 550, 547, + 551, 436, 555, 0, 0, 554, 553, 552, 580, 578, + 575, 0, 0, 579, 577, 0, 568, 573, 0, 583, + 0, 531, 582, 0, 484, 377, 0, 516, 378, 581, + 535, 489, 0, 123, 0, 436, 0, 485, 489, 0, + 0, 436, 0, 517, 0, 537, 0, 529, 587, 0, + 589, 584, 0, 585, 588, 586, 0, 590, 576, 574, + 0, 563, 558, 557, 559, 560, 0, 0, 556, 0, + 561, 562, 0, 569, 571, 0, 565, 0, 572, 0, + 566, 570, 567, 0, 564, 5, 545, 436, 2, 0, + 84, 83, 0, 0, 481, 514, 103, 105, 113, 104, + 35, 4, 81, 64, 67, 78, 74, 0, 85, 0, + 489, 0, 123, 0, 436, 0, 483, 0, 69, 68, + 76, 53, 52, 51, 0, 0, 53, 0, 0, 0, + 54, 0, 99, 97, 92, 100, 96, 93, 95, 101, + 98, 94, 63, 0, 66, 436, 0, 70, 44, 45, + 46, 48, 0, 0, 49, 47, 42, 436, 43, 387, + 142, 144, 163, 0, 0, 0, 39, 178, 40, 176, + 165, 0, 170, 41, 73, 71, 0, 0, 0, 88, + 0, 87, 90, 0, 91, 0, 89, 53, 0, 0, + 0, 0, 0, 0, 0, 0, 30, 0, 0, 0, + 31, 77, 0, 34, 32, 28, 0, 33, 29, 0, + 436, 0, 241, 0, 0, 80, 0, 82, 65, 79, + 75, 53, 0, 0, 0, 0, 0, 0, 436, 0, + 241, 0, 72, 0, 0, 0, 62, 55, 0, 53, + 56, 0, 0, 0, 57, 0, 0, 0, 0, 59, + 60, 0, 61, 58, 436, 0, 0, 50, 157, 0, + 0, 36, 37, 0, 38, 8, 0, 0, 9, 0, + 11, 0, 10, 1, 25, 18, 14, 0, 17, 13, + 12, 27, 7, 19, 0, 21, 0, 0, 24, 0, + 20, 22, 0, 0, 23, 591 }; const short QmlJSGrammar::goto_default [] = { - 7, 984, 108, 23, 840, 826, 737, 980, 994, 976, - 979, 983, 981, 988, 27, 985, 32, 982, 866, 839, - 930, 920, 927, 922, 106, 882, 887, 871, 125, 428, - 123, 128, 160, 137, 156, 911, 956, 955, 830, 159, - 900, 26, 13, 38, 29, 9, 37, 24, 18, 25, - 39, 82, 20, 126, 215, 311, 688, 686, 114, 300, - 698, 12, 675, 886, 674, 671, 222, 888, 472, 471, - 241, 238, 239, 244, 400, 416, 395, 724, 42, 36, - 33, 599, 35, 17, 598, 131, 84, 83, 22, 34, - 94, 8, 136, 134, 40, 178, 124, 21, 172, 14, - 115, 16, 117, 15, 116, 30, 132, 31, 133, 19, - 120, 85, 161, 10, 112, 383, 359, 518, 429, 119, - 121, 118, 135, 130, 155, 122, 434, 438, 433, 440, - 437, 770, 767, 769, 129, 111, 109, 110, 439, 157, - 363, 392, 456, 367, 415, 158, 570, 394, 414, 571, - 399, 214, 242, 297, 237, 298, 236, 299, 212, 377, - 360, 524, 528, 531, 527, 526, 203, 545, 546, 553, - 206, 483, 104, 451, 578, 484, 216, 498, 113, 101, - 446, 452, 453, 499, 634, 464, 466, 478, 764, 469, - 468, 467, 827, 739, 738, 741, 740, 736, 735, 801, - 756, 804, 803, 805, 806, 815, 816, 814, 760, 751, - 790, 789, 0 + 7, 1033, 110, 23, 861, 845, 757, 1029, 1042, 1025, + 1028, 1032, 1030, 1037, 27, 902, 1034, 32, 1031, 1046, + 903, 860, 966, 955, 963, 957, 108, 918, 923, 907, + 127, 471, 125, 130, 162, 139, 158, 948, 1001, 1000, + 863, 864, 934, 866, 865, 862, 851, 850, 161, 938, + 26, 13, 300, 231, 225, 226, 38, 29, 9, 37, + 24, 18, 25, 39, 84, 20, 128, 218, 356, 714, + 712, 116, 345, 724, 12, 701, 922, 700, 697, 305, + 924, 514, 513, 325, 322, 323, 238, 441, 458, 435, + 744, 42, 36, 33, 288, 35, 17, 287, 133, 86, + 85, 22, 34, 96, 8, 138, 136, 40, 180, 126, + 21, 174, 14, 117, 16, 119, 15, 118, 30, 134, + 31, 135, 19, 122, 87, 163, 10, 114, 422, 398, + 564, 472, 121, 123, 120, 137, 132, 157, 124, 477, + 481, 476, 483, 478, 789, 785, 788, 131, 113, 111, + 112, 482, 159, 402, 431, 498, 406, 456, 160, 614, + 433, 455, 615, 439, 217, 326, 342, 321, 343, 320, + 344, 215, 416, 399, 569, 573, 576, 572, 571, 206, + 589, 590, 597, 209, 525, 106, 493, 622, 526, 219, + 542, 115, 103, 685, 494, 495, 543, 479, 659, 507, + 509, 520, 782, 512, 511, 510, 846, 759, 758, 761, + 760, 756, 755, 820, 774, 823, 822, 824, 825, 834, + 835, 833, 778, 769, 809, 808, 0 }; const short QmlJSGrammar::action_index [] = { - 360, 2257, 317, 158, -126, 1795, 188, 277, 218, -126, - -126, 75, -126, -126, 142, 96, 83, 422, -126, -126, - 76, 393, -126, 172, -126, -126, 85, -126, 1036, -126, - 68, 213, 409, -126, 302, -126, -126, -126, -126, -126, - 427, 288, 291, -126, 685, 2142, -126, -126, -126, -126, - 901, -126, -126, 5445, 2953, 3643, 2142, 2142, -126, 1679, - 2142, -126, -126, -126, -126, -126, 2142, 2142, -126, -126, - -126, -126, -126, -126, -126, 2257, -126, 2142, -126, 2142, - 2142, 3413, -126, -126, 28, -126, 2142, 2142, -126, -126, - 168, 310, -126, -126, 2142, -126, -126, -126, -126, 337, - -126, 3298, -126, 105, -126, -126, 5567, 86, -126, 336, - -126, -126, -126, 78, -126, 147, 106, 100, -126, -126, - -126, -126, -126, -126, 504, -126, 323, 187, -126, -126, - -126, 1223, 153, 145, 483, -126, 309, -126, 885, 881, - 130, -126, 121, 128, 346, 120, 2372, -126, 114, 2372, - 119, -126, 111, 110, 3068, -126, -126, 906, 150, -126, - -126, -126, -126, 3183, -126, 112, -126, 94, -126, -126, - 2142, 377, 2142, -126, -126, -126, -126, 464, 2142, -126, - -126, 2142, -126, -126, -126, 352, 2142, 2142, 2142, 183, - 186, 198, 263, 2142, 109, 2142, 174, -126, 2372, -126, - -126, -126, 5689, -126, -126, 161, 712, -126, -126, 138, - -126, 1100, -126, 159, 149, -126, 155, 107, 1003, 4835, - 177, -126, -126, 2372, -126, -126, 1100, -126, -126, 156, - -126, 52, -126, -126, -126, 84, -126, 116, -126, -126, - 189, -126, 49, 88, -126, -126, -126, -126, -126, -126, - -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, - -126, -126, -126, -126, -126, -126, -126, 2372, -126, -126, - -126, -126, -126, -126, -126, -126, -126, -126, -126, -126, - -126, -126, -126, -126, -126, -126, -126, 4835, -126, -126, - 906, 77, 74, -126, -126, 27, -126, 29, 63, -126, - 65, 1100, -126, -126, 71, -126, 1100, -126, -126, -126, - -126, -126, 2372, -126, -126, 2372, -126, -126, -126, -126, - -126, -126, -126, -126, -126, -126, -126, -126, 2142, 41, - 2142, 2372, 79, 81, 2372, -126, 171, -126, -126, -126, - -126, 169, -126, -126, -126, -126, -126, -126, 5201, 72, - 104, 2372, 205, 241, -126, -126, -126, 3873, 125, 70, - 176, 1122, 1003, 64, -126, -126, 906, 58, 2257, -126, - 2372, 44, 90, 2372, 53, -126, -126, 2372, -126, -126, - 195, -126, -126, 2257, 2372, 2257, -126, 185, -126, -126, - -126, 327, 102, 95, -126, -126, 906, 97, 92, -126, - -126, -126, 2257, -126, -126, -126, 2372, 60, 2372, 62, - -126, -126, 322, 101, -126, 115, -126, -126, 1003, 99, - 98, -126, 2372, 59, 2372, 57, -126, -126, -126, -126, - -126, 56, -126, -126, 211, 708, -126, -126, -126, 906, - -126, 564, -126, -126, 712, 91, 1100, -126, 69, 93, - -126, -126, 73, -126, -126, 113, 124, 117, -126, 759, - -126, 61, 103, 1451, 5079, -126, 82, -126, 5079, 4957, - -126, -126, 50, 4835, -126, 4835, 4835, 46, -126, -126, - -126, -126, 1100, -126, 20, 39, -126, 38, -126, 40, - 24, 45, -126, 42, -126, 54, 906, -126, -126, 43, - 66, -126, 47, -126, -28, 1100, 48, 67, -126, 51, - -126, -126, 2372, 231, -126, 80, -126, -126, 181, -126, - -126, 2372, 214, 144, -126, 157, -126, 160, 209, 2372, - -126, 167, 166, -126, 127, -126, -126, -126, 396, -126, - -126, 308, -126, -126, 246, 164, -126, 162, 146, -126, - 906, -126, -126, 126, 154, -126, -126, 2372, 208, -126, - -126, 2372, 210, -126, -126, -126, 2372, -126, 118, 122, - 134, -126, -126, -126, 782, -126, -126, -126, -126, 5567, - -126, 2142, 368, 2142, 437, 2142, 315, 2142, 89, 2142, - 152, 4225, 2372, 2487, -126, -126, 239, -126, 7, -39, - -126, 2372, 2835, -126, 2372, -126, -126, -126, 2142, -26, - 2142, 2372, 21, 6, 2257, -126, 4225, 2372, 2487, -126, - -126, 236, -126, -30, -126, 4225, 2372, 2487, -126, 228, - -126, -60, -126, -87, 33, 33, 5079, 13, -126, 5079, - 5, -126, -126, -126, 25, 1100, 650, 1100, -3, 31, - -126, 22, -126, -25, 3, -126, -17, -126, 4, 1100, - 1100, -18, 1, -126, -8, -126, -4, 18, -126, -16, - -126, -126, 312, -126, -126, 243, 253, -126, -126, 5323, - -126, -126, -126, 2372, -126, -126, 249, 2605, 215, 17, - -126, 3758, -126, -126, 2257, -126, -126, -126, -126, -126, - 2, 240, -126, -126, 2720, -126, -12, -126, -126, -126, - 406, -126, 212, 12, 2487, -14, -126, -126, -126, -126, - -126, 348, 2257, -126, -126, 330, -126, -126, -126, -126, - -126, 2257, -126, 2142, -126, 232, 217, -126, -126, -126, - -126, 220, -126, 494, 998, -126, -126, -126, -126, -126, - -126, -75, -126, 4347, -96, -126, -126, -9, -126, -126, - 3528, -126, 178, -126, -126, 805, -126, -126, -126, -126, - -126, 632, 1100, 809, 15, 26, -126, -1, -126, 1100, - -27, -7, -126, -36, -126, 32, 5079, -41, -126, -126, - 206, -86, -126, 4469, -126, -126, -126, 4225, -126, -126, - -126, -52, -126, 151, -126, -126, -126, 4713, -57, -126, - 196, -126, -126, -101, -126, -126, 207, -126, 580, -126, - 4591, -126, -126, -126, 712, -126, -126, -126, 55, -126, - -126, 386, 19, 8, 165, 1565, 283, -24, 16, -126, - -126, 304, -126, 275, 37, -126, -126, 615, 342, -126, - 193, 23, 499, -126, 163, -126, -126, -126, -126, -126, - -126, -126, -126, -126, -126, -126, 347, -126, -126, -126, - 4103, -126, -126, -126, -126, -126, -29, 2372, -126, -126, - -126, -126, -126, 5811, 11, 10, -126, 201, 9, 296, - -126, -126, -126, -126, -126, 2372, -126, -126, -5, 0, - 180, 14, -19, -126, -15, -42, -126, -40, -126, 431, - -34, 615, 303, 182, 495, 313, -126, -2, -126, 1337, - 194, -126, 36, 1337, -126, -126, 1911, -126, -126, -126, - 2027, -126, -126, 300, -126, -126, -126, 4103, -126, 458, - -13, -126, 289, 615, -6, -126, 4103, -126, 448, -22, - -126, 247, -126, 321, -126, 35, -11, 615, 316, 615, - -126, 143, -126, -126, -126, -126, 1210, 3988, -126, 2953, - 34, 267, -126, -126, 30, -126, -126, 1337, 545, 173, - 1337, -126, 387, -126, -126, -126, 382, -126, 179, -126, - -126, -126, -126, -126, -126, 474, -126, 320, -126, 192, - -126, -126, 471, -126, -126, 224, -126, -126, -126, + 411, 3072, 372, 153, -130, 2475, 205, 152, 274, -130, + -130, 80, -130, -130, 150, 115, 77, 488, -130, -130, + 68, 463, -130, 142, -130, -130, 67, -130, 1520, -130, + 144, 190, 484, -130, 377, -130, -130, -130, -130, -130, + 596, 385, 363, -130, 959, 2834, -130, -130, -130, -130, + 1058, 1073, -130, -130, 6123, 3432, 4387, 2834, 2834, -130, + 2355, 2834, -130, -130, -130, -130, -130, 2834, 2834, -130, + -130, -130, -130, -130, -130, -130, -130, 3072, -130, 2834, + -130, 2834, 2834, 4146, -130, -130, 78, -130, 2834, 2834, + -130, -130, 251, 391, -130, -130, 2834, -130, -130, -130, + -130, 400, -130, 3191, -130, 108, -130, -130, 6501, 91, + -130, 428, -130, -130, -130, 66, -130, 139, 90, 62, + -130, -130, -130, -130, -130, -130, 458, -130, 368, 216, + -130, -130, -130, 1438, 135, 176, 550, -130, 418, -130, + 1172, 1094, 196, -130, 110, 109, 479, 104, 2953, -130, + 98, 2953, 109, -130, 112, 141, 4027, -130, -130, 1311, + 229, -130, -130, -130, -130, 3908, -130, 147, -130, 120, + -130, -130, 2834, 445, 2834, -130, -130, -130, -130, 512, + 2834, -130, -130, 2834, -130, -130, -130, 342, 2834, 2834, + 2834, 231, 246, 197, 305, 2834, 119, 2834, 175, -130, + -130, 2953, -130, -130, -130, 6375, -130, -130, 156, 747, + -130, -130, 137, -130, 1638, -130, 166, 155, -130, 161, + 94, 1211, 5619, 159, 2119, -130, 151, 373, 228, 2237, + -130, -130, 128, 4989, 2953, -130, -130, -130, -130, -130, + -130, -130, -130, -130, -130, -130, -130, -130, -130, -130, + -130, -130, -130, -130, -130, -130, -130, -130, -130, -130, + -130, -130, -130, -130, -130, -130, -130, -130, -130, -130, + -130, -130, -130, -130, -130, -130, -130, 221, -130, 4989, + 2953, -130, 367, -130, 478, 129, 3670, 149, 118, -130, + 2953, 3551, -130, 2953, -130, -130, -130, -130, 2119, -130, + 270, 2119, -130, -130, -130, -130, 2953, -130, -130, 1413, + -130, -130, 158, 124, -130, 113, -130, -130, -130, 138, + -130, 146, -130, -130, 219, -130, 73, 103, 2953, -130, + -130, -130, 5619, -130, -130, 1311, 102, 97, -130, -130, + 60, -130, 57, 100, -130, 96, 1398, -130, -130, 95, + -130, 1538, -130, -130, -130, -130, -130, 2953, -130, -130, + 2953, -130, -130, -130, -130, -130, -130, -130, -130, -130, + -130, -130, -130, 2834, 58, 2834, 2953, 99, 93, 2953, + -130, 198, -130, -130, 206, -130, -130, -130, 6249, 15, + 61, 2953, 209, 366, -130, -130, 4625, 89, 54, 199, + 1765, 1311, 48, -130, -130, 1311, 43, 3072, -130, 2953, + 42, 87, 2953, 40, -130, -130, 2953, -130, -130, 266, + -130, -130, 3072, 2953, 3072, -130, 275, -130, -130, -130, + 85, 81, 71, -130, 365, -130, 1311, 92, 117, -130, + 116, -130, -130, 3072, -130, -130, -130, 2953, 75, 2953, + 74, -130, -130, 125, 114, -130, 245, 354, -130, -130, + 1311, 106, 114, -130, 111, 2953, 59, 2953, 65, -130, + -130, -130, -130, -130, 72, -130, -130, 262, -130, 861, + -130, -130, 1311, -130, 840, -130, -130, 88, 1538, -130, + 64, 82, -130, -130, 63, -130, -130, 105, 101, 107, + -130, 107, 1311, -130, 20, 173, 2001, 5871, -130, 183, + -130, 5871, 5745, -130, 174, 5619, -130, 5619, 5619, 145, + -130, -130, -130, -130, 1638, -130, 132, 180, -30, -130, + 131, -130, 160, 130, 186, 162, -130, 163, -130, 169, + 1311, -130, -130, 171, 192, 170, -130, 165, -130, 168, + 1638, 148, 188, 164, -130, 143, -130, -130, 2953, 204, + -130, 167, -130, -130, 227, -130, 2953, 241, 157, -130, + 185, -130, 184, 248, 2953, -130, 181, 178, -130, 127, + -130, -130, -130, 240, -130, -130, 322, -130, 224, 189, + -130, 177, 179, -130, 1311, -130, -130, 172, 182, -130, + -130, 2953, 296, -130, -130, 2953, 301, -130, -130, -130, + 2953, -130, 194, 154, 195, -130, 2, -130, -130, 1311, + -130, -130, -130, 6501, -130, 2834, 443, 2834, 462, 2834, + 415, 2834, -67, 2834, 30, 4989, 2953, 3670, -130, -130, + 256, -130, -26, -130, 2834, -8, 2834, 2953, 1, -7, + 3072, -130, 3670, -57, -130, 3670, -54, -130, -91, -22, + -22, 5871, -44, -130, 5871, 23, -130, -130, -130, 38, + 1523, 1538, 14, 70, 44, -130, 24, -130, 31, 76, + 51, -130, 37, -130, 5, 1287, 1259, -19, 10, -130, + -6, -130, -13, 16, -130, 3, -130, -130, 332, -130, + -130, 290, 273, -130, -130, 5997, -130, -130, -130, 2953, + -130, -130, 321, 4268, 254, 79, -130, 4506, -130, -130, + 3072, -130, -130, -130, -130, -130, -32, 294, -130, -130, + 3789, -130, -24, -130, -130, -130, 491, -130, -130, -130, + -130, 340, 3072, -130, -130, 358, -130, -130, -130, -130, + -130, 3072, -130, 2834, -130, 257, 255, -130, -130, -130, + -130, 239, -130, 570, 1235, -130, -130, -130, -130, -65, + -130, 5241, -71, -130, -130, -52, -130, -130, 3310, -130, + 396, -130, -130, 1007, -130, -130, 941, -130, -130, -130, + 1111, 1638, -56, 0, -23, -130, -42, -130, 1638, 9, + 45, -130, 33, -130, 12, 5871, -2, -130, -130, 211, + -27, -130, 5493, -130, -130, -130, 4989, -130, -130, -130, + -31, -130, 56, -130, -130, -130, 5367, -51, -130, 187, + -130, -130, -61, -130, -130, 200, -130, 773, -130, 5115, + -130, -130, -130, 700, -130, -130, -130, 123, -130, 835, + -130, -130, -38, -3, -9, -12, 331, -46, -47, -10, + -130, -130, -130, -130, -130, -130, -130, 346, -130, 21, + 1638, 6, 52, 27, -130, 8, -130, 344, -130, -130, + -130, 32, -130, -130, 811, 311, -130, 220, 4, 546, + -130, 218, -130, -130, -130, -130, -130, -130, -130, -130, + -130, -130, -130, 333, -130, -130, 4744, 222, -130, -130, + -130, -130, -33, 2953, -130, -130, -130, -130, -130, 6627, + 11, 19, -130, 265, 28, 295, -130, -130, -130, -130, + -130, 2953, -130, -130, -130, -130, -20, -28, 210, 50, + 36, -130, 55, 26, -130, 34, -130, 53, 811, 361, + 212, 696, 490, 22, 1883, 217, -130, 29, 1883, 213, + -130, -130, 2595, -130, -130, -130, 2715, -130, -130, 352, + -130, 4744, 536, -5, 191, -130, 315, -130, -130, -130, + -130, -1, 633, 335, 226, 575, 329, 47, -130, 4744, + 524, 330, -130, 811, 225, 320, -130, 1011, 49, 41, + 39, -17, 693, 316, 25, 911, 46, 669, 308, 69, + -130, 233, -130, -130, -130, 1883, 4863, -130, 3432, 35, + 207, -130, -130, -25, -130, -130, 1883, 720, 223, 1883, + -130, 405, -130, -130, -130, 436, -130, 244, -130, -130, + -130, -130, -130, -130, 582, 7, 291, 260, -130, -29, + -130, -130, 696, 237, -130, -130, - -213, 160, 123, 148, 168, 658, -213, -213, -213, -213, - -213, -213, -213, -213, -213, -213, -213, 81, -213, -213, - -213, 44, -213, -213, -213, -213, -213, -213, -213, -213, - -213, -213, 104, -213, -213, -213, -213, -213, -213, -213, - 48, -213, -213, -213, 124, 659, -213, -213, -213, -213, - 116, -213, -213, 212, 120, 197, 500, 505, -213, 506, - 493, -213, -213, -213, -213, -213, 521, 529, -213, -213, - -213, -213, -213, -213, -213, 267, -213, 560, -213, 638, - 619, 218, -213, -213, -213, -213, 306, 309, -213, -213, - -213, -213, -213, -213, 487, -213, -213, -213, -213, -213, - -213, 307, -213, -213, -46, -213, 82, -213, -213, 184, - -213, -213, -213, -213, -213, -213, -213, -213, -213, -213, - -213, -213, -213, -213, -213, -213, -213, -213, -213, -213, - -213, 11, -213, -213, -213, -213, -213, -213, 60, 99, - -213, 198, -213, -213, 171, -213, 66, -213, -213, 86, - 28, -213, -213, -213, 1, -213, -213, 225, -213, -213, - -213, -213, -117, 7, -213, -108, -106, -104, -213, -213, - 422, -213, 432, -213, -213, -213, -213, -213, 329, -213, - -213, 434, -213, -213, -213, -213, 451, 458, 430, -213, - -213, -213, -213, 459, -213, 468, -213, -213, -13, -213, - -213, 204, 9, -213, -213, 57, 196, -213, -213, -213, - -213, 217, -213, 32, 34, -213, -213, -213, 213, 215, - 26, -213, -213, 23, -213, -213, 393, -213, -213, -99, - -95, -98, -213, -213, -213, 10, -213, -213, -213, -213, - -213, -213, -213, -213, -213, -213, -213, -213, -213, -213, - -213, -213, -213, -213, -213, -213, -213, -213, -213, -213, - -213, -213, -213, -213, -213, -213, -213, 29, -213, -213, - -213, -213, -213, -213, -213, -213, -213, -213, -213, -213, - -213, -213, -213, -213, -213, -213, -213, 342, -213, -213, - 223, 16, 17, -213, -213, -213, -213, -213, -213, -213, - -213, 312, -213, -213, 117, -213, 555, -213, -213, -213, - -213, -213, 31, -213, -213, 30, -213, -213, -213, -213, - -213, -213, -213, -213, -213, -213, -213, -213, 376, -213, - 391, 27, -213, -213, 25, -213, -213, -213, -213, -213, - -213, -213, -213, -213, -213, -213, -213, -213, 39, -213, - -213, 21, -213, -213, -213, -213, -213, 610, -213, -213, - -213, -80, 295, -213, -213, -213, 291, -213, 359, -213, - 115, -213, -213, 114, -213, 162, -213, 24, -213, -213, - -213, 161, -213, 377, 22, 387, -213, -213, 159, -213, - -213, -213, -213, 36, -213, -213, 272, 40, 38, -213, - -213, -213, 398, -213, -213, -213, 107, -213, 106, -213, - 315, -213, -213, 37, -213, -213, -213, -213, 408, -213, - 35, -213, 103, -213, 101, -213, 151, -213, -213, -213, - -35, -213, -213, -213, -213, 109, -213, -213, -213, 330, - -213, 169, -213, -213, 188, -213, 258, -213, -213, -75, - -213, -213, -213, -213, -213, -213, -213, 33, -213, 471, - -213, -88, -213, 250, 53, -213, -213, -213, 172, 199, - -213, -213, -213, 194, -213, 201, 203, -213, -213, -213, - -213, -213, 205, -213, -213, -81, -83, -90, -213, -213, - -213, -109, -118, -120, -213, -213, 254, -213, -213, -213, - -119, -121, -127, -213, -178, 252, -213, -124, -135, -141, - -213, -213, -2, -213, 178, -213, 179, -213, -213, -213, - -213, -4, -213, -213, -213, -213, -213, -123, -213, -9, - -213, -122, -213, -213, -213, -213, -96, -213, -213, -97, - -213, -213, -213, -213, -213, -125, -213, -213, 42, -213, - 246, -213, -213, -213, 69, -213, -213, 19, -213, 195, - -213, 15, -213, 202, -213, -213, 8, -213, -20, 3, - -213, -213, -213, -213, 304, -213, -213, -213, -213, 20, - -213, 542, -38, 578, -37, 308, -213, 519, -213, 588, - -213, 164, 80, 76, -213, -213, -213, -213, -213, -213, - -213, 77, 78, -213, 79, -213, -213, -213, 590, -213, - 591, 83, -213, -213, 290, -213, 153, 93, 131, -213, - -213, -213, -213, -213, -213, 149, 50, 126, -213, -213, - -213, -213, -213, -78, -72, -71, 154, -67, -213, 200, - -65, -213, -213, -213, -213, 270, 277, 281, -213, -48, - -44, -43, -213, -213, -56, -66, -69, -213, -36, 248, - 236, -213, -68, -64, -52, -213, -213, -47, -53, -61, - -213, -213, 52, -213, -213, -213, -213, -213, -213, 437, - -213, -213, -213, 90, -213, -213, -213, 91, -213, 89, - -213, 111, -213, -213, 404, -213, -213, -213, -213, -213, - -213, -213, -213, -213, 251, -213, -213, -213, -213, -213, - 104, -213, -213, -213, 118, -213, -213, -213, -213, -213, - -213, -213, 317, -213, -213, 61, -213, -213, -213, -213, - -213, 316, -213, 337, -213, -213, -213, -213, -213, -213, - -213, 219, -213, 365, 283, -213, -213, -213, -213, -213, - -213, -213, -213, 121, -183, -213, -213, -185, -213, -213, - -39, -213, 288, -213, -213, 192, -213, -213, -213, -213, - -213, 256, 289, 287, -213, -143, -142, -144, -213, 266, - -213, -145, -180, -177, -213, -175, 141, -179, -213, -213, - -213, -213, -213, 220, -213, -213, -213, 155, -213, -213, - -213, -174, -213, -213, -213, -213, -213, 244, -213, -213, - 12, -213, -213, -213, -213, -213, -213, -213, 234, -213, - 301, -213, -213, -213, 231, -213, -213, -213, 167, -213, - -213, 104, -213, -213, 146, 486, -213, -213, -213, -213, - -213, -213, -213, -22, -213, -213, -213, -213, -7, -213, - -213, -213, 4, -213, -213, -213, -213, -213, -213, -213, - -213, -213, -213, -213, -213, -213, -213, -213, 13, -213, - 844, -213, -213, -213, -213, -213, 5, -10, -213, -213, - -213, 128, -213, -16, -213, -213, -213, -213, -213, -30, - -213, -213, -213, -213, -213, -58, -213, -213, -213, -213, - -213, -213, -213, -213, -213, -213, -213, -213, -213, 104, - -213, -3, -12, -213, 2, -213, -213, -213, -213, 583, - -213, -213, -213, 584, -213, -213, 715, -213, -213, -213, - 712, -213, -213, -213, -213, 190, -213, 766, -213, 104, - -11, -213, -29, -6, -213, 150, 746, -213, 104, -15, - -213, -213, -213, -32, -213, -213, -213, 18, 0, 14, - -213, -213, -213, -213, -213, 174, 625, 727, -213, 633, - -1, -213, -213, -213, -8, -213, -213, 328, -5, 237, - 637, -213, -213, -213, -213, -213, 104, -213, -213, -213, - -213, -213, -213, -213, -213, 6, -213, -213, -213, -213, - -213, -213, -14, -213, -213, -213, -213, -213, -213 + -227, 229, 225, 224, 237, 781, -227, -227, -227, -227, + -227, -227, -227, -227, -227, -227, -227, 97, -227, -227, + -227, 67, -227, -227, -227, -227, -227, -227, -227, -227, + -227, -227, 101, -227, -227, -227, -227, -227, -227, -227, + 71, -227, -227, -227, 216, 559, -227, -227, -227, -227, + 211, 209, -227, -227, 255, 177, 176, 567, 571, -227, + 590, 776, -227, -227, -227, -227, -227, 603, 611, -227, + -227, -227, -227, -227, -227, -227, -227, 353, -227, 622, + -227, 545, 627, 348, -227, -227, -227, -227, 336, 363, + -227, -227, -227, -227, -227, -227, 356, -227, -227, -227, + -227, -227, -227, 335, -227, -227, 0, -227, 145, -227, + -227, 201, -227, -227, -227, -227, -227, -227, -227, -227, + -227, -227, -227, -227, -227, -227, -227, -227, 155, -227, + -227, -227, -227, 70, -227, -227, -227, -227, -227, -227, + 204, 203, 154, 214, -227, -227, 138, -227, 119, -227, + -227, 98, 57, -227, -227, -227, 43, -227, -227, 278, + 51, -227, -227, -227, -135, 8, -227, -104, -64, -91, + -227, -227, 599, -227, 500, -227, -227, -227, -227, -227, + 525, -227, -227, 529, -227, -227, -227, -227, 527, 522, + 524, -227, -227, -227, -227, 499, -227, 469, -227, -227, + -227, 45, -227, -227, 268, 53, -227, -227, -34, 157, + -227, -227, -227, -227, 280, -227, -227, 61, -227, -227, + -227, 265, 260, 5, 663, -227, 21, 41, -227, 470, + -227, -227, -227, 156, 106, -227, -227, -227, -227, -227, + -227, -227, -227, -227, -227, -227, -227, -227, -227, -227, + -227, -227, -227, -227, -227, -227, -227, -227, -227, -227, + -227, -227, -227, -227, -227, -227, -227, -227, -227, -227, + -227, -227, -227, -227, -227, -227, -227, -227, -227, 161, + 128, -227, -227, -227, 133, -227, 78, -227, -227, -227, + 76, 88, -227, 87, -227, -227, -227, -227, 752, -227, + -227, 762, -227, -227, -227, -227, 55, -227, -227, 376, + -227, -227, 105, -19, -43, -49, -227, -227, -227, 64, + -227, -227, -227, -227, -227, -227, -227, -227, 73, -227, + -227, -227, 434, -227, -227, 340, 65, 104, -227, -227, + -227, -227, -227, -227, -227, -227, 466, -227, -227, 136, + -227, 534, -227, -227, -227, -227, -227, 121, -227, -227, + 125, -227, -227, -227, -227, -227, -227, -227, -227, -227, + -227, -227, -227, 425, -227, 432, 103, -227, -227, 109, + -227, 162, -227, -227, 166, -227, -227, -227, 132, -227, + -227, 117, -227, 69, -227, -227, 659, -227, -227, -227, + -87, 317, -227, -227, -227, 313, -227, 438, -227, 147, + -227, -227, 144, -227, 207, -227, 12, -227, -227, -227, + 200, -227, 447, 62, 455, -227, -227, 212, -227, -227, + 74, -227, 60, -227, -227, -227, 299, 75, 17, -227, + 44, -227, -227, 457, -227, -227, -227, 134, -227, 135, + -227, 422, -227, 58, 49, -227, -227, -227, -227, -227, + 419, 56, 48, -227, -227, 227, -227, 190, -227, 266, + -227, -227, -227, -41, -227, -227, -227, 86, -227, 234, + -227, -227, 399, -227, 238, -227, -227, -94, 294, -227, + -227, -88, -227, -227, -227, -227, -227, 47, -227, 46, + -227, -227, 490, -227, -100, -227, 316, 50, -227, -227, + -227, 179, 226, -227, -227, 228, -227, 231, 241, -227, + -227, -227, -227, -227, 222, -227, -227, 72, -172, -62, + -75, -227, -227, -227, 68, -66, -65, -67, -227, -227, + 347, -227, -227, -227, 63, -68, -71, -101, -227, -111, + 349, -227, 38, -105, -117, -119, -227, -227, 9, -227, + 273, -227, 288, -227, 54, -227, 7, -227, -227, -227, + -227, -227, -110, -227, -1, -227, -115, -227, -227, -227, + -227, -76, -227, -227, -53, -227, 77, -227, -227, -90, + -227, -227, 59, -227, 304, -227, -227, -227, 52, -227, + -227, 42, -227, 298, -227, 40, -227, 300, -227, -227, + 16, -227, 39, 10, -227, -227, 99, -227, -227, 360, + -227, -227, -227, 139, -227, 633, 80, 634, 79, 354, + -227, 668, -227, 680, -227, 170, 110, 150, -227, -227, + -227, -227, -227, -227, 685, -227, 686, 102, -227, -227, + 334, -227, 163, -227, -227, 164, -227, -227, 81, -9, + 83, 178, 85, -227, 165, 82, -227, -227, -227, -227, + 292, 319, -227, 96, -33, -40, -39, -227, -227, 90, + -54, -45, -47, -227, -51, 326, 329, -227, -52, -57, + -61, -227, -227, -10, -23, -28, -227, -227, 89, -227, + -227, -227, -227, -227, -227, 385, -227, -227, -227, 91, + -227, -227, -227, 84, -227, 94, -227, 198, -227, -227, + 397, -227, -227, -227, -227, -227, -227, -227, -227, -227, + 325, -227, -227, -227, -227, -227, 93, -227, -227, -227, + -227, -227, 402, -227, -227, 66, -227, -227, -227, -227, + -227, 400, -227, 391, -227, 1, -13, -227, -227, -227, + -227, 281, -227, 277, 338, -227, -227, -227, -227, -227, + -227, 195, -155, -227, -227, -153, -227, -227, -8, -227, + 492, -227, -227, 186, -227, -227, 321, -227, -227, -227, + 310, 296, -227, -24, -156, -154, -157, -227, 289, -227, + -162, -160, -159, -227, -161, 174, -158, -227, -227, -227, + -227, -227, 263, -227, -227, -227, 167, -227, -227, -227, + -170, -227, -227, -227, -227, -227, 302, -227, -227, 100, + -227, -227, -227, -227, -227, -227, -227, 308, -227, 352, + -227, -227, -227, 282, -227, -227, -227, 275, -227, 247, + -227, -227, 342, -227, 153, 245, -227, 526, -26, -227, + -227, -227, -227, -227, -227, -227, -227, -227, -227, -227, + 344, -227, -35, -180, -182, -177, -227, -20, -227, -227, + -227, -227, -227, -227, -227, 33, -227, -227, -227, 4, + -227, -227, -227, -227, -227, -227, -227, -227, -227, -227, + -227, -227, -227, 26, -227, 14, 973, 22, -227, -227, + -227, -227, -4, -5, -227, -227, -227, 173, -227, 6, + -227, -227, -227, -227, -227, -22, -227, -227, -227, -227, + -227, -60, -227, -227, -227, -227, -227, -227, -227, -227, + -227, -227, -227, -227, -227, -227, -227, -227, 28, 24, + -227, 25, -227, -227, 669, -227, -227, -227, 679, 11, + -227, -227, 817, -227, -227, -227, 782, -227, -227, 37, + 32, 827, -11, 23, 36, -227, -30, -227, -227, -227, + -227, -227, 2, -16, -227, -14, -227, -227, -25, 803, + -55, -18, -227, -6, -15, -12, -227, 267, -227, -227, + -227, -227, 29, 27, -227, 210, -227, 35, 34, -227, + -227, 20, -227, -227, 196, 690, 853, -227, 725, 18, + -227, -227, -227, 15, -227, -227, 395, 19, 220, 591, + -227, 13, -227, -227, -227, 3, -227, 197, -227, -227, + -227, -227, -227, -227, 30, -227, 31, -7, -227, -227, + -227, -227, -2, -3, -227, -227 }; const short QmlJSGrammar::action_info [] = { - 632, 945, 905, 912, 881, 906, 757, 908, 447, 818, - 904, 926, 463, 614, 479, 602, 895, -160, -162, 454, - 926, 606, 587, 608, 797, 302, 105, 757, 899, 901, - 624, 907, 919, 781, 105, 654, 105, 898, 169, 454, - 447, 717, 662, 958, 942, 951, 716, 454, 707, 961, - 757, 105, 853, 824, 169, -539, 667, 649, 759, 105, - 479, 647, 703, 926, 105, 465, 465, 926, 479, 926, - 608, 304, 105, 310, 848, 775, 490, 169, 105, 302, - 485, 328, -103, 296, 491, 303, 482, 843, 334, 193, - 496, 223, 733, 169, 223, 290, 516, 169, 198, 105, - 105, 223, 169, 500, 289, 373, 454, 169, 507, 402, - 396, 432, 223, 375, 402, 402, 402, 426, 402, 422, - 424, 408, 410, 418, 287, 406, 105, 447, 454, 449, - 223, 370, 459, 368, 223, 223, 465, 479, 105, 223, - 351, 169, 574, 581, 587, 105, 561, 557, 170, 169, - 521, 350, 430, 581, 193, 328, 512, 357, -537, 810, - 463, 430, 529, 226, 589, 529, 223, 229, 100, -499, - 589, 162, 529, 536, 211, 170, 223, 525, -107, 430, - 368, 195, 535, 208, 548, 302, 554, 430, 902, 105, - 195, 347, 346, 198, 201, 330, -164, 851, 550, 331, - 208, 645, 923, 198, 963, 962, 914, 378, 851, 889, - 92, 577, 576, 198, 793, 820, 198, 852, 198, 532, - -541, 93, 198, 86, 865, 864, 86, 625, 646, 807, - 345, 344, 340, 339, 87, 903, 198, 87, 86, 198, - 990, 989, 520, 519, 198, 388, 626, 198, 704, 87, - 924, 679, 547, 1001, 1000, 381, 890, 689, 86, 808, - 683, 794, 821, 610, 533, 353, 548, 611, 559, 87, - 563, 699, 443, 442, 523, 923, 771, 1008, 748, 747, - -107, 977, 978, 953, 630, 1007, 1006, 379, 186, 482, - 187, 514, 622, 746, 745, 597, 977, 978, 680, -164, - 705, 188, 356, 354, 844, 690, 625, 935, 954, 952, - 694, 965, 910, 186, 95, 187, 198, -542, 849, -164, - 917, 743, 95, 972, 0, 626, 188, 627, 744, 223, - -207, 198, 849, 355, 186, -208, 187, 926, 368, 402, - 186, -373, 187, 891, 223, 849, -373, 188, -164, 95, - 849, 892, 846, 188, 868, 0, 368, 0, 0, 96, - 846, 936, 934, 893, 845, 97, 846, 96, 208, 543, - 542, 849, 845, 97, 918, 916, 0, 186, 845, 187, - 846, 1004, 1003, -207, 199, 197, 173, 174, -208, 0, - 188, -373, 845, 846, 96, 173, 174, 616, 846, 0, - 97, 616, 0, 539, 198, 845, 0, 0, 869, 867, - 845, 173, 174, 175, 176, 0, 617, 0, 743, 846, - 617, 616, 175, 176, 616, 744, 0, 0, 966, 0, - 1002, 845, 364, 365, 997, 722, 723, 591, 175, 176, - 617, 0, 714, 617, 441, 618, 616, 0, 998, 996, - 179, 180, 0, 722, 723, 0, 592, 0, 593, 182, - 179, 180, 183, 616, 184, 617, 0, 714, 0, 182, - 0, 0, 183, 616, 184, 6, 5, 4, 1, 3, - 2, -80, 617, 0, 618, 61, 75, 179, 180, 61, - 75, -80, 617, 0, 618, 181, 182, 995, 0, 183, - 857, 184, 0, 857, 752, 0, 179, 180, 0, 61, - 75, 0, 61, 75, 181, 182, 208, 0, 183, 0, - 184, 0, 173, 174, 857, 61, 75, 753, 857, 0, - 0, 0, 0, 0, 61, 75, 0, 0, 0, 860, - 863, 861, 860, 863, 861, 0, 0, 0, 0, 175, - 176, 61, 75, 0, 0, 0, 0, 754, 0, 0, - 0, 61, 75, 860, 863, 861, 0, 860, 863, 861, - 0, 151, 0, 855, 52, 0, 855, 0, 0, 0, - 364, 365, 858, 856, 862, 858, 856, 862, 0, 0, - 0, 0, 441, 52, 0, 859, 0, 855, 859, 0, - 0, 855, 0, 0, 0, 0, 858, 856, 862, 52, - 858, 856, 862, 68, 71, 69, 0, 0, 0, 859, - 0, 0, 0, 859, 0, 0, 0, 0, 0, 0, - 851, 0, 68, 71, 69, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 857, 72, 0, 49, 68, 71, - 69, 0, 0, 0, 0, 43, 64, 51, 70, 0, - 0, 52, 0, 0, 72, 0, 49, 0, 0, 65, - 0, 0, 0, 0, 43, 64, 51, 70, 0, 52, - 72, 0, 49, 860, 863, 861, 447, 0, 65, 0, - 43, 64, 51, 70, 0, 0, 0, 0, 0, 0, - 68, 71, 69, 0, 65, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 52, 0, 0, 855, 68, 71, - 69, 0, 0, 0, 0, 0, 858, 856, 862, 0, - 0, 463, 72, 0, 49, 0, 0, 52, 0, 859, - 0, 52, 43, 64, 51, 70, 0, 0, 0, 0, - 72, 0, 49, 68, 71, 69, 65, 0, 0, 0, - 43, 64, 51, 70, 0, 0, 0, 0, 0, 0, - 0, 444, 0, 0, 65, 0, 68, 71, 69, 0, - 68, 71, 69, 0, 463, 72, 0, 49, 52, 0, - 0, 0, 219, 220, 0, 43, 64, 51, 70, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 72, 65, - 49, 52, 72, 0, 49, 219, 220, 0, 43, 64, - 51, 70, 43, 64, 51, 70, 0, 68, 71, 69, - 0, 0, 65, 0, 52, 0, 65, 0, 52, 0, - 0, 772, 0, 0, 0, 447, 0, 0, 0, 0, - 68, 71, 69, 0, 0, 0, 0, 0, 0, 72, - 0, 49, 0, 0, 0, 0, 0, 0, 773, 43, - 64, 51, 70, 68, 71, 69, 0, 68, 71, 69, - 0, 0, 72, 65, 49, 0, 0, 0, 0, 0, - 0, 0, 43, 64, 51, 70, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 72, 65, 49, 0, 72, - 52, 49, 0, 0, 52, 43, 64, 51, 70, 43, - 64, 51, 70, 0, 0, 0, 0, 0, 0, 65, - 52, 0, 0, 65, 0, 52, 0, 645, 0, 219, - 220, 0, 343, 342, 0, 0, 338, 337, 0, 68, - 71, 69, 0, 68, 71, 69, 0, 0, 0, 0, - 0, 0, 0, 0, 646, 0, 0, 0, 0, 68, - 71, 69, 0, 0, 68, 71, 69, 0, 0, 0, - 0, 72, 0, 49, 0, 72, 0, 49, 0, 0, - 0, 43, 64, 51, 70, 43, 64, 51, 70, 0, - 0, 72, 0, 49, 0, 65, 72, 0, 49, 65, - 0, 43, 64, 51, 70, 0, 43, 64, 51, 70, - 0, 0, 0, 0, 0, 65, 0, 52, 0, 0, - 65, 807, 52, 0, 0, 0, 219, 220, 0, 313, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 314, - 0, 0, 0, 385, 0, 0, 0, 0, 0, 0, - 0, 808, 316, 0, 317, 759, 68, 71, 69, 0, - 0, 68, 71, 69, 0, 318, 0, 319, 92, 0, - 0, 0, 0, 0, 0, 320, 0, 0, 321, 93, - 0, 0, 0, 0, 322, 0, 0, 0, 72, 0, - 49, 324, 323, 72, 0, 49, 0, 0, 43, 64, - 51, 70, 0, 43, 64, 51, 70, 0, 325, 0, - 0, 0, 65, 0, 0, 313, 0, 65, 0, 52, - 0, 0, 0, 219, 220, 314, 0, 0, 0, 385, - 0, 0, 0, 0, 0, 0, 0, 0, 316, 0, - 317, 0, 0, 378, 0, 0, 0, 0, 0, 0, - 0, 318, 0, 319, 92, 0, 0, 0, 68, 71, - 69, 320, 0, 0, 321, 93, 0, 0, 0, 0, - 322, 0, 0, 0, 0, 0, 0, 324, 323, 0, - 0, 0, 0, 0, 0, 218, 0, 0, 0, 0, - 72, 0, 49, 0, 325, 0, 0, 0, 0, 0, - 43, 64, 51, 70, 0, 0, 0, 0, 0, 0, - 0, 0, 46, 47, 65, 0, 313, 0, 0, 0, - 0, 0, 50, 379, 0, 0, 314, 0, 0, 52, - 315, 0, 0, 53, 54, 0, 55, 0, 0, 316, - 0, 317, 0, 835, 0, 0, 0, 63, 0, 0, - 0, 0, 318, 0, 319, 92, 0, 0, 0, 0, - 0, 0, 320, 0, 0, 321, 93, 73, 68, 71, - 69, 322, 76, 0, 0, 0, 0, 0, 324, 323, - 0, 0, 0, 62, 78, 48, 0, 0, 0, 0, - 58, 0, 0, 0, 0, 325, 0, 74, 44, 0, - 72, 0, 49, 61, 75, 0, 0, 0, 0, 0, - 43, 64, 51, 70, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 65, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, - 47, 0, 0, 0, 0, 0, 0, 0, 0, 50, - 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, - 53, 54, 0, 55, 0, 0, 0, 0, 0, 0, - 835, 0, 0, 0, 63, 0, 0, 0, 0, 0, + 650, 917, 939, 644, 107, 654, 793, 224, 657, 962, + 506, 107, 508, 521, 937, 171, 633, 777, -178, 306, + 995, 1050, 1049, 991, 976, 489, -176, 936, 670, 962, + 729, 625, 877, 775, 890, 931, 643, 983, 733, 775, + 888, 631, 489, 688, 107, 1011, 508, 1005, -92, 693, + 107, 496, 837, 1008, 988, 521, 1003, 954, 870, 224, + 496, 107, 843, 962, 829, 171, 942, 945, 872, 962, + 885, 800, 943, 775, 944, 671, 673, 224, 107, 107, + 521, 171, 946, 224, 888, 107, 816, 347, 306, 436, + 496, 949, 224, 679, 171, 201, 390, 407, 391, 224, + 379, 373, 414, 347, 355, 412, 465, 195, 349, 502, + 335, 447, 224, 224, 306, 348, 107, 409, 341, 306, + 496, 506, 467, -546, 306, 489, 491, 469, 443, 475, + 334, 443, 224, 443, 443, 566, 451, 373, 449, 195, + 172, 558, 107, 473, 753, 197, 644, 396, 171, 601, + 407, 625, 1055, -544, 332, 306, 312, 291, 107, 297, + 633, 164, -115, -505, 631, 224, 298, 347, 306, 309, + 171, 306, 306, 224, 214, 102, 172, 171, 605, 211, + 295, 107, -110, 562, 580, 581, 574, 224, 171, 574, + 574, 570, 534, 224, 527, 224, 107, 533, 107, 224, + 496, 224, 197, 619, 107, 489, 540, 508, 839, 592, + 552, 524, 201, 473, 594, 958, 473, 201, 940, 812, + 171, 826, 171, 204, 0, 958, -180, 888, 375, 201, + 591, 417, 376, 544, 598, 888, 0, 951, 88, -548, + 521, 888, 646, 279, 592, 889, 647, 584, 201, 201, + 89, 985, 827, 460, 202, 200, 0, 840, 577, 202, + 200, 202, 200, 280, 201, 1021, 560, 941, 813, 202, + 200, 393, 88, 925, 201, 959, 202, 200, 301, 278, + 709, 202, 200, 201, 89, 202, 200, 88, 202, 200, + 202, 200, 202, 200, 94, 302, 202, 200, 705, 89, + 202, 200, 730, 568, 201, 578, 95, 202, 200, 201, + 524, -115, 725, 418, 641, 88, 1026, 1027, 202, 200, + 202, 200, 926, 202, 200, 202, 200, 89, 420, 715, + 201, 188, -180, 189, 1026, 1027, 953, 427, 886, -180, + 905, 886, 763, 927, 190, 981, 886, 706, 407, 306, + 764, 720, 928, 1014, 202, 200, 731, 997, 603, 970, + 886, 947, -223, 607, 929, 886, 407, 0, 188, -180, + 189, 443, -549, -224, 881, 201, 201, 0, 279, 716, + 962, 190, 306, 202, 200, 202, 200, 883, 233, 97, + 883, 886, 202, 200, 883, 883, 202, 200, 280, 882, + 655, 0, 882, 97, 1052, 0, 882, 882, 234, 883, + 883, 188, 97, 189, 883, 202, 200, -223, 485, 211, + 0, 882, 882, 883, 190, 283, 882, 0, -224, 202, + 200, 202, 200, -388, 0, 882, 98, 0, -388, 0, + 883, 188, 99, 189, 188, 0, 189, 0, 742, 743, + 98, 233, 882, 0, 190, 1045, 99, 190, 0, 98, + 395, 175, 176, 175, 176, 99, 742, 743, 202, 200, + 0, 234, 0, 1015, 0, 763, 175, 176, 0, 62, + 77, 175, 176, 764, 0, -388, 181, 182, 0, 177, + 178, 177, 178, 233, 0, 184, 790, 953, 185, 233, + 186, 485, 211, 635, 177, 178, 233, 0, 0, 177, + 178, 0, 0, 234, 0, 286, 0, 0, 1044, 234, + 0, 652, 0, 636, 0, 637, 234, 0, 286, 6, + 5, 4, 1, 3, 2, 0, 181, 182, 0, 233, + 0, 0, 62, 77, 183, 184, 0, 0, 185, 0, + 186, 233, 0, 202, 200, 0, 0, 0, -86, 234, + 0, 652, 0, 0, 0, 0, 0, 403, 404, 0, + -86, 234, 0, 652, 181, 182, 894, 0, 0, 484, + 770, 0, 183, 184, 62, 77, 185, 0, 186, 0, + 62, 77, 485, 211, 62, 77, 0, 62, 77, 0, + 0, 0, 0, 0, 771, 894, 0, 0, 0, 0, + 0, 0, 894, 0, 0, 0, 897, 901, 898, 0, + 181, 182, 0, 0, 0, 0, 0, 0, 0, 184, + 62, 77, 185, 0, 186, 772, 0, 0, 0, 0, + 0, 0, 62, 77, 0, 897, 901, 898, 888, 153, + 892, 899, 897, 901, 898, 0, 0, 0, 403, 404, + 895, 893, 900, 894, 0, 0, 0, 0, 0, 0, + 484, 0, 0, 896, 0, 0, 0, 0, 0, 892, + 899, 0, 0, 0, 888, 0, 892, 899, 0, 895, + 893, 900, 0, 0, 0, 0, 895, 893, 900, 894, + 0, 0, 896, 897, 901, 898, 0, 0, 888, 896, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 73, 68, 71, 69, 0, 76, + 0, 0, 0, 894, 0, 0, 894, 0, 0, 0, + 53, 0, 0, 0, 0, 0, 0, 892, 899, 897, + 901, 898, 0, 0, 0, 0, 0, 895, 893, 900, + 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 896, 0, 0, 897, 901, 898, 897, 901, 898, 0, + 69, 73, 70, 892, 899, 0, 0, 53, 0, 0, + 0, 0, 0, 895, 893, 900, 0, 0, 0, 0, + 69, 73, 70, 0, 0, 0, 896, 892, 899, 0, + 892, 899, 74, 53, 49, 71, 0, 895, 893, 900, + 895, 893, 900, 43, 65, 52, 72, 69, 73, 70, + 896, 0, 74, 896, 49, 71, 888, 66, 0, 0, + 0, 0, 0, 43, 65, 52, 72, 0, 0, 0, + 0, 894, 0, 69, 73, 70, 0, 66, 0, 74, + 0, 49, 71, 0, 0, 0, 0, 0, 0, 0, + 43, 65, 52, 72, 0, 53, 0, 0, 0, 0, + 53, 0, 0, 0, 66, 74, 0, 49, 71, 0, + 0, 897, 901, 898, 0, 0, 43, 65, 52, 72, + 0, 53, 0, 0, 0, 0, 0, 0, 0, 0, + 66, 0, 0, 0, 0, 69, 73, 70, 0, 0, + 69, 73, 70, 0, 0, 892, 899, 0, 0, 0, + 0, 0, 0, 0, 0, 895, 893, 900, 0, 0, + 0, 69, 73, 70, 0, 0, 0, 74, 896, 49, + 71, 999, 74, 0, 49, 71, 0, 0, 43, 65, + 52, 72, 0, 43, 65, 52, 72, 0, 0, 0, + 0, 0, 66, 74, 0, 49, 71, 66, 0, 0, + 0, 53, 0, 0, 43, 65, 52, 72, 489, 0, + 0, 897, 901, 898, 0, 0, 0, 0, 66, 53, + 883, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 882, 0, 0, 0, 0, 0, 0, 0, + 0, 69, 73, 70, 0, 892, 899, 0, 0, 0, + 0, 0, 0, 0, 0, 895, 893, 900, 0, 69, + 73, 70, 0, 0, 0, 0, 0, 53, 896, 0, + 0, 999, 0, 74, 791, 49, 71, 0, 0, 0, + 0, 0, 0, 0, 43, 65, 52, 72, 0, 0, + 506, 74, 0, 49, 71, 0, 0, 0, 66, 0, + 0, 0, 43, 65, 52, 72, 0, 69, 73, 70, + 0, 897, 901, 898, 0, 0, 66, 0, 53, 0, + 883, 0, 0, 0, 0, 670, 0, 0, 0, 0, + 0, 0, 882, 53, 0, 0, 0, 0, 0, 74, + 489, 49, 71, 0, 0, 892, 899, 0, 0, 0, + 43, 65, 52, 72, 53, 895, 893, 900, 69, 73, + 70, 0, 0, 0, 66, 0, 0, 0, 896, 0, + 0, 53, 0, 69, 73, 70, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 202, 200, 0, + 74, 0, 49, 71, 69, 73, 70, 0, 0, 0, + 0, 43, 65, 52, 72, 74, 0, 49, 71, 0, + 0, 69, 73, 70, 0, 66, 43, 65, 52, 72, + 0, 0, 0, 0, 0, 0, 74, 0, 49, 71, + 66, 0, 53, 0, 0, 0, 0, 43, 65, 52, + 72, 0, 506, 74, 0, 49, 71, 0, 0, 0, + 0, 66, 0, 0, 43, 65, 52, 72, 0, 0, + 0, 0, 0, 0, 0, 202, 200, 0, 66, 0, + 0, 53, 69, 73, 70, 222, 223, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 62, 78, 48, 0, 0, 0, 0, 58, 0, 0, - 0, 0, 0, 0, 74, 44, 0, 72, 0, 49, - 61, 75, 0, 0, 0, 0, 0, 43, 64, 51, + 0, 0, 0, 0, 0, 53, 0, 0, 0, 826, + 0, 0, 0, 0, 74, 0, 49, 71, 0, 0, + 0, 69, 73, 70, 0, 43, 65, 52, 72, 53, + 0, 0, 0, 222, 223, 0, 0, 0, 0, 66, + 827, 0, 0, 0, 777, 69, 73, 70, 0, 0, + 0, 0, 0, 74, 0, 49, 71, 53, 0, 0, + 0, 222, 223, 0, 43, 65, 52, 72, 0, 69, + 73, 70, 0, 0, 0, 0, 0, 74, 66, 49, + 71, 53, 0, 0, 0, 222, 223, 0, 43, 65, + 52, 72, 0, 0, 0, 0, 221, 69, 73, 70, + 0, 74, 66, 49, 71, 0, 0, 0, 0, 0, + 0, 0, 43, 65, 52, 72, 0, 0, 0, 0, + 0, 69, 73, 70, 221, 0, 66, 0, 0, 74, + 0, 49, 71, 0, 0, 0, 0, 0, 0, 0, + 43, 65, 52, 72, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 74, 66, 49, 71, 0, 0, 0, + 0, 0, 0, 0, 43, 65, 52, 72, 53, 0, + 0, 0, 222, 223, 0, 0, 0, 0, 66, 0, + 0, 358, 0, 53, 0, 0, 0, 222, 223, 0, + 0, 359, 0, 0, 0, 360, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 361, 0, 362, 69, 73, + 70, 0, 0, 0, 0, 0, 0, 0, 363, 0, + 364, 94, 0, 69, 73, 70, 0, 0, 0, 365, + 0, 0, 366, 95, 0, 221, 0, 0, 367, 0, + 74, 0, 49, 71, 0, 369, 368, 0, 0, 0, + 221, 43, 65, 52, 72, 74, 0, 49, 71, 0, + 0, 0, 370, 358, 0, 66, 43, 65, 52, 72, + 0, 0, 0, 359, 0, 0, 0, 424, 0, 0, + 66, 0, 0, 0, 0, 0, 0, 361, 0, 362, + 0, 0, 0, 53, 0, 0, 0, 222, 223, 0, + 363, 0, 364, 94, 0, 0, 0, 0, 53, 0, + 0, 365, 222, 223, 366, 95, 0, 0, 0, 0, + 367, 0, 0, 0, 0, 0, 0, 369, 368, 0, + 0, 0, 0, 69, 73, 70, 0, 0, 0, 0, + 0, 0, 0, 0, 370, 0, 0, 0, 69, 73, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 65, 0, 46, 47, 0, 0, 0, 0, 0, - 0, 0, 0, 50, 0, 0, 0, 0, 0, 0, - 52, 0, 0, 0, 53, 54, 0, 55, 0, 0, - 0, 0, 0, 0, 59, 0, 0, 0, 63, 0, + 221, 0, 0, 0, 0, 74, 0, 49, 71, 0, + 0, 0, 0, 0, 0, 221, 43, 65, 52, 72, + 74, 0, 49, 71, 0, 0, 0, 0, 0, 0, + 66, 43, 65, 52, 72, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 66, 0, 0, 53, 0, + 0, 0, 222, 223, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 73, 68, - 71, 69, 0, 76, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 62, 78, 48, 0, 0, 0, - 0, 58, 0, 0, 0, 0, 0, 0, 74, 44, - 0, 72, 0, 49, 61, 75, 0, 0, 0, 0, - 0, 43, 64, 51, 70, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 65, 0, 46, 47, 0, - 713, 0, 0, 0, 0, 0, 0, 50, 0, 0, - 0, 0, 0, 0, 52, 0, 0, 0, 53, 54, - 0, 55, 0, 0, 0, 0, 0, 0, 835, 0, - 0, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 73, 68, 71, 69, 0, 76, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 62, 78, - 48, 0, 0, 0, 0, 58, 0, 0, 0, 0, - 0, 0, 74, 44, 0, 72, 0, 49, 61, 75, - 0, 0, 0, 0, 0, 43, 64, 51, 70, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, - 0, 46, 47, 0, 713, 0, 0, 0, 0, 0, - 0, 50, 0, 0, 0, 0, 0, 0, 52, 0, - 0, 0, 53, 54, 0, 55, 0, 0, 0, 0, - 0, 0, 59, 0, 0, 0, 63, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 73, 68, 71, 69, - 0, 76, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 62, 78, 48, 0, 0, 0, 0, 58, - 0, 0, 0, 0, 0, 0, 74, 44, 0, 72, - 0, 49, 61, 75, 0, 0, 0, 0, 0, 43, - 64, 51, 70, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 65, 0, 832, 0, 46, 47, 0, - 0, 0, 0, 0, 0, 0, 0, 834, 0, 0, - 0, 0, 0, 0, 52, 0, 0, 0, 53, 54, - 0, 55, 0, 0, 0, 0, 0, 0, 835, 0, - 0, 0, 63, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 73, 836, 838, 837, 0, 76, 0, 0, - 0, 0, 151, 0, 0, 0, 0, 0, 62, 78, - 48, 0, 0, 0, 0, 58, 0, 0, 0, 833, - 0, 0, 74, 44, 0, 72, 0, 49, 61, 75, - 0, 0, 0, 0, 0, 43, 64, 51, 70, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, - 0, 832, 0, 46, 47, 0, 0, 0, 0, 0, - 0, 0, 0, 834, 0, 0, 0, 0, 0, 0, - 52, 0, 0, 0, 53, 54, 0, 55, 0, 0, - 0, 0, 0, 0, 835, 0, 0, 0, 63, 0, - 0, 0, 0, 0, 0, 0, 928, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 73, 836, - 838, 837, 0, 76, 0, 0, 0, 0, 151, 0, - 0, 0, 0, 0, 62, 78, 48, 0, 0, 0, - 0, 58, 0, 0, 0, 833, 0, 0, 74, 44, - 0, 72, 0, 49, 61, 75, 0, 0, 0, 0, - 0, 43, 64, 51, 70, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 65, 0, 832, 0, 46, - 47, 0, 0, 0, 0, 0, 0, 0, 0, 834, - 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, - 53, 54, 0, 55, 0, 0, 0, 0, 0, 0, - 835, 0, 0, 0, 63, 0, 0, 0, 0, 0, - 0, 0, 931, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 73, 836, 838, 837, 0, 76, - 0, 0, 0, 0, 151, 0, 0, 0, 0, 0, - 62, 78, 48, 0, 0, 0, 0, 58, 0, 0, - 0, 833, 0, 0, 74, 44, 0, 72, 0, 49, - 61, 75, 0, 0, 0, 0, 0, 43, 64, 51, + 0, 0, 0, 0, 0, 0, 0, 0, 69, 73, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 65, 0, 45, 46, 47, 0, 0, 0, 0, - 0, 0, 0, 0, 50, 0, 0, 0, 0, 0, - 0, 52, 0, 0, 0, 53, 54, 0, 55, 0, - 0, 0, 56, 0, 57, 59, 60, 0, 0, 63, - 0, 0, 0, 66, 0, 67, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 73, - 68, 71, 69, 0, 76, 0, 77, 0, 79, 0, - 80, 0, 0, 0, 0, 62, 78, 48, 0, 0, - 0, 0, 58, 0, 0, 0, 0, 0, 0, 74, - 44, 0, 72, 0, 49, 61, 75, 0, 0, 0, - 0, 0, 43, 64, 51, 70, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 65, 0, 45, 46, - 47, 0, 0, 0, 0, 0, 0, 0, 0, 50, - 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, - 53, 54, 0, 55, 0, 0, 0, 56, 0, 57, - 59, 60, 0, 0, 63, 0, 0, 0, 66, 0, - 67, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 73, 68, 71, 69, 0, 76, - 0, 77, 0, 79, 0, 80, 0, 0, 0, 0, - 62, 78, 48, 0, 0, 0, 0, 58, 0, 0, - 0, 0, 0, 81, 74, 44, 0, 72, 0, 49, - 61, 75, 0, 0, 0, 0, 0, 43, 64, 51, - 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 65, 0, 45, 46, 47, 0, 0, 0, 0, - 0, 0, 0, 0, 50, 0, 0, 0, 0, 0, - 0, 52, 0, 0, 0, 53, 54, 0, 55, 0, - 0, 0, 56, 0, 57, 59, 60, 0, 0, 63, - 0, 0, 0, 66, 0, 67, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 73, - 68, 71, 69, 0, 76, 0, 77, 0, 79, 0, - 80, 0, 0, 0, 0, 62, 78, 48, 0, 0, - 0, 0, 58, 0, 0, 0, 0, 0, 154, 74, - 44, 0, 72, 0, 49, 61, 75, 0, 0, 0, - 0, 0, 43, 64, 51, 70, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 65, 0, 45, 46, - 47, 0, 0, 0, 0, 0, 0, 0, 0, 50, - 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, - 53, 54, 0, 55, 0, 0, 0, 56, 0, 57, - 59, 60, 0, 0, 63, 0, 0, 0, 66, 0, - 67, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 73, 68, 71, 69, 0, 76, - 0, 77, 0, 79, 0, 80, 0, 0, 0, 0, - 62, 78, 48, 0, 0, 0, 0, 58, 0, 0, - 0, 0, 601, 154, 74, 44, 0, 72, 0, 49, - 61, 75, 0, 0, 0, 0, 0, 43, 64, 51, - 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 65, 0, 310, 0, 0, 45, 46, 47, 0, - 0, 0, 0, 0, 0, 0, 0, 50, 0, 0, - 0, 0, 0, 0, 52, 0, 0, 0, 53, 54, - 0, 55, 0, 0, 0, 56, 0, 57, 59, 60, - 0, 0, 63, 0, 0, 0, 66, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 73, 68, 71, 69, 0, 76, 0, 77, - 0, 79, 0, 80, 0, 0, 0, 0, 62, 78, - 48, 0, 0, 0, 0, 58, 0, 0, 0, 0, - 0, 154, 74, 44, 0, 72, 0, 49, 61, 75, - 0, 0, 0, 0, 0, 43, 64, 51, 70, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, + 0, 0, 0, 0, 0, 221, 0, 0, 0, 0, + 74, 0, 49, 71, 0, 0, 0, 0, 0, 0, + 0, 43, 65, 52, 72, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 66, 0, 0, 358, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 359, 0, + 0, 0, 424, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 361, 0, 362, 0, 0, 417, 0, 0, + 0, 0, 0, 0, 0, 363, 0, 364, 94, 0, + 0, 0, 0, 0, 0, 0, 365, 0, 0, 366, + 95, 0, 0, 0, 0, 367, 0, 0, 0, 0, + 0, 0, 369, 368, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 370, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 418, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 46, 47, 0, 0, 0, + 0, 0, 0, 0, 0, 51, 50, 0, 0, 0, + 0, 0, 0, 53, 0, 0, 0, 54, 55, 0, + 56, 0, 0, 0, 0, 0, 0, 229, 0, 0, + 0, 64, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 75, 69, 73, 70, 0, 78, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 63, 80, + 48, 0, 0, 0, 0, 59, 0, 0, 0, 0, + 0, 0, 76, 44, 0, 74, 0, 49, 71, 62, + 77, 0, 0, 0, 0, 0, 43, 65, 52, 72, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 66, 0, 0, 46, 47, 0, 0, 0, 0, 0, + 0, 0, 0, 51, 50, 0, 0, 0, 0, 0, + 0, 53, 0, 0, 0, 54, 55, 0, 56, 0, + 0, 0, 0, 0, 0, 60, 0, 0, 0, 64, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 75, 69, 73, 70, 0, 78, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 63, 80, 48, 0, + 0, 0, 0, 59, 0, 0, 0, 0, 0, 0, + 76, 44, 0, 74, 0, 49, 71, 62, 77, 0, + 0, 0, 0, 0, 43, 65, 52, 72, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 0, + 0, 46, 47, 0, 0, 0, 0, 0, 0, 0, + 0, 51, 50, 0, 0, 0, 0, 0, 0, 53, + 0, 0, 0, 54, 55, 0, 56, 0, 0, 0, + 0, 0, 0, 229, 0, 0, 0, 64, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 75, 69, + 73, 70, 0, 78, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 63, 80, 48, 0, 0, 0, + 230, 59, 0, 0, 0, 0, 0, 0, 76, 44, + 0, 74, 0, 49, 71, 62, 77, 0, 0, 0, + 0, 0, 43, 65, 52, 72, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 0, 0, 46, + 47, 0, 285, 0, 0, 0, 0, 0, 0, 51, + 50, 0, 0, 0, 0, 0, 0, 53, 0, 0, + 0, 54, 55, 0, 56, 0, 0, 0, 0, 0, + 0, 229, 0, 0, 0, 64, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 75, 69, 73, 70, + 0, 78, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 63, 80, 48, 0, 0, 0, 0, 59, + 0, 0, 0, 0, 0, 0, 76, 44, 0, 74, + 0, 49, 71, 62, 77, 0, 0, 0, 0, 0, + 43, 65, 52, 72, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 66, 0, 0, 46, 47, 0, + 285, 0, 0, 0, 0, 0, 0, 51, 50, 0, + 0, 0, 0, 0, 0, 53, 0, 0, 0, 54, + 55, 0, 56, 0, 0, 0, 0, 0, 0, 60, + 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 75, 69, 73, 70, 0, 78, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 63, 80, 48, 0, 0, 0, 0, 59, 0, 0, + 0, 0, 0, 0, 76, 44, 0, 74, 0, 49, + 71, 62, 77, 0, 0, 0, 0, 0, 43, 65, + 52, 72, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 0, 0, 852, 0, 46, 47, 0, + 0, 0, 0, 0, 0, 0, 0, 855, 854, 0, + 0, 0, 0, 0, 0, 53, 0, 0, 0, 54, + 55, 0, 56, 0, 0, 0, 0, 0, 0, 229, + 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 75, 856, 859, 857, 0, 78, + 0, 0, 0, 0, 153, 0, 0, 0, 0, 0, + 63, 80, 48, 0, 0, 0, 0, 59, 0, 0, + 0, 853, 0, 0, 76, 44, 0, 74, 0, 49, + 858, 62, 77, 0, 0, 0, 0, 0, 43, 65, + 52, 72, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 0, 0, 852, 0, 46, 47, 0, + 0, 0, 0, 0, 0, 0, 0, 855, 854, 0, + 0, 0, 0, 0, 0, 53, 0, 0, 0, 54, + 55, 0, 56, 0, 0, 0, 0, 0, 0, 229, + 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 964, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 75, 856, 859, 857, 0, 78, + 0, 0, 0, 0, 153, 0, 0, 0, 0, 0, + 63, 80, 48, 0, 0, 0, 0, 59, 0, 0, + 0, 853, 0, 0, 76, 44, 0, 74, 0, 49, + 858, 62, 77, 0, 0, 0, 0, 0, 43, 65, + 52, 72, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 0, 0, 852, 0, 46, 47, 0, + 0, 0, 0, 0, 0, 0, 0, 855, 854, 0, + 0, 0, 0, 0, 0, 53, 0, 0, 0, 54, + 55, 0, 56, 0, 0, 0, 0, 0, 0, 229, + 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 967, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 75, 856, 859, 857, 0, 78, + 0, 0, 0, 0, 153, 0, 0, 0, 0, 0, + 63, 80, 48, 0, 0, 0, 0, 59, 0, 0, + 0, 853, 0, 0, 76, 44, 0, 74, 0, 49, + 858, 62, 77, 0, 0, 0, 0, 0, 43, 65, + 52, 72, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 0, 0, 45, 46, 47, 0, 0, + 0, 0, 0, 0, 0, 0, 51, 50, 0, 0, + 0, 0, 0, 0, 53, 0, 0, 0, 54, 55, + 0, 56, 0, 0, 0, 57, 0, 58, 60, 61, + 0, 0, 64, 0, 0, 0, 0, 67, 0, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 75, 69, 73, 70, 0, 78, 0, + 79, 0, 81, 0, 82, 0, 0, 0, 0, 63, + 80, 48, 0, 0, 0, 0, 59, 0, 0, 0, + 0, 0, 0, 76, 44, 0, 74, 0, 49, 71, + 62, 77, 0, 0, 0, 0, 0, 43, 65, 52, + 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 66, 0, 0, 45, 46, 47, 0, 0, 0, + 0, 0, 0, 0, 0, 51, 50, 0, 0, 0, + 0, 0, 0, 53, 0, 0, 0, 54, 55, 0, + 56, 0, 0, 0, 57, 0, 58, 60, 61, 0, + 0, 64, 0, 0, 0, 0, 67, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 75, 69, 73, 70, 0, 78, 0, 79, + 0, 81, 0, 82, 0, 0, 0, 0, 63, 80, + 48, 0, 0, 0, 0, 59, 0, 0, 0, 0, + 0, 156, 76, 44, 0, 74, 0, 49, 71, 62, + 77, 0, 0, 0, 0, 0, 43, 65, 52, 72, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 66, 0, 0, 45, 46, 47, 0, 0, 0, 0, + 0, 0, 0, 0, 51, 50, 0, 0, 0, 0, + 0, 0, 53, 0, 0, 0, 54, 55, 0, 56, + 0, 0, 0, 57, 0, 58, 60, 61, 0, 0, + 64, 0, 0, 0, 0, 67, 0, 68, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 75, 69, 73, 70, 0, 78, 0, 79, 0, + 81, 0, 82, 0, 0, 0, 0, 63, 80, 48, + 0, 0, 0, 0, 59, 0, 0, 0, 0, 0, + 83, 76, 44, 0, 74, 0, 49, 71, 62, 77, + 0, 0, 0, 0, 0, 43, 65, 52, 72, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 66, + 0, 0, 45, 46, 47, 0, 0, 0, 0, 0, + 0, 0, 0, 51, 50, 0, 0, 0, 0, 0, + 0, 53, 0, 0, 0, 54, 55, 0, 56, 0, + 0, 0, 57, 0, 58, 60, 61, 0, 0, 64, + 0, 0, 0, 0, 67, 0, 68, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 75, 69, 73, 70, 0, 78, 0, 79, 0, 81, + 0, 82, 0, 0, 0, 0, 63, 80, 48, 0, + 0, 0, 0, 59, 0, 0, 0, 0, 0, 83, + 76, 44, 0, 74, 0, 49, 71, 62, 77, 0, + 0, 0, 0, 0, 43, 65, 52, 72, 0, 0, + 0, 0, 0, 0, 0, 0, 105, 0, 66, 0, 0, 45, 46, 47, 0, 0, 0, 0, 0, 0, - 0, 0, 50, 0, 0, 0, 0, 0, 0, 52, - 0, 0, 0, 53, 54, 0, 55, 0, 0, 0, - 56, 0, 57, 59, 60, 0, 0, 63, 0, 0, - 0, 66, 0, 67, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 73, 68, 71, - 69, 0, 76, 0, 77, 0, 79, 0, 80, 0, - 0, 0, 0, 62, 78, 48, 0, 0, 0, 0, - 58, 0, 0, 0, 0, 218, 154, 74, 44, 0, - 72, 0, 49, 61, 75, 0, 0, 0, 0, 0, - 43, 64, 51, 70, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 65, 0, 45, 46, 47, 0, - 0, 0, 0, 0, 0, 0, 0, 50, 0, 0, - 0, 0, 0, 0, 52, 0, 0, 0, 53, 54, - 0, 55, 0, 0, 0, 56, 0, 57, 59, 60, - 0, 0, 63, 0, 0, 0, 66, 0, 67, 0, + 0, 0, 51, 50, 0, 0, 0, 0, 0, 0, + 53, 0, 0, 0, 54, 55, 0, 56, 0, 0, + 0, 57, 0, 58, 60, 61, 0, 0, 64, 0, + 0, 0, 0, 67, 0, 68, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 75, + 69, 73, 70, 0, 78, 0, 79, 0, 81, 0, + 82, 0, 0, 0, 0, 63, 80, 48, 0, 0, + 0, 0, 59, 0, 0, 0, 0, 0, 156, 76, + 44, 0, 74, 0, 49, 71, 62, 77, 0, 0, + 0, 0, 0, 43, 65, 52, 72, 0, 0, 0, + 0, 0, 0, 0, 780, 0, 0, 66, 0, 0, + 347, 0, 0, 45, 46, 47, 0, 0, 0, 0, + 0, 0, 0, 0, 51, 50, 0, 0, 0, 0, + 0, 0, 53, 0, 0, 0, 54, 55, 0, 56, + 0, 0, 0, 57, 0, 58, 60, 61, 0, 0, + 64, 0, 0, 0, 0, 67, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 73, 68, 71, 69, 0, 76, 0, 77, - 0, 79, 0, 80, 0, 0, 0, 0, 62, 78, - 48, 0, 0, 0, 0, 58, 0, 0, 0, 0, - 604, 154, 74, 44, 0, 72, 0, 49, 61, 75, - 0, 0, 0, 0, 0, 43, 64, 51, 70, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, - 0, 302, 0, 0, 45, 46, 47, 0, 0, 0, - 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, - 0, 0, 52, 0, 0, 0, 53, 54, 0, 55, - 0, 0, 0, 56, 0, 57, 59, 60, 0, 0, - 63, 0, 0, 0, 66, 0, 67, 0, 0, 0, + 0, 75, 69, 73, 70, 0, 78, 0, 79, 0, + 81, 0, 82, 0, 0, 0, 0, 63, 80, 48, + 0, 0, 0, 0, 59, 0, 0, 0, 0, 0, + 156, 76, 44, 0, 74, 0, 49, 71, 62, 77, + 0, 0, 0, 0, 0, 43, 65, 52, 72, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 66, + 0, 0, 45, 46, 47, 0, 0, 0, 0, 0, + 0, 0, 0, 51, 50, 0, 0, 0, 0, 0, + 0, 53, 0, 0, 0, 54, 55, 0, 56, 0, + 0, 0, 57, 0, 58, 60, 61, 0, 0, 64, + 0, 0, 0, 0, 67, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 73, 68, 71, 69, 0, 76, 0, 77, 0, 79, - 0, 80, 0, 0, 0, 0, 62, 78, 48, 0, - 0, 0, 0, 58, 0, 0, 0, 0, 0, 154, - 74, 44, 0, 72, 0, 49, 61, 75, 0, 0, - 0, 0, 0, 43, 64, 51, 70, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 65, 0, 45, + 75, 69, 73, 70, 0, 78, 0, 79, 0, 81, + 0, 82, 0, 0, 0, 0, 63, 80, 48, 0, + 0, 0, 0, 59, 0, 0, 0, 0, 293, 156, + 76, 44, 0, 74, 0, 49, 71, 62, 77, 0, + 0, 0, 0, 0, 43, 65, 52, 72, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 0, + 0, 45, 46, 47, 0, 0, 0, 0, 0, 0, + 0, 0, 51, 50, 0, 0, 0, 0, 0, 0, + 53, 0, 0, 0, 54, 55, 0, 56, 0, 0, + 0, 57, 0, 58, 60, 61, 0, 0, 64, 0, + 0, 0, 0, 67, 0, 68, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 75, + 69, 73, 70, 0, 78, 0, 79, 0, 81, 0, + 82, 0, 0, 0, 0, 63, 80, 48, 0, 0, + 0, 0, 59, 0, 0, 0, 0, 290, 156, 76, + 44, 0, 74, 0, 49, 71, 62, 77, 0, 0, + 0, 0, 0, 43, 65, 52, 72, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 66, 0, 0, + 45, 46, 47, 0, 0, 0, 0, 0, 0, 0, + 0, 51, 50, 0, 0, 0, 0, 0, 0, 53, + 0, 0, 0, 54, 55, 0, 56, 0, 0, 0, + 57, 0, 58, 60, 61, 0, 0, 64, 0, 0, + 0, 0, 67, 0, 68, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 75, 69, + 73, 70, 0, 78, 0, 79, 0, 81, 0, 82, + 0, 0, 0, 0, 63, 80, 48, 0, 0, 0, + 0, 59, 0, 0, 0, 0, 221, 156, 76, 44, + 0, 74, 0, 49, 71, 62, 77, 0, 0, 0, + 0, 0, 43, 65, 52, 72, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 0, 0, 45, 46, 47, 0, 0, 0, 0, 0, 0, 0, 0, - 50, 0, 0, 0, 0, 0, 0, 52, 0, 0, - 0, 53, 54, 0, 55, 0, 0, 0, 56, 0, - 57, 59, 60, 0, 0, 63, 0, 0, 0, 66, - 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 566, 0, 0, 0, 73, 68, 71, 69, 0, - 76, 0, 77, 0, 79, 0, 80, 0, 0, 0, - 0, 62, 78, 48, 0, 0, 0, 0, 58, 0, - 0, 0, 0, 0, 154, 74, 44, 0, 72, 0, - 49, 61, 75, 0, 0, 0, 0, 0, 43, 64, - 51, 70, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 65, 0, 45, 46, 47, 0, 0, 0, - 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, - 0, 0, 52, 0, 0, 0, 53, 54, 0, 55, - 0, 0, 0, 56, 0, 57, 59, 60, 0, 0, - 63, 0, 0, 0, 66, 0, 67, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 73, 68, 71, 69, 0, 76, 0, 77, 0, 79, - 0, 80, 0, 0, 0, 0, 62, 78, 48, 0, - 0, 0, 0, 58, 0, 0, 0, 0, 0, 154, - 74, 44, 0, 72, 0, 49, 61, 75, 0, 0, - 0, 0, 0, 43, 64, 51, 70, 0, 0, 0, - 0, 0, 0, 0, 0, 165, 0, 65, 0, 45, + 51, 50, 0, 0, 0, 0, 0, 0, 53, 0, + 0, 0, 54, 55, 0, 56, 0, 0, 0, 57, + 0, 58, 60, 61, 0, 0, 64, 0, 0, 0, + 0, 67, 0, 68, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 75, 69, 73, + 70, 0, 78, 0, 79, 0, 81, 0, 82, 0, + 0, 0, 0, 63, 80, 48, 0, 0, 0, 0, + 59, 0, 0, 0, 0, 0, 156, 76, 44, 0, + 74, 0, 49, 71, 62, 77, 0, 0, 0, 0, + 0, 43, 65, 52, 72, 0, 0, 0, 0, 0, + 0, 0, 0, 167, 0, 66, 0, 0, 45, 46, + 47, 0, 0, 0, 0, 0, 0, 0, 0, 51, + 50, 0, 0, 0, 0, 0, 0, 53, 0, 0, + 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, + 58, 60, 61, 0, 0, 64, 0, 0, 0, 0, + 67, 0, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 610, 0, 0, 0, 75, 69, 73, 70, + 0, 78, 0, 79, 0, 81, 0, 82, 0, 0, + 0, 0, 63, 80, 48, 0, 0, 0, 0, 59, + 0, 0, 0, 0, 0, 156, 76, 44, 0, 74, + 0, 49, 71, 62, 77, 0, 0, 0, 0, 0, + 43, 65, 52, 72, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 66, 0, 0, 45, 46, 47, + 0, 0, 0, 0, 0, 0, 0, 0, 51, 50, + 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, + 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, + 60, 61, 0, 0, 64, 0, 0, 0, 0, 67, + 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 751, 0, 0, 0, 75, 69, 73, 70, 0, + 78, 0, 79, 0, 81, 0, 82, 0, 0, 0, + 0, 63, 80, 48, 0, 0, 0, 0, 59, 0, + 0, 0, 0, 0, 83, 76, 44, 0, 74, 0, + 49, 71, 62, 77, 0, 0, 0, 0, 0, 43, + 65, 52, 72, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 66, 0, 0, 355, 0, 0, 45, 46, 47, 0, 0, 0, 0, 0, 0, 0, 0, - 50, 0, 0, 0, 0, 0, 0, 52, 0, 0, - 0, 53, 54, 0, 55, 0, 0, 0, 56, 0, - 57, 59, 60, 0, 0, 63, 0, 0, 0, 66, - 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 73, 68, 71, 69, 0, - 76, 0, 77, 0, 79, 0, 80, 0, 0, 0, - 0, 62, 78, 48, 0, 0, 0, 0, 58, 0, - 0, 0, 0, 0, 81, 74, 44, 0, 72, 0, - 49, 61, 75, 0, 0, 0, 0, 0, 43, 64, - 51, 70, 0, 0, 0, 0, 0, 0, 0, 0, - 103, 0, 65, 0, 45, 46, 47, 0, 0, 0, - 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, - 0, 0, 52, 0, 0, 0, 53, 54, 0, 55, - 0, 0, 0, 56, 0, 57, 59, 60, 0, 0, - 63, 0, 0, 0, 66, 0, 67, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 731, 0, 0, 0, - 73, 68, 71, 69, 0, 76, 0, 77, 0, 79, - 0, 80, 0, 0, 0, 0, 62, 78, 48, 0, - 0, 0, 0, 58, 0, 0, 0, 0, 0, 81, - 74, 44, 0, 72, 0, 49, 61, 75, 0, 0, - 0, 0, 0, 43, 64, 51, 70, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 65, 0, 45, - 46, 47, 0, 0, 0, 0, 0, 0, 0, 0, - 50, 0, 0, 0, 0, 0, 0, 52, 0, 0, - 0, 53, 54, 0, 55, 0, 0, 0, 56, 0, - 57, 59, 60, 0, 0, 63, 0, 0, 0, 66, - 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 73, 68, 71, 69, 0, - 76, 0, 77, 0, 79, 0, 80, 0, 0, 0, - 0, 62, 78, 48, 0, 0, 0, 0, 58, 0, - 0, 0, 0, 0, 154, 74, 44, 0, 72, 0, - 49, 61, 75, 0, 0, 0, 0, 0, 43, 64, - 51, 70, 0, 0, 0, 0, 0, 0, 0, 762, - 0, 0, 65, 0, 45, 46, 47, 0, 0, 0, - 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, - 0, 0, 52, 0, 0, 0, 53, 54, 0, 55, - 0, 0, 0, 56, 0, 57, 59, 60, 0, 0, - 63, 0, 0, 0, 66, 0, 67, 0, 0, 0, - 0, 0, 0, 702, 0, 0, 0, 0, 0, 0, - 73, 68, 71, 69, 0, 76, 0, 77, 0, 79, - 0, 80, 0, 0, 0, 0, 62, 78, 48, 0, - 0, 0, 0, 58, 0, 0, 0, 0, 218, 154, - 74, 44, 0, 72, 0, 49, 61, 75, 0, 0, - 0, 0, 0, 43, 64, 51, 70, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 65, 0, 45, - 46, 47, 0, 0, 0, 0, 0, 0, 0, 0, - 50, 0, 0, 0, 0, 0, 0, 52, 0, 0, - 0, 53, 54, 0, 55, 0, 0, 0, 56, 0, - 57, 59, 60, 0, 0, 63, 0, 0, 0, 66, - 0, 67, 0, 0, 695, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 73, 68, 71, 69, 0, - 76, 0, 77, 0, 79, 0, 80, 0, 0, 0, - 0, 62, 78, 48, 0, 0, 0, 0, 58, 0, - 0, 0, 0, 694, 154, 74, 44, 0, 72, 0, - 49, 61, 75, 0, 0, 0, 0, 0, 43, 64, - 51, 70, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 65, 0, 45, 46, 47, 0, 0, 0, - 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, - 0, 0, 52, 0, 0, 0, 53, 54, 0, 55, - 0, 0, 0, 56, 0, 57, 59, 60, 0, 0, - 63, 0, 0, 0, 66, 0, 67, 0, 0, 0, + 51, 50, 0, 0, 0, 0, 0, 0, 53, 0, + 0, 0, 54, 55, 0, 56, 0, 0, 0, 57, + 0, 58, 60, 61, 0, 0, 64, 0, 0, 0, + 0, 67, 0, 68, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 75, 69, 73, + 70, 0, 78, 0, 79, 0, 81, 0, 82, 0, + 0, 0, 0, 63, 80, 48, 0, 0, 0, 0, + 59, 0, 0, 0, 0, 0, 156, 76, 44, 0, + 74, 0, 49, 71, 62, 77, 0, 0, 0, 0, + 0, 43, 65, 52, 72, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 66, 0, 0, 45, 46, + 47, 0, 0, 0, 0, 0, 0, 0, 0, 51, + 50, 0, 0, 0, 0, 0, 0, 53, 0, 0, + 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, + 58, 60, 61, 0, 0, 64, 0, 0, 0, 0, + 67, 0, 68, 0, 0, 0, 0, 0, 0, 728, + 0, 0, 0, 0, 0, 0, 75, 69, 73, 70, + 0, 78, 0, 79, 0, 81, 0, 82, 0, 0, + 0, 0, 63, 80, 48, 0, 0, 0, 0, 59, + 0, 0, 0, 0, 221, 156, 76, 44, 0, 74, + 0, 49, 71, 62, 77, 0, 0, 0, 0, 0, + 43, 65, 52, 72, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 66, 0, 0, 45, 46, 47, + 0, 0, 0, 0, 0, 0, 0, 0, 51, 50, + 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, + 54, 55, 0, 56, 0, 0, 0, 57, 0, 58, + 60, 61, 0, 0, 64, 0, 0, 0, 0, 67, + 0, 68, 0, 0, 721, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 75, 69, 73, 70, 0, + 78, 0, 79, 0, 81, 0, 82, 0, 0, 0, + 0, 63, 80, 48, 0, 0, 0, 0, 59, 0, + 0, 0, 0, 720, 156, 76, 44, 0, 74, 0, + 49, 71, 62, 77, 0, 0, 0, 0, 0, 43, + 65, 52, 72, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 66, 0, 0, 45, 46, 47, 0, + 0, 0, 0, 0, 0, 0, 0, 51, 50, 0, + 0, 0, 0, 0, 0, 53, 0, 0, 0, 54, + 55, 0, 56, 0, 0, 0, 57, 0, 58, 60, + 61, 0, 0, 64, 0, 0, 0, 0, 67, 0, + 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 75, 69, 73, 70, 0, 78, + 0, 79, 0, 81, 153, 82, 0, 0, 0, 0, + 63, 80, 48, 403, 404, 0, 0, 59, 0, 0, + 0, 0, 0, 83, 76, 44, 0, 74, 0, 49, + 71, 62, 77, 0, 0, 0, 0, 0, 43, 65, + 52, 72, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 0, 0, 45, 46, 47, 0, 0, + 0, 0, 0, 0, 0, 0, 51, 50, 0, 0, + 0, 0, 0, 0, 53, 147, 0, 0, 54, 55, + 0, 56, 0, 0, 0, 57, 0, 58, 60, 61, + 0, 0, 64, 0, 0, 0, 0, 67, 0, 68, + 0, 0, 0, 0, 0, 0, 0, 149, 0, 0, + 0, 0, 0, 75, 69, 73, 70, 150, 78, 0, + 79, 152, 81, 0, 82, 0, 155, 0, 0, 63, + 80, 48, 0, 0, 0, 0, 59, 0, 0, 0, + 0, 0, 156, 76, 44, 0, 74, 0, 49, 71, + 62, 77, 0, 0, 0, 0, 0, 43, 65, 52, + 72, 0, 0, 0, 0, 0, 0, 0, 913, 912, + 0, 66, 0, 0, 45, 46, 47, 0, 0, 0, + 0, 0, 0, 0, 0, 51, 50, 0, 0, 0, + 0, 0, 0, 53, 147, 0, 0, 54, 1018, 0, + 56, 0, 0, 0, 57, 0, 58, 60, 61, 0, + 0, 64, 0, 0, 0, 0, 67, 0, 68, 0, + 0, 0, 0, 0, 0, 0, 149, 0, 0, 0, + 0, 0, 75, 69, 73, 70, 150, 78, 0, 79, + 152, 81, 0, 82, 0, 155, 0, 0, 63, 80, + 48, 0, 0, 0, 0, 59, 0, 0, 0, 0, + 0, 156, 76, 44, 0, 74, 0, 49, 71, 62, + 77, 0, 0, 0, 0, 0, 43, 65, 52, 72, + 0, 0, 0, 0, 0, 0, 0, 913, 912, 0, + 66, 0, 0, 239, 240, 241, 0, 0, 244, 246, + 247, 0, 0, 248, 0, 249, 0, 0, 0, 254, + 255, 0, 256, 0, 0, 0, 0, 0, 0, 53, + 257, 259, 260, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 73, 68, 71, 69, 0, 76, 0, 77, 0, 79, - 151, 80, 0, 0, 0, 0, 62, 78, 48, 364, - 365, 0, 0, 58, 0, 0, 0, 0, 0, 81, - 74, 44, 0, 72, 0, 49, 61, 75, 0, 0, - 0, 0, 0, 43, 64, 51, 70, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 65, 0, 45, - 46, 47, 0, 0, 0, 0, 0, 0, 0, 0, - 50, 0, 0, 0, 0, 0, 0, 52, 145, 0, - 0, 53, 969, 0, 55, 0, 0, 0, 56, 0, - 57, 59, 60, 0, 0, 63, 0, 0, 0, 66, - 0, 67, 0, 0, 0, 0, 0, 0, 0, 147, - 0, 0, 0, 0, 0, 73, 68, 71, 69, 148, - 76, 0, 77, 150, 79, 0, 80, 0, 153, 0, - 0, 62, 78, 48, 0, 0, 0, 0, 58, 0, - 0, 0, 0, 0, 154, 74, 44, 0, 72, 0, - 49, 61, 75, 0, 0, 0, 0, 0, 43, 64, - 51, 70, 0, 0, 0, 0, 0, 0, 0, 877, - 876, 0, 65, 0, 45, 46, 47, 0, 0, 0, - 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, - 0, 0, 52, 145, 0, 0, 53, 54, 0, 55, - 0, 0, 0, 56, 0, 57, 59, 60, 0, 0, - 63, 0, 0, 0, 66, 0, 67, 0, 0, 0, - 0, 0, 0, 0, 147, 0, 0, 0, 0, 0, - 73, 68, 71, 69, 148, 76, 0, 77, 150, 79, - 0, 80, 0, 153, 0, 0, 62, 78, 48, 0, - 0, 0, 0, 58, 0, 0, 0, 0, 0, 154, - 74, 44, 0, 72, 0, 49, 61, 75, 0, 0, - 0, 0, 0, 43, 64, 51, 70, 0, 0, 0, - 0, 0, 0, 0, 877, 876, 0, 65, 0, 245, - 246, 247, 0, 0, 250, 252, 253, 0, 0, 254, - 0, 255, 0, 0, 0, 260, 261, 262, 0, 0, - 0, 0, 0, 0, 52, 263, 265, 266, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 269, 0, + 265, 0, 0, 0, 0, 0, 0, 0, 0, 69, + 73, 70, 267, 268, 269, 0, 271, 272, 273, 274, + 275, 276, 0, 0, 263, 270, 253, 243, 261, 245, + 264, 0, 0, 0, 0, 250, 0, 0, 266, 242, + 252, 74, 251, 49, 71, 0, 0, 0, 0, 0, + 258, 0, 43, 65, 52, 72, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 0, 0, 239, + 240, 241, 0, 0, 244, 246, 247, 0, 0, 248, + 0, 249, 0, 0, 0, 254, 255, 0, 256, 0, + 0, 0, 0, 0, 0, 53, 257, 259, 260, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 273, 0, 0, 0, 0, 0, - 0, 0, 0, 68, 71, 69, 276, 277, 278, 0, - 280, 281, 282, 283, 284, 285, 0, 0, 270, 279, - 259, 249, 268, 251, 272, 0, 0, 0, 0, 256, - 0, 0, 275, 248, 258, 72, 257, 49, 0, 0, - 0, 0, 0, 264, 0, 43, 64, 51, 70, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, - 0, 245, 246, 247, 0, 0, 250, 252, 253, 0, - 0, 254, 0, 255, 0, 0, 0, 260, 261, 262, - 0, 0, 0, 0, 0, 0, 52, 263, 265, 266, + 0, 0, 842, 0, 0, 0, 265, 0, 0, 0, + 0, 0, 0, 0, 0, 69, 73, 70, 267, 268, + 269, 0, 271, 272, 273, 274, 275, 276, 0, 0, + 263, 270, 253, 243, 261, 245, 264, 0, 0, 0, + 0, 250, 0, 0, 266, 242, 252, 74, 251, 49, + 71, 0, 0, 0, 0, 0, 258, 0, 43, 65, + 52, 72, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 0, 0, 239, 240, 241, 0, 0, + 244, 246, 247, 0, 0, 248, 0, 249, 0, 0, + 0, 254, 255, 0, 256, 0, 0, 0, 0, 0, + 0, 53, 257, 259, 260, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 262, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 811, 0, + 0, 0, 265, 0, 0, 0, 0, 0, 0, 0, + 0, 69, 73, 70, 267, 268, 269, 0, 271, 272, + 273, 274, 275, 276, 0, 0, 263, 270, 253, 243, + 261, 245, 264, 0, 0, 0, 0, 250, 0, 0, + 266, 242, 252, 74, 251, 49, 71, 0, 0, 0, + 0, 0, 258, 0, 43, 65, 52, 72, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 0, + 0, 239, 240, 241, 0, 0, 244, 246, 247, 0, + 0, 248, 0, 249, 0, 0, 0, 254, 255, 0, + 256, 0, 0, 0, 0, 0, 0, 53, 257, 259, + 260, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 836, 0, 0, 0, 265, 0, + 0, 0, 0, 0, 0, 0, 0, 69, 73, 70, + 267, 268, 269, 0, 271, 272, 273, 274, 275, 276, + 0, 0, 263, 270, 253, 243, 261, 245, 264, 0, + 0, 0, 0, 250, 0, 0, 266, 242, 252, 74, + 251, 49, 71, 0, 0, 0, 0, 0, 258, 0, + 43, 65, 52, 72, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 66, 0, 0, 239, 240, 241, + 0, 0, 244, 246, 247, 0, 0, 248, 0, 249, + 0, 0, 0, 254, 255, 0, 256, 0, 0, 0, + 0, 0, 0, 53, 257, 259, 260, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 269, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 792, 0, 0, 0, 273, 0, 0, 0, - 0, 0, 0, 0, 0, 68, 71, 69, 276, 277, - 278, 0, 280, 281, 282, 283, 284, 285, 0, 0, - 270, 279, 259, 249, 268, 251, 272, 0, 0, 0, - 0, 256, 0, 0, 275, 248, 258, 72, 257, 49, - 0, 0, 0, 0, 0, 264, 0, 43, 64, 51, - 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 65, 0, 245, 246, 247, 0, 0, 250, 252, - 253, 0, 0, 254, 0, 255, 0, 0, 0, 260, - 261, 262, 0, 0, 0, 0, 0, 0, 52, 263, - 265, 266, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 269, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 796, 0, 0, 0, 273, 0, - 0, 0, 0, 0, 0, 0, 0, 68, 71, 69, - 276, 277, 278, 0, 280, 281, 282, 283, 284, 285, - 0, 0, 270, 279, 259, 249, 268, 251, 272, 0, - 0, 0, 0, 256, 0, 0, 275, 248, 258, 72, - 257, 49, 0, 0, 0, 0, 0, 264, 0, 43, - 64, 51, 70, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 65, 0, 245, 246, 247, 0, 0, - 250, 252, 253, 0, 0, 254, 0, 255, 0, 0, - 0, 260, 261, 262, 0, 0, 0, 0, 0, 0, - 52, 263, 265, 266, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 269, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 823, 0, 0, 0, - 273, 0, 0, 0, 0, 0, 0, 0, 0, 68, - 71, 69, 276, 277, 278, 0, 280, 281, 282, 283, - 284, 285, 0, 0, 270, 279, 259, 249, 268, 251, - 272, 0, 0, 0, 0, 256, 0, 0, 275, 248, - 258, 72, 257, 49, 0, 0, 0, 0, 0, 264, - 0, 43, 64, 51, 70, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 65, 0, 245, 246, 247, - 0, 0, 250, 252, 253, 0, 0, 254, 0, 255, - 0, 0, 0, 260, 261, 262, 0, 0, 0, 0, - 0, 0, 52, 263, 265, 266, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 269, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 817, 0, - 0, 0, 273, 0, 0, 0, 0, 0, 0, 0, - 0, 68, 71, 69, 276, 277, 278, 0, 280, 281, - 282, 283, 284, 285, 0, 0, 270, 279, 259, 249, - 268, 251, 272, 0, 0, 0, 0, 256, 0, 0, - 275, 248, 258, 72, 257, 49, 0, 0, 0, 0, - 0, 264, 0, 43, 64, 51, 70, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 65, 0, 245, - 246, 247, 0, 0, 250, 252, 253, 0, 0, 254, - 0, 255, 0, 0, 0, 260, 261, 262, 0, 0, - 0, 0, 0, 0, 52, 263, 265, 266, 0, 267, - 0, 0, 0, 0, 0, 0, 0, 0, 269, 0, - 0, 0, 271, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 273, 0, 0, 0, 0, 0, - 0, 0, 274, 68, 71, 69, 276, 277, 278, 0, - 280, 281, 282, 283, 284, 285, 0, 0, 270, 279, - 259, 249, 268, 251, 272, 0, 0, 0, 0, 256, - 0, 0, 275, 248, 258, 72, 257, 49, 0, 0, - 0, 0, 0, 264, 0, 43, 64, 51, 70, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, - 0, 245, 246, 247, 0, 0, 250, 252, 253, 0, - 0, 254, 0, 255, 0, 0, 0, 260, 261, 262, - 0, 0, 0, 0, 0, 0, 52, 263, 265, 266, - 0, 267, 0, 0, 0, 0, 0, 0, 0, 0, - 269, 0, 0, 0, 271, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 273, 0, 0, 0, - 476, 0, 0, 0, 274, 68, 71, 69, 276, 277, - 278, 0, 280, 281, 282, 283, 284, 285, 0, 0, - 270, 279, 259, 249, 268, 251, 272, 0, 0, 0, - 0, 256, 0, 0, 275, 248, 258, 72, 257, 49, - 0, 0, 0, 0, 0, 264, 0, 43, 64, 473, - 475, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 65, 0, 245, 246, 247, 0, 0, 250, 252, - 253, 0, 0, 254, 0, 255, 0, 0, 0, 260, - 261, 262, 0, 0, 0, 0, 0, 0, 52, 263, - 265, 266, 0, 267, 0, 0, 0, 0, 0, 0, - 0, 0, 269, 0, 0, 0, 271, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 273, 0, - 474, 0, 476, 0, 0, 0, 274, 68, 71, 69, - 276, 277, 278, 0, 280, 281, 282, 283, 284, 285, - 0, 0, 270, 279, 259, 249, 268, 251, 272, 0, - 0, 0, 0, 256, 0, 0, 275, 248, 258, 477, - 257, 49, 0, 0, 0, 0, 0, 264, 0, 43, - 64, 473, 475, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 65, 0, 138, 0, 0, 0, 0, - 139, 0, 45, 46, 47, 141, 0, 0, 0, 0, - 0, 0, 142, 50, 0, 0, 0, 0, 0, 0, - 52, 145, 0, 0, 53, 54, 0, 55, 0, 0, - 0, 56, 0, 57, 59, 60, 0, 0, 63, 0, - 0, 0, 66, 0, 67, 0, 0, 0, 0, 0, - 146, 0, 147, 0, 0, 0, 0, 0, 73, 68, - 71, 69, 148, 76, 149, 77, 150, 79, 151, 80, - 152, 153, 0, 0, 62, 78, 48, 0, 0, 140, - 0, 58, 0, 0, 0, 0, 0, 154, 74, 44, - 0, 72, 0, 49, 61, 75, 0, 0, 0, 0, - 0, 43, 64, 51, 70, 0, 0, 0, 0, 0, - 0, 0, 0, 143, 0, 65, 0, 245, 246, 247, - 0, 0, 250, 252, 253, 0, 0, 254, 0, 255, - 0, 0, 0, 260, 261, 262, 0, 0, 0, 0, - 0, 0, 52, 263, 265, 266, 0, 267, 0, 0, - 0, 0, 0, 0, 0, 0, 269, 0, 0, 0, - 271, 0, 0, 0, 0, 0, 0, 0, 682, 0, - 0, 0, 273, 0, 0, 0, 476, 0, 0, 0, - 274, 68, 71, 69, 276, 277, 278, 0, 280, 281, - 282, 283, 284, 285, 0, 0, 270, 279, 259, 249, - 268, 251, 272, 0, 0, 0, 0, 256, 0, 0, - 275, 248, 258, 72, 257, 49, 0, 0, 0, 0, - 0, 264, 0, 43, 64, 473, 475, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 65, 0, 245, - 246, 247, 0, 0, 250, 252, 253, 0, 0, 254, - 0, 255, 0, 0, 0, 260, 261, 262, 0, 0, - 0, 0, 0, 0, 52, 263, 265, 266, 0, 267, - 0, 0, 0, 0, 0, 0, 0, 0, 269, 0, - 0, 0, 271, 0, 0, 0, 0, 0, 0, 0, - 677, 0, 0, 0, 273, 0, 0, 0, 476, 0, - 0, 0, 274, 68, 71, 69, 276, 277, 278, 0, - 280, 281, 282, 283, 284, 285, 0, 0, 270, 279, - 259, 249, 268, 251, 272, 0, 0, 0, 0, 256, - 0, 0, 275, 248, 258, 72, 257, 49, 0, 0, - 0, 0, 0, 264, 0, 43, 64, 473, 475, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, - 0, 138, 0, 0, 0, 0, 139, 0, 45, 46, - 47, 141, 0, 0, 0, 0, 0, 0, 142, 50, - 0, 0, 0, 0, 0, 0, 52, 145, 0, 0, - 53, 54, 0, 55, 0, 0, 0, 56, 0, 57, - 59, 60, 0, 0, 63, 0, 0, 0, 66, 0, - 67, 0, 0, 0, 0, 0, 146, 0, 147, 0, - 0, 0, 0, 0, 73, 68, 71, 69, 148, 76, - 149, 77, 150, 79, 151, 80, 152, 153, 0, 0, - 62, 78, 48, 0, 0, 140, 0, 58, 0, 0, - 0, 0, 0, 154, 74, 44, 0, 72, 0, 49, - 61, 75, 0, 0, 0, 0, 0, 43, 64, 51, - 70, 0, 0, 0, 0, 0, 0, 0, 144, 143, - 0, 65, 0, 138, 0, 0, 0, 0, 139, 0, - 45, 46, 47, 141, 0, 0, 0, 0, 0, 0, - 142, 50, 0, 0, 0, 0, 0, 0, 52, 145, - 0, 0, 53, 54, 0, 55, 0, 0, 0, 56, - 0, 57, 59, 60, 0, 0, 63, 0, 0, 0, - 66, 0, 67, 0, 0, 0, 0, 0, 146, 0, - 147, 0, 0, 0, 0, 0, 73, 68, 71, 69, - 148, 76, 149, 77, 150, 79, 151, 80, 152, 153, - 0, 0, 62, 78, 48, 0, 0, 140, 0, 58, - 0, 0, 0, 0, 0, 154, 74, 44, 0, 72, - 0, 49, 61, 75, 0, 0, 0, 0, 0, 43, - 64, 51, 70, 0, 0, 0, 0, 0, 0, 0, - 205, 143, 0, 65, 0, 138, 0, 0, 0, 0, - 139, 0, 45, 46, 47, 141, 0, 0, 0, 0, - 0, 0, 142, 50, 0, 0, 0, 0, 0, 0, - 52, 145, 0, 0, 53, 54, 0, 55, 0, 0, - 0, 56, 0, 57, 59, 60, 0, 0, 884, 0, - 0, 0, 66, 0, 67, 0, 0, 0, 0, 0, - 146, 0, 147, 0, 0, 0, 0, 0, 885, 68, - 71, 69, 148, 76, 149, 77, 150, 79, 151, 80, - 152, 153, 0, 0, 62, 78, 48, 0, 0, 140, - 0, 58, 0, 0, 0, 0, 0, 154, 74, 44, - 0, 72, 0, 49, 61, 75, 0, 0, 0, 0, - 0, 43, 64, 51, 70, 0, 0, 0, 0, 0, - 0, 0, 144, 143, 0, 65, 0, + 815, 0, 0, 0, 265, 0, 0, 0, 0, 0, + 0, 0, 0, 69, 73, 70, 267, 268, 269, 0, + 271, 272, 273, 274, 275, 276, 0, 0, 263, 270, + 253, 243, 261, 245, 264, 0, 0, 0, 0, 250, + 0, 0, 266, 242, 252, 74, 251, 49, 71, 0, + 0, 0, 0, 0, 258, 0, 43, 65, 52, 72, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 66, 0, 0, 239, 240, 241, 0, 0, 244, 246, + 247, 0, 0, 248, 0, 249, 0, 0, 0, 254, + 255, 0, 256, 0, 0, 0, 0, 0, 0, 53, + 257, 259, 260, 0, 328, 0, 0, 0, 0, 0, + 0, 0, 0, 262, 0, 0, 0, 329, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 265, 0, 0, 0, 0, 0, 0, 0, 330, 69, + 73, 70, 267, 268, 269, 0, 271, 272, 273, 274, + 275, 276, 0, 0, 263, 270, 253, 243, 261, 245, + 264, 0, 0, 0, 0, 250, 0, 0, 266, 242, + 252, 74, 251, 49, 71, 0, 0, 0, 0, 0, + 258, 0, 43, 65, 52, 72, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 0, 0, 239, + 240, 241, 0, 0, 244, 246, 247, 0, 0, 248, + 0, 249, 0, 0, 0, 254, 255, 0, 256, 0, + 0, 0, 0, 0, 0, 53, 257, 259, 260, 0, + 328, 0, 0, 0, 0, 0, 0, 0, 0, 262, + 0, 0, 0, 329, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 265, 0, 0, 0, + 518, 0, 0, 0, 330, 69, 73, 70, 267, 268, + 269, 0, 271, 272, 273, 274, 275, 276, 0, 0, + 263, 270, 253, 243, 261, 245, 264, 0, 0, 0, + 0, 250, 0, 0, 266, 242, 252, 74, 251, 49, + 71, 0, 0, 0, 0, 0, 258, 0, 43, 65, + 515, 517, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 0, 0, 239, 240, 241, 0, 0, + 244, 246, 247, 0, 0, 248, 0, 249, 0, 0, + 0, 254, 255, 0, 256, 0, 0, 0, 0, 0, + 0, 53, 257, 259, 260, 0, 328, 0, 0, 0, + 0, 0, 0, 0, 0, 262, 0, 0, 0, 329, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 265, 0, 516, 0, 518, 0, 0, 0, + 330, 69, 73, 70, 267, 268, 269, 0, 271, 272, + 273, 274, 275, 276, 0, 0, 263, 270, 253, 243, + 261, 245, 264, 0, 0, 0, 0, 250, 0, 0, + 266, 242, 252, 519, 251, 49, 71, 0, 0, 0, + 0, 0, 258, 0, 43, 65, 515, 517, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 0, + 0, 239, 240, 241, 0, 0, 244, 246, 247, 0, + 0, 248, 0, 249, 0, 0, 0, 254, 255, 0, + 256, 0, 0, 0, 0, 0, 0, 53, 257, 259, + 260, 0, 328, 0, 0, 0, 0, 0, 0, 0, + 0, 262, 0, 0, 0, 329, 0, 0, 0, 0, + 0, 0, 0, 0, 708, 0, 0, 0, 265, 0, + 0, 0, 518, 0, 0, 0, 330, 69, 73, 70, + 267, 268, 269, 0, 271, 272, 273, 274, 275, 276, + 0, 0, 263, 270, 253, 243, 261, 245, 264, 0, + 0, 0, 0, 250, 0, 0, 266, 242, 252, 74, + 251, 49, 71, 0, 0, 0, 0, 0, 258, 0, + 43, 65, 515, 517, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 66, 0, 0, 239, 240, 241, + 0, 0, 244, 246, 247, 0, 0, 248, 0, 249, + 0, 0, 0, 254, 255, 0, 256, 0, 0, 0, + 0, 0, 0, 53, 257, 259, 260, 0, 328, 0, + 0, 0, 0, 0, 0, 0, 0, 262, 0, 0, + 0, 329, 0, 0, 0, 0, 0, 0, 0, 0, + 703, 0, 0, 0, 265, 0, 0, 0, 518, 0, + 0, 0, 330, 69, 73, 70, 267, 268, 269, 0, + 271, 272, 273, 274, 275, 276, 0, 0, 263, 270, + 253, 243, 261, 245, 264, 0, 0, 0, 0, 250, + 0, 0, 266, 242, 252, 74, 251, 49, 71, 0, + 0, 0, 0, 0, 258, 0, 43, 65, 515, 517, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 66, 0, 0, 140, 0, 0, 0, 0, 141, 0, + 45, 46, 47, 143, 0, 0, 0, 0, 0, 0, + 144, 51, 50, 0, 0, 0, 0, 0, 0, 53, + 147, 0, 0, 54, 55, 0, 56, 0, 0, 0, + 57, 0, 58, 60, 61, 0, 0, 64, 0, 0, + 0, 0, 67, 0, 68, 0, 0, 0, 0, 0, + 148, 0, 149, 0, 0, 0, 0, 0, 75, 69, + 73, 70, 150, 78, 151, 79, 152, 81, 153, 82, + 154, 155, 0, 0, 63, 80, 48, 0, 0, 142, + 0, 59, 0, 0, 0, 0, 0, 156, 76, 44, + 0, 74, 0, 49, 71, 62, 77, 0, 0, 0, + 0, 0, 43, 65, 52, 72, 0, 0, 0, 0, + 0, 0, 0, 0, 145, 0, 66, 0, 0, 140, + 0, 0, 0, 0, 141, 0, 45, 46, 47, 143, + 0, 0, 0, 0, 0, 0, 144, 51, 50, 0, + 0, 0, 0, 0, 0, 53, 147, 0, 0, 54, + 55, 0, 56, 0, 0, 0, 57, 0, 58, 60, + 61, 0, 0, 64, 0, 0, 0, 0, 67, 0, + 68, 0, 0, 0, 0, 0, 148, 0, 149, 0, + 0, 0, 0, 0, 75, 69, 73, 70, 150, 78, + 151, 79, 152, 81, 153, 82, 154, 155, 0, 0, + 63, 80, 48, 0, 0, 142, 0, 59, 0, 0, + 0, 0, 0, 156, 76, 44, 0, 74, 0, 49, + 71, 62, 77, 0, 0, 0, 0, 0, 43, 65, + 52, 72, 0, 0, 0, 0, 0, 0, 0, 208, + 145, 0, 66, 0, 0, 140, 0, 0, 0, 0, + 141, 0, 45, 46, 47, 143, 0, 0, 0, 0, + 0, 0, 144, 51, 50, 0, 0, 0, 0, 0, + 0, 53, 147, 0, 0, 54, 55, 0, 56, 0, + 0, 0, 57, 0, 58, 60, 61, 0, 0, 64, + 0, 0, 0, 0, 67, 0, 68, 0, 0, 0, + 0, 0, 148, 0, 149, 0, 0, 0, 0, 0, + 75, 69, 73, 70, 150, 78, 151, 79, 152, 81, + 153, 82, 154, 155, 0, 0, 63, 80, 48, 0, + 0, 142, 0, 59, 0, 0, 0, 0, 0, 156, + 76, 44, 0, 74, 0, 49, 71, 62, 77, 0, + 0, 0, 0, 0, 43, 65, 52, 72, 0, 0, + 0, 0, 0, 0, 0, 146, 145, 0, 66, 0, + 0, 140, 0, 0, 0, 0, 141, 0, 45, 46, + 47, 143, 0, 0, 0, 0, 0, 0, 144, 51, + 50, 0, 0, 0, 0, 0, 0, 53, 147, 0, + 0, 54, 55, 0, 56, 0, 0, 0, 57, 0, + 58, 60, 61, 0, 0, 920, 0, 0, 0, 0, + 67, 0, 68, 0, 0, 0, 0, 0, 148, 0, + 149, 0, 0, 0, 0, 0, 921, 69, 73, 70, + 150, 78, 151, 79, 152, 81, 153, 82, 154, 155, + 0, 0, 63, 80, 48, 0, 0, 142, 0, 59, + 0, 0, 0, 0, 0, 156, 76, 44, 0, 74, + 0, 49, 71, 62, 77, 0, 0, 0, 0, 0, + 43, 65, 52, 72, 0, 0, 0, 0, 0, 0, + 0, 146, 145, 0, 66, 0, 0, - 896, 783, 505, 957, 1005, 784, 943, 950, 788, 987, - 786, 941, 944, 847, 975, 933, 758, 799, 897, 761, - 915, 973, 854, 913, 999, 127, 809, 782, 850, 776, - 778, 777, 960, 894, 880, 959, 964, 870, 540, 537, - 534, 510, 530, 549, 538, 200, 509, 503, 508, 522, - 127, 513, 502, 501, 494, 493, 572, 544, 585, 565, - 583, 127, 163, 492, 166, 164, 567, 167, 562, 573, - 168, 556, 558, 230, 352, 387, 232, 380, 231, 384, - 127, 224, 301, 335, 488, 333, 286, 295, 327, 326, - 487, 486, 293, 294, 470, 207, 462, 450, 555, 405, - 431, 336, 405, 629, 663, 657, 635, 656, 221, 417, - 225, 417, 404, 639, 636, 401, 655, 664, 678, 372, - 638, 670, 641, 127, 650, 668, 312, 107, 669, 651, - 665, 652, 594, 596, 600, 607, 603, 605, 726, 541, - 341, 613, 583, 585, 660, 691, 621, 579, 684, 697, - 210, 209, 883, 427, 372, 619, 372, 210, 644, 372, - 372, 389, 470, 382, 376, 210, 633, 372, 372, 692, - 829, 693, 579, 306, 946, 348, 600, 947, 685, 687, - 515, 517, 470, 348, 600, 348, 348, 210, 644, 600, - 470, 579, 348, 791, 470, 470, 470, 560, 967, 715, - 349, 968, 348, 348, 564, 470, 204, 631, 579, 436, - 210, 461, 623, 470, 937, 811, 812, 938, 425, 348, - 423, 628, 348, 409, 407, 620, 348, 798, 202, 210, - 445, 374, 371, 210, 209, 470, 595, 210, 209, 0, - 470, 470, 470, 579, 470, 28, 210, 213, 992, 991, - 701, 700, 41, 672, 210, 233, 240, 235, 210, 213, - 742, 470, 489, 431, 210, 291, 210, 568, 481, 495, - 721, 504, 210, 800, 305, 210, 800, 210, 213, 730, - 676, 673, 0, 243, 828, 240, 800, 210, 551, 210, - 213, 89, 791, 210, 213, 210, 213, 210, 461, 210, - 213, 0, 88, 28, 580, 308, 706, 210, 213, 200, - 41, 210, 213, 210, 397, 0, 813, 411, 210, 658, - 725, 580, 210, 213, 210, 800, 766, 787, 210, 445, - 210, 213, 210, 412, 0, 511, 210, 391, 11, 348, - 637, 435, 240, 800, 986, 210, 568, 89, 0, 89, - 89, 615, 28, 210, 213, 0, 742, 0, 88, 41, - 88, 88, 0, 480, 234, 0, 308, 0, 102, 89, - 89, 210, 455, 813, 292, 28, 569, 732, 89, 0, - 88, 88, 41, 240, 235, 0, 640, 0, 217, 88, - 0, 90, 28, 90, 90, 91, 11, 552, 99, 41, - 586, 28, 28, 436, 755, 0, 712, 661, 41, 41, - 243, 0, 497, 0, 90, 749, 763, 89, 768, 666, - 369, 185, 90, 398, 0, 734, 0, 506, 88, 448, - 0, 795, 89, 0, 210, 213, 825, 780, 386, 819, - 785, 653, 413, 88, 28, 11, 393, 228, 390, 210, - 419, 41, 648, 575, 0, 569, 0, 659, 765, 403, - 774, 90, 28, 89, 0, 696, 0, 779, 11, 41, - 307, 89, 28, 89, 88, 89, 90, 458, 672, 41, - 329, 457, 88, 28, 88, 11, 88, 0, 802, 28, - 41, 750, 89, 0, 11, 11, 41, 332, 288, 89, - 89, 681, 909, 88, 0, 676, 673, 90, 822, 89, - 88, 88, 210, 455, 0, 90, 0, 90, 171, 90, - 88, 191, 710, 0, 0, 177, 192, 89, 89, 0, - 0, 0, 0, 0, 89, 435, 90, 11, 88, 88, - 0, 89, 189, 90, 90, 88, 89, 89, 0, 190, - 0, 227, 88, 90, 0, 11, 421, 88, 88, 420, - 89, 194, 89, 0, 712, 11, 0, 0, 196, 0, - 89, 88, 90, 88, 0, 98, 11, 0, 90, 643, - 718, 88, 11, 89, 712, 90, 643, 708, 711, 0, - 90, 643, 709, 0, 88, 0, 210, 213, 0, 831, - 831, 89, 921, 925, 90, 0, 90, 643, 719, 308, - 309, 41, 88, 358, 90, 643, 720, 0, 460, 89, - 588, 0, 457, 0, 89, 89, 0, 90, 0, 89, - 88, 89, 89, 0, 41, 88, 88, 0, 0, 582, - 88, 831, 88, 88, 0, 90, 643, 727, 974, 939, - 0, 0, 921, 831, 971, 0, 993, 0, 0, 0, - 89, 712, 712, 90, 0, 0, 89, 0, 0, 0, - 41, 88, 584, 90, 831, 90, 90, 88, 89, 89, - 41, 841, 41, 41, 0, 0, 0, 590, 0, 88, - 88, 685, 687, 609, 0, 361, 612, 842, 0, 89, - 89, 0, 41, 712, 90, 643, 729, 0, 0, 0, - 88, 88, 0, 307, 0, 712, 932, 0, 0, 929, - 0, 0, 0, 90, 643, 728, 0, 0, 831, 0, - 0, 831, 0, 0, 0, 841, 712, 0, 841, 0, - 0, 0, 0, 948, 90, 643, 642, 0, 362, 366, - 970, 842, 0, 89, 842, 873, 89, 872, 874, 879, - 875, 878, 948, 0, 88, 0, 0, 88, 0, 949, - 0, 0, 0, 0, 873, 0, 872, 874, 879, 875, - 878, 0, 939, 0, 0, 0, 0, 0, 11, 940, - 712, 0, 0, 712, 873, 0, 872, 874, 879, 875, - 878, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 904, 989, 766, 996, 875, 874, 986, 982, 1048, 235, + 876, 932, 1054, 529, 994, 992, 765, 884, 1053, 993, + 873, 984, 987, 801, 891, 933, 961, 916, 1043, 795, + 797, 794, 796, 1036, 802, 1012, 803, 935, 805, 1024, + 906, 904, 1022, 807, 828, 952, 1051, 974, 969, 1013, + 1047, 975, 904, 235, 930, 1010, 129, 165, 971, 818, + 579, 950, 776, 779, 1004, 583, 621, 235, 575, 565, + 887, 1009, 582, 567, 346, 559, 556, 555, 419, 166, + 554, 168, 550, 599, 394, 423, 548, 611, 588, 618, + 600, 593, 587, 553, 616, 585, 170, 492, 505, 488, + 237, 486, 501, 129, 445, 235, 606, 474, 602, 210, + 304, 464, 531, 457, 609, 547, 203, 546, 545, 536, + 538, 537, 169, 535, 530, 446, 307, 528, 426, 434, + 440, 681, 442, 689, 691, 459, 459, 690, 316, 446, + 683, 682, 686, 315, 340, 680, 676, 296, 677, 289, + 308, 674, 675, 331, 338, 723, 746, 235, 294, 292, + 313, 638, 710, 717, 586, 235, 314, 696, 704, 387, + 199, 695, 277, 649, 378, 694, 640, 383, 627, 629, + 380, 386, 129, 392, 480, 411, 109, 629, 617, 129, + 664, 627, 371, 339, 282, 129, 372, 235, 357, 919, + 411, 411, 421, 213, 669, 351, 237, 213, 212, 415, + 411, 237, 1038, 411, 428, 237, 389, 237, 385, 382, + 237, 289, 1016, 0, 237, 1017, 388, 623, 237, 237, + 1006, 1040, 1039, 388, 289, 289, 213, 212, 388, 848, + 388, 236, 727, 726, 642, 237, 281, 1007, 711, 713, + 623, 623, 817, 384, 381, 639, 411, 653, 656, 213, + 684, 213, 669, 388, 448, 450, 213, 658, 470, 718, + 207, 719, 213, 216, 413, 561, 237, 410, 237, 660, + 810, 237, 661, 666, 213, 487, 663, 998, 213, 504, + 563, 237, 388, 411, 205, 213, 684, 213, 869, 388, + 604, 623, 608, 0, 1002, 698, 350, 623, 523, 532, + 324, 319, 539, 237, 388, 213, 317, 830, 831, 0, + 468, 474, 549, 480, 388, 773, 388, 28, 213, 612, + 213, 216, 213, 819, 41, 0, 702, 699, 0, 213, + 216, 327, 213, 216, 213, 216, 213, 216, 810, 213, + 437, 624, 324, 819, 213, 595, 741, 466, 213, 819, + 213, 504, 0, 213, 453, 665, 91, 213, 430, 213, + 216, 213, 487, 847, 806, 762, 213, 216, 662, 213, + 216, 90, 878, 879, 522, 880, 91, 832, 213, 819, + 213, 336, 353, 732, 213, 216, 203, 213, 216, 213, + 216, 90, 324, 819, 91, 745, 91, 0, 651, 104, + 213, 612, 1035, 91, 557, 0, 768, 0, 0, 90, + 11, 90, 750, 0, 452, 624, 213, 216, 90, 318, + 0, 762, 28, 28, 92, 698, 0, 832, 93, 41, + 41, 91, 613, 311, 0, 91, 28, 0, 388, 213, + 497, 28, 92, 41, 92, 0, 90, 100, 41, 630, + 90, 92, 707, 438, 220, 101, 702, 699, 596, 213, + 461, 722, 0, 799, 752, 91, 678, 454, 490, 0, + 792, 432, 91, 0, 324, 319, 228, 284, 814, 92, + 90, 767, 754, 0, 0, 28, 0, 90, 28, 0, + 28, 844, 41, 672, 337, 41, 0, 41, 804, 0, + 692, 0, 408, 687, 798, 327, 213, 216, 541, 91, + 91, 425, 620, 92, 613, 11, 11, 838, 871, 429, + 92, 444, 0, 353, 90, 90, 28, 551, 787, 11, + 213, 497, 374, 41, 11, 28, 0, 310, 0, 91, + 91, 377, 41, 28, 0, 28, 0, 821, 0, 500, + 41, 228, 41, 499, 90, 90, 978, 92, 0, 980, + 979, 977, 91, 841, 91, 91, 0, 91, 0, 91, + 463, 0, 198, 462, 213, 216, 0, 90, 11, 90, + 90, 11, 90, 11, 90, 91, 0, 92, 92, 0, + 0, 353, 354, 333, 0, 0, 179, 736, 227, 91, + 90, 0, 1041, 0, 196, 0, 0, 91, 0, 0, + 92, 91, 92, 92, 90, 92, 192, 92, 193, 11, + 187, 191, 90, 781, 194, 784, 90, 352, 11, 0, + 91, 91, 0, 92, 668, 748, 11, 0, 11, 91, + 503, 0, 0, 91, 499, 90, 90, 92, 668, 667, + 0, 91, 397, 0, 90, 92, 668, 734, 90, 92, + 668, 735, 91, 0, 0, 783, 90, 91, 0, 0, + 227, 228, 228, 91, 91, 737, 227, 90, 232, 786, + 956, 0, 90, 0, 0, 0, 227, 92, 90, 90, + 960, 92, 668, 739, 0, 352, 0, 227, 173, 92, + 668, 740, 0, 91, 0, 1023, 0, 0, 91, 91, + 92, 668, 747, 0, 0, 92, 668, 749, 90, 91, + 91, 92, 92, 90, 90, 91, 91, 0, 41, 41, + 91, 628, 972, 626, 90, 90, 956, 0, 1020, 0, + 90, 90, 0, 0, 228, 90, 0, 400, 0, 0, + 228, 0, 0, 0, 41, 0, 92, 0, 0, 227, + 228, 0, 0, 41, 0, 0, 0, 232, 92, 227, + 0, 228, 632, 92, 92, 41, 968, 232, 0, 0, + 41, 41, 634, 0, 0, 0, 711, 713, 227, 227, + 0, 645, 91, 0, 648, 299, 867, 867, 0, 0, + 401, 405, 91, 0, 0, 303, 0, 90, 0, 0, + 990, 965, 0, 0, 0, 0, 91, 90, 973, 868, + 868, 91, 91, 909, 227, 908, 910, 915, 911, 914, + 0, 90, 867, 228, 972, 0, 90, 90, 0, 0, + 11, 0, 973, 228, 0, 0, 0, 909, 0, 908, + 910, 915, 911, 914, 0, 868, 0, 91, 0, 0, + 990, 0, 228, 228, 92, 668, 738, 0, 1019, 0, + 0, 0, 90, 909, 0, 908, 910, 915, 911, 914, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 849, 849, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 873, 0, 872, 874, 879, 875, 878, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 849, 0, 0, 909, 0, 908, 910, 915, 911, 914, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -1359,693 +1320,789 @@ const short QmlJSGrammar::action_info [] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; const short QmlJSGrammar::action_check [] = { - 60, 7, 17, 37, 33, 47, 102, 47, 36, 110, - 29, 33, 99, 7, 55, 8, 7, 7, 7, 55, - 33, 60, 48, 2, 110, 8, 33, 102, 33, 29, - 60, 17, 34, 60, 33, 60, 33, 29, 55, 55, - 36, 29, 60, 8, 68, 29, 60, 55, 60, 60, - 102, 33, 29, 110, 55, 0, 60, 60, 67, 33, - 55, 36, 60, 33, 33, 33, 33, 33, 55, 33, - 2, 8, 33, 8, 37, 60, 36, 55, 33, 8, - 60, 2, 36, 56, 60, 56, 36, 68, 7, 48, - 36, 17, 64, 55, 17, 7, 16, 55, 8, 33, - 33, 17, 55, 60, 55, 61, 55, 55, 60, 17, - 8, 55, 17, 60, 17, 17, 17, 60, 17, 61, - 61, 61, 60, 8, 8, 61, 33, 36, 55, 60, - 17, 61, 8, 8, 17, 17, 33, 55, 33, 17, - 36, 55, 8, 1, 48, 33, 36, 36, 1, 55, - 36, 79, 33, 1, 48, 2, 36, 36, 0, 8, - 99, 33, 5, 8, 81, 5, 17, 60, 93, 93, - 81, 93, 5, 7, 36, 1, 17, 33, 93, 33, - 8, 81, 55, 22, 20, 8, 60, 33, 8, 33, - 81, 61, 62, 8, 7, 50, 7, 15, 36, 54, - 22, 36, 8, 8, 61, 62, 24, 31, 15, 8, - 42, 61, 62, 8, 8, 8, 8, 24, 8, 10, - 0, 53, 8, 40, 61, 62, 40, 15, 63, 33, - 61, 62, 61, 62, 51, 55, 8, 51, 40, 8, - 61, 62, 61, 62, 8, 60, 34, 8, 8, 51, - 56, 8, 6, 61, 62, 60, 55, 8, 40, 63, - 7, 55, 55, 50, 55, 60, 20, 54, 60, 51, - 60, 56, 61, 62, 60, 8, 98, 0, 61, 62, - 93, 108, 109, 36, 56, 61, 62, 111, 25, 36, - 27, 60, 56, 61, 62, 56, 108, 109, 55, 110, - 60, 38, 61, 62, 29, 56, 15, 7, 61, 62, - 95, 7, 29, 25, 12, 27, 8, 0, 29, 7, - 7, 101, 12, 56, -1, 34, 38, 36, 108, 17, - 8, 8, 29, 92, 25, 8, 27, 33, 8, 17, - 25, 5, 27, 47, 17, 29, 10, 38, 36, 12, - 29, 55, 77, 38, 7, -1, 8, -1, -1, 57, - 77, 61, 62, 67, 89, 63, 77, 57, 22, 61, - 62, 29, 89, 63, 61, 62, -1, 25, 89, 27, - 77, 61, 62, 61, 61, 62, 18, 19, 61, -1, - 38, 55, 89, 77, 57, 18, 19, 15, 77, -1, - 63, 15, -1, 7, 8, 89, -1, -1, 61, 62, - 89, 18, 19, 45, 46, -1, 34, -1, 101, 77, - 34, 15, 45, 46, 15, 108, -1, -1, 124, -1, - 110, 89, 86, 87, 47, 105, 106, 15, 45, 46, - 34, -1, 36, 34, 98, 36, 15, -1, 61, 62, - 23, 24, -1, 105, 106, -1, 34, -1, 36, 32, - 23, 24, 35, 15, 37, 34, -1, 36, -1, 32, - -1, -1, 35, 15, 37, 115, 116, 117, 118, 119, - 120, 33, 34, -1, 36, 103, 104, 23, 24, 103, - 104, 33, 34, -1, 36, 31, 32, 110, -1, 35, - 29, 37, -1, 29, 10, -1, 23, 24, -1, 103, - 104, -1, 103, 104, 31, 32, 22, -1, 35, -1, - 37, -1, 18, 19, 29, 103, 104, 33, 29, -1, - -1, -1, -1, -1, 103, 104, -1, -1, -1, 68, - 69, 70, 68, 69, 70, -1, -1, -1, -1, 45, - 46, 103, 104, -1, -1, -1, -1, 63, -1, -1, - -1, 103, 104, 68, 69, 70, -1, 68, 69, 70, - -1, 77, -1, 102, 29, -1, 102, -1, -1, -1, - 86, 87, 111, 112, 113, 111, 112, 113, -1, -1, - -1, -1, 98, 29, -1, 124, -1, 102, 124, -1, - -1, 102, -1, -1, -1, -1, 111, 112, 113, 29, - 111, 112, 113, 68, 69, 70, -1, -1, -1, 124, - -1, -1, -1, 124, -1, -1, -1, -1, -1, -1, - 15, -1, 68, 69, 70, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 29, 100, -1, 102, 68, 69, - 70, -1, -1, -1, -1, 110, 111, 112, 113, -1, - -1, 29, -1, -1, 100, -1, 102, -1, -1, 124, - -1, -1, -1, -1, 110, 111, 112, 113, -1, 29, - 100, -1, 102, 68, 69, 70, 36, -1, 124, -1, - 110, 111, 112, 113, -1, -1, -1, -1, -1, -1, - 68, 69, 70, -1, 124, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 29, -1, -1, 102, 68, 69, - 70, -1, -1, -1, -1, -1, 111, 112, 113, -1, - -1, 99, 100, -1, 102, -1, -1, 29, -1, 124, - -1, 29, 110, 111, 112, 113, -1, -1, -1, -1, - 100, -1, 102, 68, 69, 70, 124, -1, -1, -1, - 110, 111, 112, 113, -1, -1, -1, -1, -1, -1, - -1, 63, -1, -1, 124, -1, 68, 69, 70, -1, - 68, 69, 70, -1, 99, 100, -1, 102, 29, -1, - -1, -1, 33, 34, -1, 110, 111, 112, 113, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 100, 124, - 102, 29, 100, -1, 102, 33, 34, -1, 110, 111, - 112, 113, 110, 111, 112, 113, -1, 68, 69, 70, - -1, -1, 124, -1, 29, -1, 124, -1, 29, -1, - -1, 36, -1, -1, -1, 36, -1, -1, -1, -1, - 68, 69, 70, -1, -1, -1, -1, -1, -1, 100, - -1, 102, -1, -1, -1, -1, -1, -1, 63, 110, - 111, 112, 113, 68, 69, 70, -1, 68, 69, 70, - -1, -1, 100, 124, 102, -1, -1, -1, -1, -1, - -1, -1, 110, 111, 112, 113, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 100, 124, 102, -1, 100, - 29, 102, -1, -1, 29, 110, 111, 112, 113, 110, - 111, 112, 113, -1, -1, -1, -1, -1, -1, 124, - 29, -1, -1, 124, -1, 29, -1, 36, -1, 33, - 34, -1, 61, 62, -1, -1, 61, 62, -1, 68, - 69, 70, -1, 68, 69, 70, -1, -1, -1, -1, - -1, -1, -1, -1, 63, -1, -1, -1, -1, 68, - 69, 70, -1, -1, 68, 69, 70, -1, -1, -1, - -1, 100, -1, 102, -1, 100, -1, 102, -1, -1, - -1, 110, 111, 112, 113, 110, 111, 112, 113, -1, - -1, 100, -1, 102, -1, 124, 100, -1, 102, 124, - -1, 110, 111, 112, 113, -1, 110, 111, 112, 113, - -1, -1, -1, -1, -1, 124, -1, 29, -1, -1, - 124, 33, 29, -1, -1, -1, 33, 34, -1, 3, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 13, - -1, -1, -1, 17, -1, -1, -1, -1, -1, -1, - -1, 63, 26, -1, 28, 67, 68, 69, 70, -1, - -1, 68, 69, 70, -1, 39, -1, 41, 42, -1, - -1, -1, -1, -1, -1, 49, -1, -1, 52, 53, - -1, -1, -1, -1, 58, -1, -1, -1, 100, -1, - 102, 65, 66, 100, -1, 102, -1, -1, 110, 111, - 112, 113, -1, 110, 111, 112, 113, -1, 82, -1, - -1, -1, 124, -1, -1, 3, -1, 124, -1, 29, - -1, -1, -1, 33, 34, 13, -1, -1, -1, 17, - -1, -1, -1, -1, -1, -1, -1, -1, 26, -1, - 28, -1, -1, 31, -1, -1, -1, -1, -1, -1, - -1, 39, -1, 41, 42, -1, -1, -1, 68, 69, - 70, 49, -1, -1, 52, 53, -1, -1, -1, -1, - 58, -1, -1, -1, -1, -1, -1, 65, 66, -1, - -1, -1, -1, -1, -1, 95, -1, -1, -1, -1, - 100, -1, 102, -1, 82, -1, -1, -1, -1, -1, - 110, 111, 112, 113, -1, -1, -1, -1, -1, -1, - -1, -1, 12, 13, 124, -1, 3, -1, -1, -1, - -1, -1, 22, 111, -1, -1, 13, -1, -1, 29, - 17, -1, -1, 33, 34, -1, 36, -1, -1, 26, - -1, 28, -1, 43, -1, -1, -1, 47, -1, -1, - -1, -1, 39, -1, 41, 42, -1, -1, -1, -1, - -1, -1, 49, -1, -1, 52, 53, 67, 68, 69, - 70, 58, 72, -1, -1, -1, -1, -1, 65, 66, - -1, -1, -1, 83, 84, 85, -1, -1, -1, -1, - 90, -1, -1, -1, -1, 82, -1, 97, 98, -1, - 100, -1, 102, 103, 104, -1, -1, -1, -1, -1, - 110, 111, 112, 113, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 124, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 12, - 13, -1, -1, -1, -1, -1, -1, -1, -1, 22, - -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, - 33, 34, -1, 36, -1, -1, -1, -1, -1, -1, - 43, -1, -1, -1, 47, -1, -1, -1, -1, -1, + 7, 34, 30, 2, 34, 62, 62, 7, 62, 34, + 101, 34, 34, 57, 34, 57, 83, 69, 7, 17, + 30, 50, 15, 70, 70, 37, 7, 30, 37, 34, + 62, 1, 70, 104, 30, 7, 62, 38, 62, 104, + 15, 49, 37, 62, 34, 62, 34, 8, 7, 62, + 34, 57, 113, 7, 7, 57, 7, 35, 37, 7, + 57, 34, 113, 34, 8, 57, 30, 17, 62, 34, + 38, 62, 17, 104, 48, 37, 62, 7, 34, 34, + 57, 57, 48, 7, 15, 34, 113, 8, 17, 8, + 57, 38, 7, 62, 57, 8, 81, 8, 37, 7, + 7, 2, 62, 8, 8, 63, 63, 49, 8, 8, + 7, 63, 7, 7, 17, 58, 34, 63, 58, 17, + 57, 101, 63, 0, 17, 37, 62, 62, 17, 57, + 57, 17, 7, 17, 17, 37, 62, 2, 63, 49, + 1, 37, 34, 34, 66, 83, 2, 37, 57, 37, + 8, 1, 0, 0, 8, 17, 62, 8, 34, 30, + 83, 95, 95, 95, 49, 7, 38, 8, 17, 8, + 57, 17, 17, 7, 37, 95, 1, 57, 37, 23, + 62, 34, 37, 16, 57, 7, 5, 7, 57, 5, + 5, 34, 62, 7, 62, 7, 34, 37, 34, 7, + 57, 7, 83, 8, 34, 37, 37, 34, 8, 20, + 62, 37, 8, 34, 37, 8, 34, 8, 8, 8, + 57, 34, 57, 7, -1, 8, 7, 15, 52, 8, + 6, 32, 56, 62, 62, 15, -1, 25, 41, 0, + 57, 15, 52, 15, 20, 25, 56, 7, 8, 8, + 53, 25, 65, 8, 63, 64, -1, 57, 10, 63, + 64, 63, 64, 35, 8, 58, 62, 57, 57, 63, + 64, 62, 41, 8, 8, 58, 63, 64, 8, 58, + 7, 63, 64, 8, 53, 63, 64, 41, 63, 64, + 63, 64, 63, 64, 43, 25, 63, 64, 8, 53, + 63, 64, 8, 62, 8, 57, 55, 63, 64, 8, + 37, 95, 58, 114, 58, 41, 111, 112, 63, 64, + 63, 64, 57, 63, 64, 63, 64, 53, 62, 8, + 8, 26, 113, 28, 111, 112, 7, 62, 30, 7, + 7, 30, 103, 48, 39, 30, 30, 57, 8, 17, + 111, 97, 57, 7, 63, 64, 62, 37, 62, 7, + 30, 30, 8, 62, 69, 30, 8, -1, 26, 37, + 28, 17, 0, 8, 30, 8, 8, -1, 15, 58, + 34, 39, 17, 63, 64, 63, 64, 79, 15, 12, + 79, 30, 63, 64, 79, 79, 63, 64, 35, 91, + 37, -1, 91, 12, 113, -1, 91, 91, 35, 79, + 79, 26, 12, 28, 79, 63, 64, 63, 22, 23, + -1, 91, 91, 79, 39, 58, 91, -1, 63, 63, + 64, 63, 64, 5, -1, 91, 59, -1, 10, -1, + 79, 26, 65, 28, 26, -1, 28, -1, 108, 109, + 59, 15, 91, -1, 39, 50, 65, 39, -1, 59, + 94, 18, 19, 18, 19, 65, 108, 109, 63, 64, + -1, 35, -1, 127, -1, 103, 18, 19, -1, 106, + 107, 18, 19, 111, -1, 57, 24, 25, -1, 46, + 47, 46, 47, 15, -1, 33, 100, 7, 36, 15, + 38, 22, 23, 15, 46, 47, 15, -1, -1, 46, + 47, -1, -1, 35, -1, 37, -1, -1, 113, 35, + -1, 37, -1, 35, -1, 37, 35, -1, 37, 118, + 119, 120, 121, 122, 123, -1, 24, 25, -1, 15, + -1, -1, 106, 107, 32, 33, -1, -1, 36, -1, + 38, 15, -1, 63, 64, -1, -1, -1, 34, 35, + -1, 37, -1, -1, -1, -1, -1, 88, 89, -1, + 34, 35, -1, 37, 24, 25, 30, -1, -1, 100, + 10, -1, 32, 33, 106, 107, 36, -1, 38, -1, + 106, 107, 22, 23, 106, 107, -1, 106, 107, -1, + -1, -1, -1, -1, 34, 30, -1, -1, -1, -1, + -1, -1, 30, -1, -1, -1, 70, 71, 72, -1, + 24, 25, -1, -1, -1, -1, -1, -1, -1, 33, + 106, 107, 36, -1, 38, 65, -1, -1, -1, -1, + -1, -1, 106, 107, -1, 70, 71, 72, 15, 79, + 104, 105, 70, 71, 72, -1, -1, -1, 88, 89, + 114, 115, 116, 30, -1, -1, -1, -1, -1, -1, + 100, -1, -1, 127, -1, -1, -1, -1, -1, 104, + 105, -1, -1, -1, 15, -1, 104, 105, -1, 114, + 115, 116, -1, -1, -1, -1, 114, 115, 116, 30, + -1, -1, 127, 70, 71, 72, -1, -1, 15, 127, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 67, 68, 69, 70, -1, 72, + -1, -1, -1, 30, -1, -1, 30, -1, -1, -1, + 30, -1, -1, -1, -1, -1, -1, 104, 105, 70, + 71, 72, -1, -1, -1, -1, -1, 114, 115, 116, + 30, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 127, -1, -1, 70, 71, 72, 70, 71, 72, -1, + 70, 71, 72, 104, 105, -1, -1, 30, -1, -1, + -1, -1, -1, 114, 115, 116, -1, -1, -1, -1, + 70, 71, 72, -1, -1, -1, 127, 104, 105, -1, + 104, 105, 102, 30, 104, 105, -1, 114, 115, 116, + 114, 115, 116, 113, 114, 115, 116, 70, 71, 72, + 127, -1, 102, 127, 104, 105, 15, 127, -1, -1, + -1, -1, -1, 113, 114, 115, 116, -1, -1, -1, + -1, 30, -1, 70, 71, 72, -1, 127, -1, 102, + -1, 104, 105, -1, -1, -1, -1, -1, -1, -1, + 113, 114, 115, 116, -1, 30, -1, -1, -1, -1, + 30, -1, -1, -1, 127, 102, -1, 104, 105, -1, + -1, 70, 71, 72, -1, -1, 113, 114, 115, 116, + -1, 30, -1, -1, -1, -1, -1, -1, -1, -1, + 127, -1, -1, -1, -1, 70, 71, 72, -1, -1, + 70, 71, 72, -1, -1, 104, 105, -1, -1, -1, + -1, -1, -1, -1, -1, 114, 115, 116, -1, -1, + -1, 70, 71, 72, -1, -1, -1, 102, 127, 104, + 105, 30, 102, -1, 104, 105, -1, -1, 113, 114, + 115, 116, -1, 113, 114, 115, 116, -1, -1, -1, + -1, -1, 127, 102, -1, 104, 105, 127, -1, -1, + -1, 30, -1, -1, 113, 114, 115, 116, 37, -1, + -1, 70, 71, 72, -1, -1, -1, -1, 127, 30, + 79, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 91, -1, -1, -1, -1, -1, -1, -1, + -1, 70, 71, 72, -1, 104, 105, -1, -1, -1, + -1, -1, -1, -1, -1, 114, 115, 116, -1, 70, + 71, 72, -1, -1, -1, -1, -1, 30, 127, -1, + -1, 30, -1, 102, 37, 104, 105, -1, -1, -1, + -1, -1, -1, -1, 113, 114, 115, 116, -1, -1, + 101, 102, -1, 104, 105, -1, -1, -1, 127, -1, + -1, -1, 113, 114, 115, 116, -1, 70, 71, 72, + -1, 70, 71, 72, -1, -1, 127, -1, 30, -1, + 79, -1, -1, -1, -1, 37, -1, -1, -1, -1, + -1, -1, 91, 30, -1, -1, -1, -1, -1, 102, + 37, 104, 105, -1, -1, 104, 105, -1, -1, -1, + 113, 114, 115, 116, 30, 114, 115, 116, 70, 71, + 72, -1, -1, -1, 127, -1, -1, -1, 127, -1, + -1, 30, -1, 70, 71, 72, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 63, 64, -1, + 102, -1, 104, 105, 70, 71, 72, -1, -1, -1, + -1, 113, 114, 115, 116, 102, -1, 104, 105, -1, + -1, 70, 71, 72, -1, 127, 113, 114, 115, 116, + -1, -1, -1, -1, -1, -1, 102, -1, 104, 105, + 127, -1, 30, -1, -1, -1, -1, 113, 114, 115, + 116, -1, 101, 102, -1, 104, 105, -1, -1, -1, + -1, 127, -1, -1, 113, 114, 115, 116, -1, -1, + -1, -1, -1, -1, -1, 63, 64, -1, 127, -1, + -1, 30, 70, 71, 72, 34, 35, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 83, 84, 85, -1, -1, -1, -1, 90, -1, -1, - -1, -1, -1, -1, 97, 98, -1, 100, -1, 102, - 103, 104, -1, -1, -1, -1, -1, 110, 111, 112, - 113, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 124, -1, 12, 13, -1, -1, -1, -1, -1, - -1, -1, -1, 22, -1, -1, -1, -1, -1, -1, - 29, -1, -1, -1, 33, 34, -1, 36, -1, -1, - -1, -1, -1, -1, 43, -1, -1, -1, 47, -1, + -1, -1, -1, -1, -1, 30, -1, -1, -1, 34, + -1, -1, -1, -1, 102, -1, 104, 105, -1, -1, + -1, 70, 71, 72, -1, 113, 114, 115, 116, 30, + -1, -1, -1, 34, 35, -1, -1, -1, -1, 127, + 65, -1, -1, -1, 69, 70, 71, 72, -1, -1, + -1, -1, -1, 102, -1, 104, 105, 30, -1, -1, + -1, 34, 35, -1, 113, 114, 115, 116, -1, 70, + 71, 72, -1, -1, -1, -1, -1, 102, 127, 104, + 105, 30, -1, -1, -1, 34, 35, -1, 113, 114, + 115, 116, -1, -1, -1, -1, 97, 70, 71, 72, + -1, 102, 127, 104, 105, -1, -1, -1, -1, -1, + -1, -1, 113, 114, 115, 116, -1, -1, -1, -1, + -1, 70, 71, 72, 97, -1, 127, -1, -1, 102, + -1, 104, 105, -1, -1, -1, -1, -1, -1, -1, + 113, 114, 115, 116, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 102, 127, 104, 105, -1, -1, -1, + -1, -1, -1, -1, 113, 114, 115, 116, 30, -1, + -1, -1, 34, 35, -1, -1, -1, -1, 127, -1, + -1, 3, -1, 30, -1, -1, -1, 34, 35, -1, + -1, 13, -1, -1, -1, 17, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 27, -1, 29, 70, 71, + 72, -1, -1, -1, -1, -1, -1, -1, 40, -1, + 42, 43, -1, 70, 71, 72, -1, -1, -1, 51, + -1, -1, 54, 55, -1, 97, -1, -1, 60, -1, + 102, -1, 104, 105, -1, 67, 68, -1, -1, -1, + 97, 113, 114, 115, 116, 102, -1, 104, 105, -1, + -1, -1, 84, 3, -1, 127, 113, 114, 115, 116, + -1, -1, -1, 13, -1, -1, -1, 17, -1, -1, + 127, -1, -1, -1, -1, -1, -1, 27, -1, 29, + -1, -1, -1, 30, -1, -1, -1, 34, 35, -1, + 40, -1, 42, 43, -1, -1, -1, -1, 30, -1, + -1, 51, 34, 35, 54, 55, -1, -1, -1, -1, + 60, -1, -1, -1, -1, -1, -1, 67, 68, -1, + -1, -1, -1, 70, 71, 72, -1, -1, -1, -1, + -1, -1, -1, -1, 84, -1, -1, -1, 70, 71, + 72, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 97, -1, -1, -1, -1, 102, -1, 104, 105, -1, + -1, -1, -1, -1, -1, 97, 113, 114, 115, 116, + 102, -1, 104, 105, -1, -1, -1, -1, -1, -1, + 127, 113, 114, 115, 116, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 127, -1, -1, 30, -1, + -1, -1, 34, 35, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 67, 68, - 69, 70, -1, 72, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 83, 84, 85, -1, -1, -1, - -1, 90, -1, -1, -1, -1, -1, -1, 97, 98, - -1, 100, -1, 102, 103, 104, -1, -1, -1, -1, - -1, 110, 111, 112, 113, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 124, -1, 12, 13, -1, - 15, -1, -1, -1, -1, -1, -1, 22, -1, -1, - -1, -1, -1, -1, 29, -1, -1, -1, 33, 34, - -1, 36, -1, -1, -1, -1, -1, -1, 43, -1, - -1, -1, 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 67, 68, 69, 70, -1, 72, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 83, 84, - 85, -1, -1, -1, -1, 90, -1, -1, -1, -1, - -1, -1, 97, 98, -1, 100, -1, 102, 103, 104, - -1, -1, -1, -1, -1, 110, 111, 112, 113, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 124, - -1, 12, 13, -1, 15, -1, -1, -1, -1, -1, - -1, 22, -1, -1, -1, -1, -1, -1, 29, -1, - -1, -1, 33, 34, -1, 36, -1, -1, -1, -1, - -1, -1, 43, -1, -1, -1, 47, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 70, 71, + 72, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 67, 68, 69, 70, - -1, 72, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 83, 84, 85, -1, -1, -1, -1, 90, - -1, -1, -1, -1, -1, -1, 97, 98, -1, 100, - -1, 102, 103, 104, -1, -1, -1, -1, -1, 110, - 111, 112, 113, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 124, -1, 10, -1, 12, 13, -1, - -1, -1, -1, -1, -1, -1, -1, 22, -1, -1, - -1, -1, -1, -1, 29, -1, -1, -1, 33, 34, - -1, 36, -1, -1, -1, -1, -1, -1, 43, -1, - -1, -1, 47, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 97, -1, -1, -1, -1, + 102, -1, 104, 105, -1, -1, -1, -1, -1, -1, + -1, 113, 114, 115, 116, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 127, -1, -1, 3, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 13, -1, + -1, -1, 17, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 27, -1, 29, -1, -1, 32, -1, -1, + -1, -1, -1, -1, -1, 40, -1, 42, 43, -1, + -1, -1, -1, -1, -1, -1, 51, -1, -1, 54, + 55, -1, -1, -1, -1, 60, -1, -1, -1, -1, + -1, -1, 67, 68, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 84, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 67, 68, 69, 70, -1, 72, -1, -1, - -1, -1, 77, -1, -1, -1, -1, -1, 83, 84, - 85, -1, -1, -1, -1, 90, -1, -1, -1, 94, - -1, -1, 97, 98, -1, 100, -1, 102, 103, 104, - -1, -1, -1, -1, -1, 110, 111, 112, 113, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 124, - -1, 10, -1, 12, 13, -1, -1, -1, -1, -1, - -1, -1, -1, 22, -1, -1, -1, -1, -1, -1, - 29, -1, -1, -1, 33, 34, -1, 36, -1, -1, - -1, -1, -1, -1, 43, -1, -1, -1, 47, -1, - -1, -1, -1, -1, -1, -1, 55, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 67, 68, - 69, 70, -1, 72, -1, -1, -1, -1, 77, -1, - -1, -1, -1, -1, 83, 84, 85, -1, -1, -1, - -1, 90, -1, -1, -1, 94, -1, -1, 97, 98, - -1, 100, -1, 102, 103, 104, -1, -1, -1, -1, - -1, 110, 111, 112, 113, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 124, -1, 10, -1, 12, - 13, -1, -1, -1, -1, -1, -1, -1, -1, 22, - -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, - 33, 34, -1, 36, -1, -1, -1, -1, -1, -1, - 43, -1, -1, -1, 47, -1, -1, -1, -1, -1, - -1, -1, 55, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 67, 68, 69, 70, -1, 72, - -1, -1, -1, -1, 77, -1, -1, -1, -1, -1, - 83, 84, 85, -1, -1, -1, -1, 90, -1, -1, - -1, 94, -1, -1, 97, 98, -1, 100, -1, 102, - 103, 104, -1, -1, -1, -1, -1, 110, 111, 112, - 113, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 124, -1, 11, 12, 13, -1, -1, -1, -1, - -1, -1, -1, -1, 22, -1, -1, -1, -1, -1, - -1, 29, -1, -1, -1, 33, 34, -1, 36, -1, - -1, -1, 40, -1, 42, 43, 44, -1, -1, 47, - -1, -1, -1, 51, -1, 53, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, - 68, 69, 70, -1, 72, -1, 74, -1, 76, -1, - 78, -1, -1, -1, -1, 83, 84, 85, -1, -1, - -1, -1, 90, -1, -1, -1, -1, -1, -1, 97, - 98, -1, 100, -1, 102, 103, 104, -1, -1, -1, - -1, -1, 110, 111, 112, 113, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 124, -1, 11, 12, - 13, -1, -1, -1, -1, -1, -1, -1, -1, 22, - -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, - 33, 34, -1, 36, -1, -1, -1, 40, -1, 42, - 43, 44, -1, -1, 47, -1, -1, -1, 51, -1, - 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 67, 68, 69, 70, -1, 72, - -1, 74, -1, 76, -1, 78, -1, -1, -1, -1, - 83, 84, 85, -1, -1, -1, -1, 90, -1, -1, - -1, -1, -1, 96, 97, 98, -1, 100, -1, 102, - 103, 104, -1, -1, -1, -1, -1, 110, 111, 112, - 113, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 124, -1, 11, 12, 13, -1, -1, -1, -1, - -1, -1, -1, -1, 22, -1, -1, -1, -1, -1, - -1, 29, -1, -1, -1, 33, 34, -1, 36, -1, - -1, -1, 40, -1, 42, 43, 44, -1, -1, 47, - -1, -1, -1, 51, -1, 53, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 67, - 68, 69, 70, -1, 72, -1, 74, -1, 76, -1, - 78, -1, -1, -1, -1, 83, 84, 85, -1, -1, - -1, -1, 90, -1, -1, -1, -1, -1, 96, 97, - 98, -1, 100, -1, 102, 103, 104, -1, -1, -1, - -1, -1, 110, 111, 112, 113, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 124, -1, 11, 12, - 13, -1, -1, -1, -1, -1, -1, -1, -1, 22, - -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, - 33, 34, -1, 36, -1, -1, -1, 40, -1, 42, - 43, 44, -1, -1, 47, -1, -1, -1, 51, -1, - 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 67, 68, 69, 70, -1, 72, - -1, 74, -1, 76, -1, 78, -1, -1, -1, -1, - 83, 84, 85, -1, -1, -1, -1, 90, -1, -1, - -1, -1, 95, 96, 97, 98, -1, 100, -1, 102, - 103, 104, -1, -1, -1, -1, -1, 110, 111, 112, - 113, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 124, -1, 8, -1, -1, 11, 12, 13, -1, - -1, -1, -1, -1, -1, -1, -1, 22, -1, -1, - -1, -1, -1, -1, 29, -1, -1, -1, 33, 34, - -1, 36, -1, -1, -1, 40, -1, 42, 43, 44, - -1, -1, 47, -1, -1, -1, 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 67, 68, 69, 70, -1, 72, -1, 74, - -1, 76, -1, 78, -1, -1, -1, -1, 83, 84, - 85, -1, -1, -1, -1, 90, -1, -1, -1, -1, - -1, 96, 97, 98, -1, 100, -1, 102, 103, 104, - -1, -1, -1, -1, -1, 110, 111, 112, 113, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 124, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 114, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 12, 13, -1, -1, -1, + -1, -1, -1, -1, -1, 22, 23, -1, -1, -1, + -1, -1, -1, 30, -1, -1, -1, 34, 35, -1, + 37, -1, -1, -1, -1, -1, -1, 44, -1, -1, + -1, 48, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 69, 70, 71, 72, -1, 74, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 85, 86, + 87, -1, -1, -1, -1, 92, -1, -1, -1, -1, + -1, -1, 99, 100, -1, 102, -1, 104, 105, 106, + 107, -1, -1, -1, -1, -1, 113, 114, 115, 116, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 127, -1, -1, 12, 13, -1, -1, -1, -1, -1, + -1, -1, -1, 22, 23, -1, -1, -1, -1, -1, + -1, 30, -1, -1, -1, 34, 35, -1, 37, -1, + -1, -1, -1, -1, -1, 44, -1, -1, -1, 48, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 69, 70, 71, 72, -1, 74, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 85, 86, 87, -1, + -1, -1, -1, 92, -1, -1, -1, -1, -1, -1, + 99, 100, -1, 102, -1, 104, 105, 106, 107, -1, + -1, -1, -1, -1, 113, 114, 115, 116, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 127, -1, + -1, 12, 13, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, -1, -1, -1, -1, -1, -1, 30, + -1, -1, -1, 34, 35, -1, 37, -1, -1, -1, + -1, -1, -1, 44, -1, -1, -1, 48, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 69, 70, + 71, 72, -1, 74, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 85, 86, 87, -1, -1, -1, + 91, 92, -1, -1, -1, -1, -1, -1, 99, 100, + -1, 102, -1, 104, 105, 106, 107, -1, -1, -1, + -1, -1, 113, 114, 115, 116, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 127, -1, -1, 12, + 13, -1, 15, -1, -1, -1, -1, -1, -1, 22, + 23, -1, -1, -1, -1, -1, -1, 30, -1, -1, + -1, 34, 35, -1, 37, -1, -1, -1, -1, -1, + -1, 44, -1, -1, -1, 48, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 69, 70, 71, 72, + -1, 74, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 85, 86, 87, -1, -1, -1, -1, 92, + -1, -1, -1, -1, -1, -1, 99, 100, -1, 102, + -1, 104, 105, 106, 107, -1, -1, -1, -1, -1, + 113, 114, 115, 116, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 127, -1, -1, 12, 13, -1, + 15, -1, -1, -1, -1, -1, -1, 22, 23, -1, + -1, -1, -1, -1, -1, 30, -1, -1, -1, 34, + 35, -1, 37, -1, -1, -1, -1, -1, -1, 44, + -1, -1, -1, 48, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 69, 70, 71, 72, -1, 74, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 85, 86, 87, -1, -1, -1, -1, 92, -1, -1, + -1, -1, -1, -1, 99, 100, -1, 102, -1, 104, + 105, 106, 107, -1, -1, -1, -1, -1, 113, 114, + 115, 116, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 127, -1, -1, 10, -1, 12, 13, -1, + -1, -1, -1, -1, -1, -1, -1, 22, 23, -1, + -1, -1, -1, -1, -1, 30, -1, -1, -1, 34, + 35, -1, 37, -1, -1, -1, -1, -1, -1, 44, + -1, -1, -1, 48, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 69, 70, 71, 72, -1, 74, + -1, -1, -1, -1, 79, -1, -1, -1, -1, -1, + 85, 86, 87, -1, -1, -1, -1, 92, -1, -1, + -1, 96, -1, -1, 99, 100, -1, 102, -1, 104, + 105, 106, 107, -1, -1, -1, -1, -1, 113, 114, + 115, 116, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 127, -1, -1, 10, -1, 12, 13, -1, + -1, -1, -1, -1, -1, -1, -1, 22, 23, -1, + -1, -1, -1, -1, -1, 30, -1, -1, -1, 34, + 35, -1, 37, -1, -1, -1, -1, -1, -1, 44, + -1, -1, -1, 48, -1, -1, -1, -1, -1, -1, + -1, -1, 57, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 69, 70, 71, 72, -1, 74, + -1, -1, -1, -1, 79, -1, -1, -1, -1, -1, + 85, 86, 87, -1, -1, -1, -1, 92, -1, -1, + -1, 96, -1, -1, 99, 100, -1, 102, -1, 104, + 105, 106, 107, -1, -1, -1, -1, -1, 113, 114, + 115, 116, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 127, -1, -1, 10, -1, 12, 13, -1, + -1, -1, -1, -1, -1, -1, -1, 22, 23, -1, + -1, -1, -1, -1, -1, 30, -1, -1, -1, 34, + 35, -1, 37, -1, -1, -1, -1, -1, -1, 44, + -1, -1, -1, 48, -1, -1, -1, -1, -1, -1, + -1, -1, 57, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 69, 70, 71, 72, -1, 74, + -1, -1, -1, -1, 79, -1, -1, -1, -1, -1, + 85, 86, 87, -1, -1, -1, -1, 92, -1, -1, + -1, 96, -1, -1, 99, 100, -1, 102, -1, 104, + 105, 106, 107, -1, -1, -1, -1, -1, 113, 114, + 115, 116, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 127, -1, -1, 11, 12, 13, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, -1, -1, + -1, -1, -1, -1, 30, -1, -1, -1, 34, 35, + -1, 37, -1, -1, -1, 41, -1, 43, 44, 45, + -1, -1, 48, -1, -1, -1, -1, 53, -1, 55, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 69, 70, 71, 72, -1, 74, -1, + 76, -1, 78, -1, 80, -1, -1, -1, -1, 85, + 86, 87, -1, -1, -1, -1, 92, -1, -1, -1, + -1, -1, -1, 99, 100, -1, 102, -1, 104, 105, + 106, 107, -1, -1, -1, -1, -1, 113, 114, 115, + 116, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 127, -1, -1, 11, 12, 13, -1, -1, -1, + -1, -1, -1, -1, -1, 22, 23, -1, -1, -1, + -1, -1, -1, 30, -1, -1, -1, 34, 35, -1, + 37, -1, -1, -1, 41, -1, 43, 44, 45, -1, + -1, 48, -1, -1, -1, -1, 53, -1, 55, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 69, 70, 71, 72, -1, 74, -1, 76, + -1, 78, -1, 80, -1, -1, -1, -1, 85, 86, + 87, -1, -1, -1, -1, 92, -1, -1, -1, -1, + -1, 98, 99, 100, -1, 102, -1, 104, 105, 106, + 107, -1, -1, -1, -1, -1, 113, 114, 115, 116, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 127, -1, -1, 11, 12, 13, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, -1, -1, -1, -1, + -1, -1, 30, -1, -1, -1, 34, 35, -1, 37, + -1, -1, -1, 41, -1, 43, 44, 45, -1, -1, + 48, -1, -1, -1, -1, 53, -1, 55, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 69, 70, 71, 72, -1, 74, -1, 76, -1, + 78, -1, 80, -1, -1, -1, -1, 85, 86, 87, + -1, -1, -1, -1, 92, -1, -1, -1, -1, -1, + 98, 99, 100, -1, 102, -1, 104, 105, 106, 107, + -1, -1, -1, -1, -1, 113, 114, 115, 116, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 127, + -1, -1, 11, 12, 13, -1, -1, -1, -1, -1, + -1, -1, -1, 22, 23, -1, -1, -1, -1, -1, + -1, 30, -1, -1, -1, 34, 35, -1, 37, -1, + -1, -1, 41, -1, 43, 44, 45, -1, -1, 48, + -1, -1, -1, -1, 53, -1, 55, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 69, 70, 71, 72, -1, 74, -1, 76, -1, 78, + -1, 80, -1, -1, -1, -1, 85, 86, 87, -1, + -1, -1, -1, 92, -1, -1, -1, -1, -1, 98, + 99, 100, -1, 102, -1, 104, 105, 106, 107, -1, + -1, -1, -1, -1, 113, 114, 115, 116, -1, -1, + -1, -1, -1, -1, -1, -1, 125, -1, 127, -1, -1, 11, 12, 13, -1, -1, -1, -1, -1, -1, - -1, -1, 22, -1, -1, -1, -1, -1, -1, 29, - -1, -1, -1, 33, 34, -1, 36, -1, -1, -1, - 40, -1, 42, 43, 44, -1, -1, 47, -1, -1, - -1, 51, -1, 53, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 67, 68, 69, - 70, -1, 72, -1, 74, -1, 76, -1, 78, -1, - -1, -1, -1, 83, 84, 85, -1, -1, -1, -1, - 90, -1, -1, -1, -1, 95, 96, 97, 98, -1, - 100, -1, 102, 103, 104, -1, -1, -1, -1, -1, - 110, 111, 112, 113, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 124, -1, 11, 12, 13, -1, - -1, -1, -1, -1, -1, -1, -1, 22, -1, -1, - -1, -1, -1, -1, 29, -1, -1, -1, 33, 34, - -1, 36, -1, -1, -1, 40, -1, 42, 43, 44, - -1, -1, 47, -1, -1, -1, 51, -1, 53, -1, + -1, -1, 22, 23, -1, -1, -1, -1, -1, -1, + 30, -1, -1, -1, 34, 35, -1, 37, -1, -1, + -1, 41, -1, 43, 44, 45, -1, -1, 48, -1, + -1, -1, -1, 53, -1, 55, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 69, + 70, 71, 72, -1, 74, -1, 76, -1, 78, -1, + 80, -1, -1, -1, -1, 85, 86, 87, -1, -1, + -1, -1, 92, -1, -1, -1, -1, -1, 98, 99, + 100, -1, 102, -1, 104, 105, 106, 107, -1, -1, + -1, -1, -1, 113, 114, 115, 116, -1, -1, -1, + -1, -1, -1, -1, 124, -1, -1, 127, -1, -1, + 8, -1, -1, 11, 12, 13, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, -1, -1, -1, -1, + -1, -1, 30, -1, -1, -1, 34, 35, -1, 37, + -1, -1, -1, 41, -1, 43, 44, 45, -1, -1, + 48, -1, -1, -1, -1, 53, -1, 55, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 67, 68, 69, 70, -1, 72, -1, 74, - -1, 76, -1, 78, -1, -1, -1, -1, 83, 84, - 85, -1, -1, -1, -1, 90, -1, -1, -1, -1, - 95, 96, 97, 98, -1, 100, -1, 102, 103, 104, - -1, -1, -1, -1, -1, 110, 111, 112, 113, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 124, - -1, 8, -1, -1, 11, 12, 13, -1, -1, -1, - -1, -1, -1, -1, -1, 22, -1, -1, -1, -1, - -1, -1, 29, -1, -1, -1, 33, 34, -1, 36, - -1, -1, -1, 40, -1, 42, 43, 44, -1, -1, - 47, -1, -1, -1, 51, -1, 53, -1, -1, -1, + -1, 69, 70, 71, 72, -1, 74, -1, 76, -1, + 78, -1, 80, -1, -1, -1, -1, 85, 86, 87, + -1, -1, -1, -1, 92, -1, -1, -1, -1, -1, + 98, 99, 100, -1, 102, -1, 104, 105, 106, 107, + -1, -1, -1, -1, -1, 113, 114, 115, 116, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 127, + -1, -1, 11, 12, 13, -1, -1, -1, -1, -1, + -1, -1, -1, 22, 23, -1, -1, -1, -1, -1, + -1, 30, -1, -1, -1, 34, 35, -1, 37, -1, + -1, -1, 41, -1, 43, 44, 45, -1, -1, 48, + -1, -1, -1, -1, 53, -1, 55, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 67, 68, 69, 70, -1, 72, -1, 74, -1, 76, - -1, 78, -1, -1, -1, -1, 83, 84, 85, -1, - -1, -1, -1, 90, -1, -1, -1, -1, -1, 96, - 97, 98, -1, 100, -1, 102, 103, 104, -1, -1, - -1, -1, -1, 110, 111, 112, 113, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 124, -1, 11, + 69, 70, 71, 72, -1, 74, -1, 76, -1, 78, + -1, 80, -1, -1, -1, -1, 85, 86, 87, -1, + -1, -1, -1, 92, -1, -1, -1, -1, 97, 98, + 99, 100, -1, 102, -1, 104, 105, 106, 107, -1, + -1, -1, -1, -1, 113, 114, 115, 116, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 127, -1, + -1, 11, 12, 13, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, -1, -1, -1, -1, -1, -1, + 30, -1, -1, -1, 34, 35, -1, 37, -1, -1, + -1, 41, -1, 43, 44, 45, -1, -1, 48, -1, + -1, -1, -1, 53, -1, 55, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 69, + 70, 71, 72, -1, 74, -1, 76, -1, 78, -1, + 80, -1, -1, -1, -1, 85, 86, 87, -1, -1, + -1, -1, 92, -1, -1, -1, -1, 97, 98, 99, + 100, -1, 102, -1, 104, 105, 106, 107, -1, -1, + -1, -1, -1, 113, 114, 115, 116, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 127, -1, -1, + 11, 12, 13, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, -1, -1, -1, -1, -1, -1, 30, + -1, -1, -1, 34, 35, -1, 37, -1, -1, -1, + 41, -1, 43, 44, 45, -1, -1, 48, -1, -1, + -1, -1, 53, -1, 55, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 69, 70, + 71, 72, -1, 74, -1, 76, -1, 78, -1, 80, + -1, -1, -1, -1, 85, 86, 87, -1, -1, -1, + -1, 92, -1, -1, -1, -1, 97, 98, 99, 100, + -1, 102, -1, 104, 105, 106, 107, -1, -1, -1, + -1, -1, 113, 114, 115, 116, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 127, -1, -1, 11, 12, 13, -1, -1, -1, -1, -1, -1, -1, -1, - 22, -1, -1, -1, -1, -1, -1, 29, -1, -1, - -1, 33, 34, -1, 36, -1, -1, -1, 40, -1, - 42, 43, 44, -1, -1, 47, -1, -1, -1, 51, - -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 63, -1, -1, -1, 67, 68, 69, 70, -1, - 72, -1, 74, -1, 76, -1, 78, -1, -1, -1, - -1, 83, 84, 85, -1, -1, -1, -1, 90, -1, - -1, -1, -1, -1, 96, 97, 98, -1, 100, -1, - 102, 103, 104, -1, -1, -1, -1, -1, 110, 111, - 112, 113, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 124, -1, 11, 12, 13, -1, -1, -1, - -1, -1, -1, -1, -1, 22, -1, -1, -1, -1, - -1, -1, 29, -1, -1, -1, 33, 34, -1, 36, - -1, -1, -1, 40, -1, 42, 43, 44, -1, -1, - 47, -1, -1, -1, 51, -1, 53, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 67, 68, 69, 70, -1, 72, -1, 74, -1, 76, - -1, 78, -1, -1, -1, -1, 83, 84, 85, -1, - -1, -1, -1, 90, -1, -1, -1, -1, -1, 96, - 97, 98, -1, 100, -1, 102, 103, 104, -1, -1, - -1, -1, -1, 110, 111, 112, 113, -1, -1, -1, - -1, -1, -1, -1, -1, 122, -1, 124, -1, 11, + 22, 23, -1, -1, -1, -1, -1, -1, 30, -1, + -1, -1, 34, 35, -1, 37, -1, -1, -1, 41, + -1, 43, 44, 45, -1, -1, 48, -1, -1, -1, + -1, 53, -1, 55, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 69, 70, 71, + 72, -1, 74, -1, 76, -1, 78, -1, 80, -1, + -1, -1, -1, 85, 86, 87, -1, -1, -1, -1, + 92, -1, -1, -1, -1, -1, 98, 99, 100, -1, + 102, -1, 104, 105, 106, 107, -1, -1, -1, -1, + -1, 113, 114, 115, 116, -1, -1, -1, -1, -1, + -1, -1, -1, 125, -1, 127, -1, -1, 11, 12, + 13, -1, -1, -1, -1, -1, -1, -1, -1, 22, + 23, -1, -1, -1, -1, -1, -1, 30, -1, -1, + -1, 34, 35, -1, 37, -1, -1, -1, 41, -1, + 43, 44, 45, -1, -1, 48, -1, -1, -1, -1, + 53, -1, 55, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 65, -1, -1, -1, 69, 70, 71, 72, + -1, 74, -1, 76, -1, 78, -1, 80, -1, -1, + -1, -1, 85, 86, 87, -1, -1, -1, -1, 92, + -1, -1, -1, -1, -1, 98, 99, 100, -1, 102, + -1, 104, 105, 106, 107, -1, -1, -1, -1, -1, + 113, 114, 115, 116, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 127, -1, -1, 11, 12, 13, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + -1, -1, -1, -1, -1, -1, 30, -1, -1, -1, + 34, 35, -1, 37, -1, -1, -1, 41, -1, 43, + 44, 45, -1, -1, 48, -1, -1, -1, -1, 53, + -1, 55, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 65, -1, -1, -1, 69, 70, 71, 72, -1, + 74, -1, 76, -1, 78, -1, 80, -1, -1, -1, + -1, 85, 86, 87, -1, -1, -1, -1, 92, -1, + -1, -1, -1, -1, 98, 99, 100, -1, 102, -1, + 104, 105, 106, 107, -1, -1, -1, -1, -1, 113, + 114, 115, 116, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 127, -1, -1, 8, -1, -1, 11, 12, 13, -1, -1, -1, -1, -1, -1, -1, -1, - 22, -1, -1, -1, -1, -1, -1, 29, -1, -1, - -1, 33, 34, -1, 36, -1, -1, -1, 40, -1, - 42, 43, 44, -1, -1, 47, -1, -1, -1, 51, - -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 67, 68, 69, 70, -1, - 72, -1, 74, -1, 76, -1, 78, -1, -1, -1, - -1, 83, 84, 85, -1, -1, -1, -1, 90, -1, - -1, -1, -1, -1, 96, 97, 98, -1, 100, -1, - 102, 103, 104, -1, -1, -1, -1, -1, 110, 111, - 112, 113, -1, -1, -1, -1, -1, -1, -1, -1, - 122, -1, 124, -1, 11, 12, 13, -1, -1, -1, - -1, -1, -1, -1, -1, 22, -1, -1, -1, -1, - -1, -1, 29, -1, -1, -1, 33, 34, -1, 36, - -1, -1, -1, 40, -1, 42, 43, 44, -1, -1, - 47, -1, -1, -1, 51, -1, 53, -1, -1, -1, + 22, 23, -1, -1, -1, -1, -1, -1, 30, -1, + -1, -1, 34, 35, -1, 37, -1, -1, -1, 41, + -1, 43, 44, 45, -1, -1, 48, -1, -1, -1, + -1, 53, -1, 55, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 69, 70, 71, + 72, -1, 74, -1, 76, -1, 78, -1, 80, -1, + -1, -1, -1, 85, 86, 87, -1, -1, -1, -1, + 92, -1, -1, -1, -1, -1, 98, 99, 100, -1, + 102, -1, 104, 105, 106, 107, -1, -1, -1, -1, + -1, 113, 114, 115, 116, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 127, -1, -1, 11, 12, + 13, -1, -1, -1, -1, -1, -1, -1, -1, 22, + 23, -1, -1, -1, -1, -1, -1, 30, -1, -1, + -1, 34, 35, -1, 37, -1, -1, -1, 41, -1, + 43, 44, 45, -1, -1, 48, -1, -1, -1, -1, + 53, -1, 55, -1, -1, -1, -1, -1, -1, 62, + -1, -1, -1, -1, -1, -1, 69, 70, 71, 72, + -1, 74, -1, 76, -1, 78, -1, 80, -1, -1, + -1, -1, 85, 86, 87, -1, -1, -1, -1, 92, + -1, -1, -1, -1, 97, 98, 99, 100, -1, 102, + -1, 104, 105, 106, 107, -1, -1, -1, -1, -1, + 113, 114, 115, 116, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 127, -1, -1, 11, 12, 13, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + -1, -1, -1, -1, -1, -1, 30, -1, -1, -1, + 34, 35, -1, 37, -1, -1, -1, 41, -1, 43, + 44, 45, -1, -1, 48, -1, -1, -1, -1, 53, + -1, 55, -1, -1, 58, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 69, 70, 71, 72, -1, + 74, -1, 76, -1, 78, -1, 80, -1, -1, -1, + -1, 85, 86, 87, -1, -1, -1, -1, 92, -1, + -1, -1, -1, 97, 98, 99, 100, -1, 102, -1, + 104, 105, 106, 107, -1, -1, -1, -1, -1, 113, + 114, 115, 116, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 127, -1, -1, 11, 12, 13, -1, + -1, -1, -1, -1, -1, -1, -1, 22, 23, -1, + -1, -1, -1, -1, -1, 30, -1, -1, -1, 34, + 35, -1, 37, -1, -1, -1, 41, -1, 43, 44, + 45, -1, -1, 48, -1, -1, -1, -1, 53, -1, + 55, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 69, 70, 71, 72, -1, 74, + -1, 76, -1, 78, 79, 80, -1, -1, -1, -1, + 85, 86, 87, 88, 89, -1, -1, 92, -1, -1, + -1, -1, -1, 98, 99, 100, -1, 102, -1, 104, + 105, 106, 107, -1, -1, -1, -1, -1, 113, 114, + 115, 116, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 127, -1, -1, 11, 12, 13, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, -1, -1, + -1, -1, -1, -1, 30, 31, -1, -1, 34, 35, + -1, 37, -1, -1, -1, 41, -1, 43, 44, 45, + -1, -1, 48, -1, -1, -1, -1, 53, -1, 55, + -1, -1, -1, -1, -1, -1, -1, 63, -1, -1, + -1, -1, -1, 69, 70, 71, 72, 73, 74, -1, + 76, 77, 78, -1, 80, -1, 82, -1, -1, 85, + 86, 87, -1, -1, -1, -1, 92, -1, -1, -1, + -1, -1, 98, 99, 100, -1, 102, -1, 104, 105, + 106, 107, -1, -1, -1, -1, -1, 113, 114, 115, + 116, -1, -1, -1, -1, -1, -1, -1, 124, 125, + -1, 127, -1, -1, 11, 12, 13, -1, -1, -1, + -1, -1, -1, -1, -1, 22, 23, -1, -1, -1, + -1, -1, -1, 30, 31, -1, -1, 34, 35, -1, + 37, -1, -1, -1, 41, -1, 43, 44, 45, -1, + -1, 48, -1, -1, -1, -1, 53, -1, 55, -1, -1, -1, -1, -1, -1, -1, 63, -1, -1, -1, - 67, 68, 69, 70, -1, 72, -1, 74, -1, 76, - -1, 78, -1, -1, -1, -1, 83, 84, 85, -1, - -1, -1, -1, 90, -1, -1, -1, -1, -1, 96, - 97, 98, -1, 100, -1, 102, 103, 104, -1, -1, - -1, -1, -1, 110, 111, 112, 113, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 124, -1, 11, - 12, 13, -1, -1, -1, -1, -1, -1, -1, -1, - 22, -1, -1, -1, -1, -1, -1, 29, -1, -1, - -1, 33, 34, -1, 36, -1, -1, -1, 40, -1, - 42, 43, 44, -1, -1, 47, -1, -1, -1, 51, - -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 67, 68, 69, 70, -1, - 72, -1, 74, -1, 76, -1, 78, -1, -1, -1, - -1, 83, 84, 85, -1, -1, -1, -1, 90, -1, - -1, -1, -1, -1, 96, 97, 98, -1, 100, -1, - 102, 103, 104, -1, -1, -1, -1, -1, 110, 111, - 112, 113, -1, -1, -1, -1, -1, -1, -1, 121, - -1, -1, 124, -1, 11, 12, 13, -1, -1, -1, - -1, -1, -1, -1, -1, 22, -1, -1, -1, -1, - -1, -1, 29, -1, -1, -1, 33, 34, -1, 36, - -1, -1, -1, 40, -1, 42, 43, 44, -1, -1, - 47, -1, -1, -1, 51, -1, 53, -1, -1, -1, - -1, -1, -1, 60, -1, -1, -1, -1, -1, -1, - 67, 68, 69, 70, -1, 72, -1, 74, -1, 76, - -1, 78, -1, -1, -1, -1, 83, 84, 85, -1, - -1, -1, -1, 90, -1, -1, -1, -1, 95, 96, - 97, 98, -1, 100, -1, 102, 103, 104, -1, -1, - -1, -1, -1, 110, 111, 112, 113, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 124, -1, 11, - 12, 13, -1, -1, -1, -1, -1, -1, -1, -1, - 22, -1, -1, -1, -1, -1, -1, 29, -1, -1, - -1, 33, 34, -1, 36, -1, -1, -1, 40, -1, - 42, 43, 44, -1, -1, 47, -1, -1, -1, 51, - -1, 53, -1, -1, 56, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 67, 68, 69, 70, -1, - 72, -1, 74, -1, 76, -1, 78, -1, -1, -1, - -1, 83, 84, 85, -1, -1, -1, -1, 90, -1, - -1, -1, -1, 95, 96, 97, 98, -1, 100, -1, - 102, 103, 104, -1, -1, -1, -1, -1, 110, 111, - 112, 113, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 124, -1, 11, 12, 13, -1, -1, -1, - -1, -1, -1, -1, -1, 22, -1, -1, -1, -1, - -1, -1, 29, -1, -1, -1, 33, 34, -1, 36, - -1, -1, -1, 40, -1, 42, 43, 44, -1, -1, - 47, -1, -1, -1, 51, -1, 53, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 67, 68, 69, 70, -1, 72, -1, 74, -1, 76, - 77, 78, -1, -1, -1, -1, 83, 84, 85, 86, - 87, -1, -1, 90, -1, -1, -1, -1, -1, 96, - 97, 98, -1, 100, -1, 102, 103, 104, -1, -1, - -1, -1, -1, 110, 111, 112, 113, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 124, -1, 11, - 12, 13, -1, -1, -1, -1, -1, -1, -1, -1, - 22, -1, -1, -1, -1, -1, -1, 29, 30, -1, - -1, 33, 34, -1, 36, -1, -1, -1, 40, -1, - 42, 43, 44, -1, -1, 47, -1, -1, -1, 51, - -1, 53, -1, -1, -1, -1, -1, -1, -1, 61, - -1, -1, -1, -1, -1, 67, 68, 69, 70, 71, - 72, -1, 74, 75, 76, -1, 78, -1, 80, -1, - -1, 83, 84, 85, -1, -1, -1, -1, 90, -1, - -1, -1, -1, -1, 96, 97, 98, -1, 100, -1, - 102, 103, 104, -1, -1, -1, -1, -1, 110, 111, - 112, 113, -1, -1, -1, -1, -1, -1, -1, 121, - 122, -1, 124, -1, 11, 12, 13, -1, -1, -1, - -1, -1, -1, -1, -1, 22, -1, -1, -1, -1, - -1, -1, 29, 30, -1, -1, 33, 34, -1, 36, - -1, -1, -1, 40, -1, 42, 43, 44, -1, -1, - 47, -1, -1, -1, 51, -1, 53, -1, -1, -1, - -1, -1, -1, -1, 61, -1, -1, -1, -1, -1, - 67, 68, 69, 70, 71, 72, -1, 74, 75, 76, - -1, 78, -1, 80, -1, -1, 83, 84, 85, -1, - -1, -1, -1, 90, -1, -1, -1, -1, -1, 96, - 97, 98, -1, 100, -1, 102, 103, 104, -1, -1, - -1, -1, -1, 110, 111, 112, 113, -1, -1, -1, - -1, -1, -1, -1, 121, 122, -1, 124, -1, 4, - 5, 6, -1, -1, 9, 10, 11, -1, -1, 14, - -1, 16, -1, -1, -1, 20, 21, 22, -1, -1, - -1, -1, -1, -1, 29, 30, 31, 32, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 43, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 59, -1, -1, -1, -1, -1, - -1, -1, -1, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, 80, -1, -1, 83, 84, - 85, 86, 87, 88, 89, -1, -1, -1, -1, 94, - -1, -1, 97, 98, 99, 100, 101, 102, -1, -1, - -1, -1, -1, 108, -1, 110, 111, 112, 113, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 124, - -1, 4, 5, 6, -1, -1, 9, 10, 11, -1, - -1, 14, -1, 16, -1, -1, -1, 20, 21, 22, - -1, -1, -1, -1, -1, -1, 29, 30, 31, 32, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 43, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 55, -1, -1, -1, 59, -1, -1, -1, - -1, -1, -1, -1, -1, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, 80, -1, -1, - 83, 84, 85, 86, 87, 88, 89, -1, -1, -1, - -1, 94, -1, -1, 97, 98, 99, 100, 101, 102, - -1, -1, -1, -1, -1, 108, -1, 110, 111, 112, - 113, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 124, -1, 4, 5, 6, -1, -1, 9, 10, + -1, -1, 69, 70, 71, 72, 73, 74, -1, 76, + 77, 78, -1, 80, -1, 82, -1, -1, 85, 86, + 87, -1, -1, -1, -1, 92, -1, -1, -1, -1, + -1, 98, 99, 100, -1, 102, -1, 104, 105, 106, + 107, -1, -1, -1, -1, -1, 113, 114, 115, 116, + -1, -1, -1, -1, -1, -1, -1, 124, 125, -1, + 127, -1, -1, 4, 5, 6, -1, -1, 9, 10, 11, -1, -1, 14, -1, 16, -1, -1, -1, 20, - 21, 22, -1, -1, -1, -1, -1, -1, 29, 30, - 31, 32, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 43, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 55, -1, -1, -1, 59, -1, - -1, -1, -1, -1, -1, -1, -1, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, 80, - -1, -1, 83, 84, 85, 86, 87, 88, 89, -1, - -1, -1, -1, 94, -1, -1, 97, 98, 99, 100, - 101, 102, -1, -1, -1, -1, -1, 108, -1, 110, - 111, 112, 113, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 124, -1, 4, 5, 6, -1, -1, + 21, -1, 23, -1, -1, -1, -1, -1, -1, 30, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 44, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 61, -1, -1, -1, -1, -1, -1, -1, -1, 70, + 71, 72, 73, 74, 75, -1, 77, 78, 79, 80, + 81, 82, -1, -1, 85, 86, 87, 88, 89, 90, + 91, -1, -1, -1, -1, 96, -1, -1, 99, 100, + 101, 102, 103, 104, 105, -1, -1, -1, -1, -1, + 111, -1, 113, 114, 115, 116, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 127, -1, -1, 4, + 5, 6, -1, -1, 9, 10, 11, -1, -1, 14, + -1, 16, -1, -1, -1, 20, 21, -1, 23, -1, + -1, -1, -1, -1, -1, 30, 31, 32, 33, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 57, -1, -1, -1, 61, -1, -1, -1, + -1, -1, -1, -1, -1, 70, 71, 72, 73, 74, + 75, -1, 77, 78, 79, 80, 81, 82, -1, -1, + 85, 86, 87, 88, 89, 90, 91, -1, -1, -1, + -1, 96, -1, -1, 99, 100, 101, 102, 103, 104, + 105, -1, -1, -1, -1, -1, 111, -1, 113, 114, + 115, 116, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 127, -1, -1, 4, 5, 6, -1, -1, 9, 10, 11, -1, -1, 14, -1, 16, -1, -1, - -1, 20, 21, 22, -1, -1, -1, -1, -1, -1, - 29, 30, 31, 32, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 43, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 55, -1, -1, -1, - 59, -1, -1, -1, -1, -1, -1, -1, -1, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, 80, -1, -1, 83, 84, 85, 86, 87, 88, - 89, -1, -1, -1, -1, 94, -1, -1, 97, 98, - 99, 100, 101, 102, -1, -1, -1, -1, -1, 108, - -1, 110, 111, 112, 113, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 124, -1, 4, 5, 6, - -1, -1, 9, 10, 11, -1, -1, 14, -1, 16, - -1, -1, -1, 20, 21, 22, -1, -1, -1, -1, - -1, -1, 29, 30, 31, 32, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 43, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 55, -1, - -1, -1, 59, -1, -1, -1, -1, -1, -1, -1, - -1, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, 80, -1, -1, 83, 84, 85, 86, - 87, 88, 89, -1, -1, -1, -1, 94, -1, -1, - 97, 98, 99, 100, 101, 102, -1, -1, -1, -1, - -1, 108, -1, 110, 111, 112, 113, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 124, -1, 4, - 5, 6, -1, -1, 9, 10, 11, -1, -1, 14, - -1, 16, -1, -1, -1, 20, 21, 22, -1, -1, - -1, -1, -1, -1, 29, 30, 31, 32, -1, 34, - -1, -1, -1, -1, -1, -1, -1, -1, 43, -1, - -1, -1, 47, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 59, -1, -1, -1, -1, -1, - -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, 80, -1, -1, 83, 84, - 85, 86, 87, 88, 89, -1, -1, -1, -1, 94, - -1, -1, 97, 98, 99, 100, 101, 102, -1, -1, - -1, -1, -1, 108, -1, 110, 111, 112, 113, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 124, + -1, 20, 21, -1, 23, -1, -1, -1, -1, -1, + -1, 30, 31, 32, 33, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 44, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 57, -1, + -1, -1, 61, -1, -1, -1, -1, -1, -1, -1, + -1, 70, 71, 72, 73, 74, 75, -1, 77, 78, + 79, 80, 81, 82, -1, -1, 85, 86, 87, 88, + 89, 90, 91, -1, -1, -1, -1, 96, -1, -1, + 99, 100, 101, 102, 103, 104, 105, -1, -1, -1, + -1, -1, 111, -1, 113, 114, 115, 116, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 127, -1, -1, 4, 5, 6, -1, -1, 9, 10, 11, -1, - -1, 14, -1, 16, -1, -1, -1, 20, 21, 22, - -1, -1, -1, -1, -1, -1, 29, 30, 31, 32, - -1, 34, -1, -1, -1, -1, -1, -1, -1, -1, - 43, -1, -1, -1, 47, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 59, -1, -1, -1, - 63, -1, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, 80, -1, -1, - 83, 84, 85, 86, 87, 88, 89, -1, -1, -1, - -1, 94, -1, -1, 97, 98, 99, 100, 101, 102, - -1, -1, -1, -1, -1, 108, -1, 110, 111, 112, - 113, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 124, -1, 4, 5, 6, -1, -1, 9, 10, - 11, -1, -1, 14, -1, 16, -1, -1, -1, 20, - 21, 22, -1, -1, -1, -1, -1, -1, 29, 30, - 31, 32, -1, 34, -1, -1, -1, -1, -1, -1, - -1, -1, 43, -1, -1, -1, 47, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 59, -1, - 61, -1, 63, -1, -1, -1, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, 80, - -1, -1, 83, 84, 85, 86, 87, 88, 89, -1, - -1, -1, -1, 94, -1, -1, 97, 98, 99, 100, - 101, 102, -1, -1, -1, -1, -1, 108, -1, 110, - 111, 112, 113, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 124, -1, 4, -1, -1, -1, -1, - 9, -1, 11, 12, 13, 14, -1, -1, -1, -1, - -1, -1, 21, 22, -1, -1, -1, -1, -1, -1, - 29, 30, -1, -1, 33, 34, -1, 36, -1, -1, - -1, 40, -1, 42, 43, 44, -1, -1, 47, -1, - -1, -1, 51, -1, 53, -1, -1, -1, -1, -1, - 59, -1, 61, -1, -1, -1, -1, -1, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, -1, -1, 83, 84, 85, -1, -1, 88, - -1, 90, -1, -1, -1, -1, -1, 96, 97, 98, - -1, 100, -1, 102, 103, 104, -1, -1, -1, -1, - -1, 110, 111, 112, 113, -1, -1, -1, -1, -1, - -1, -1, -1, 122, -1, 124, -1, 4, 5, 6, + -1, 14, -1, 16, -1, -1, -1, 20, 21, -1, + 23, -1, -1, -1, -1, -1, -1, 30, 31, 32, + 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 44, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 57, -1, -1, -1, 61, -1, + -1, -1, -1, -1, -1, -1, -1, 70, 71, 72, + 73, 74, 75, -1, 77, 78, 79, 80, 81, 82, + -1, -1, 85, 86, 87, 88, 89, 90, 91, -1, + -1, -1, -1, 96, -1, -1, 99, 100, 101, 102, + 103, 104, 105, -1, -1, -1, -1, -1, 111, -1, + 113, 114, 115, 116, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 127, -1, -1, 4, 5, 6, -1, -1, 9, 10, 11, -1, -1, 14, -1, 16, - -1, -1, -1, 20, 21, 22, -1, -1, -1, -1, - -1, -1, 29, 30, 31, 32, -1, 34, -1, -1, - -1, -1, -1, -1, -1, -1, 43, -1, -1, -1, - 47, -1, -1, -1, -1, -1, -1, -1, 55, -1, - -1, -1, 59, -1, -1, -1, 63, -1, -1, -1, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, 80, -1, -1, 83, 84, 85, 86, - 87, 88, 89, -1, -1, -1, -1, 94, -1, -1, - 97, 98, 99, 100, 101, 102, -1, -1, -1, -1, - -1, 108, -1, 110, 111, 112, 113, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 124, -1, 4, + -1, -1, -1, 20, 21, -1, 23, -1, -1, -1, + -1, -1, -1, 30, 31, 32, 33, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 44, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 57, -1, -1, -1, 61, -1, -1, -1, -1, -1, + -1, -1, -1, 70, 71, 72, 73, 74, 75, -1, + 77, 78, 79, 80, 81, 82, -1, -1, 85, 86, + 87, 88, 89, 90, 91, -1, -1, -1, -1, 96, + -1, -1, 99, 100, 101, 102, 103, 104, 105, -1, + -1, -1, -1, -1, 111, -1, 113, 114, 115, 116, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 127, -1, -1, 4, 5, 6, -1, -1, 9, 10, + 11, -1, -1, 14, -1, 16, -1, -1, -1, 20, + 21, -1, 23, -1, -1, -1, -1, -1, -1, 30, + 31, 32, 33, -1, 35, -1, -1, -1, -1, -1, + -1, -1, -1, 44, -1, -1, -1, 48, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 61, -1, -1, -1, -1, -1, -1, -1, 69, 70, + 71, 72, 73, 74, 75, -1, 77, 78, 79, 80, + 81, 82, -1, -1, 85, 86, 87, 88, 89, 90, + 91, -1, -1, -1, -1, 96, -1, -1, 99, 100, + 101, 102, 103, 104, 105, -1, -1, -1, -1, -1, + 111, -1, 113, 114, 115, 116, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 127, -1, -1, 4, 5, 6, -1, -1, 9, 10, 11, -1, -1, 14, - -1, 16, -1, -1, -1, 20, 21, 22, -1, -1, - -1, -1, -1, -1, 29, 30, 31, 32, -1, 34, - -1, -1, -1, -1, -1, -1, -1, -1, 43, -1, - -1, -1, 47, -1, -1, -1, -1, -1, -1, -1, - 55, -1, -1, -1, 59, -1, -1, -1, 63, -1, - -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, 80, -1, -1, 83, 84, - 85, 86, 87, 88, 89, -1, -1, -1, -1, 94, - -1, -1, 97, 98, 99, 100, 101, 102, -1, -1, - -1, -1, -1, 108, -1, 110, 111, 112, 113, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 124, + -1, 16, -1, -1, -1, 20, 21, -1, 23, -1, + -1, -1, -1, -1, -1, 30, 31, 32, 33, -1, + 35, -1, -1, -1, -1, -1, -1, -1, -1, 44, + -1, -1, -1, 48, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 61, -1, -1, -1, + 65, -1, -1, -1, 69, 70, 71, 72, 73, 74, + 75, -1, 77, 78, 79, 80, 81, 82, -1, -1, + 85, 86, 87, 88, 89, 90, 91, -1, -1, -1, + -1, 96, -1, -1, 99, 100, 101, 102, 103, 104, + 105, -1, -1, -1, -1, -1, 111, -1, 113, 114, + 115, 116, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 127, -1, -1, 4, 5, 6, -1, -1, + 9, 10, 11, -1, -1, 14, -1, 16, -1, -1, + -1, 20, 21, -1, 23, -1, -1, -1, -1, -1, + -1, 30, 31, 32, 33, -1, 35, -1, -1, -1, + -1, -1, -1, -1, -1, 44, -1, -1, -1, 48, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 61, -1, 63, -1, 65, -1, -1, -1, + 69, 70, 71, 72, 73, 74, 75, -1, 77, 78, + 79, 80, 81, 82, -1, -1, 85, 86, 87, 88, + 89, 90, 91, -1, -1, -1, -1, 96, -1, -1, + 99, 100, 101, 102, 103, 104, 105, -1, -1, -1, + -1, -1, 111, -1, 113, 114, 115, 116, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 127, -1, + -1, 4, 5, 6, -1, -1, 9, 10, 11, -1, + -1, 14, -1, 16, -1, -1, -1, 20, 21, -1, + 23, -1, -1, -1, -1, -1, -1, 30, 31, 32, + 33, -1, 35, -1, -1, -1, -1, -1, -1, -1, + -1, 44, -1, -1, -1, 48, -1, -1, -1, -1, + -1, -1, -1, -1, 57, -1, -1, -1, 61, -1, + -1, -1, 65, -1, -1, -1, 69, 70, 71, 72, + 73, 74, 75, -1, 77, 78, 79, 80, 81, 82, + -1, -1, 85, 86, 87, 88, 89, 90, 91, -1, + -1, -1, -1, 96, -1, -1, 99, 100, 101, 102, + 103, 104, 105, -1, -1, -1, -1, -1, 111, -1, + 113, 114, 115, 116, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 127, -1, -1, 4, 5, 6, + -1, -1, 9, 10, 11, -1, -1, 14, -1, 16, + -1, -1, -1, 20, 21, -1, 23, -1, -1, -1, + -1, -1, -1, 30, 31, 32, 33, -1, 35, -1, + -1, -1, -1, -1, -1, -1, -1, 44, -1, -1, + -1, 48, -1, -1, -1, -1, -1, -1, -1, -1, + 57, -1, -1, -1, 61, -1, -1, -1, 65, -1, + -1, -1, 69, 70, 71, 72, 73, 74, 75, -1, + 77, 78, 79, 80, 81, 82, -1, -1, 85, 86, + 87, 88, 89, 90, 91, -1, -1, -1, -1, 96, + -1, -1, 99, 100, 101, 102, 103, 104, 105, -1, + -1, -1, -1, -1, 111, -1, 113, 114, 115, 116, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 127, -1, -1, 4, -1, -1, -1, -1, 9, -1, + 11, 12, 13, 14, -1, -1, -1, -1, -1, -1, + 21, 22, 23, -1, -1, -1, -1, -1, -1, 30, + 31, -1, -1, 34, 35, -1, 37, -1, -1, -1, + 41, -1, 43, 44, 45, -1, -1, 48, -1, -1, + -1, -1, 53, -1, 55, -1, -1, -1, -1, -1, + 61, -1, 63, -1, -1, -1, -1, -1, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, -1, -1, 85, 86, 87, -1, -1, 90, + -1, 92, -1, -1, -1, -1, -1, 98, 99, 100, + -1, 102, -1, 104, 105, 106, 107, -1, -1, -1, + -1, -1, 113, 114, 115, 116, -1, -1, -1, -1, + -1, -1, -1, -1, 125, -1, 127, -1, -1, 4, + -1, -1, -1, -1, 9, -1, 11, 12, 13, 14, + -1, -1, -1, -1, -1, -1, 21, 22, 23, -1, + -1, -1, -1, -1, -1, 30, 31, -1, -1, 34, + 35, -1, 37, -1, -1, -1, 41, -1, 43, 44, + 45, -1, -1, 48, -1, -1, -1, -1, 53, -1, + 55, -1, -1, -1, -1, -1, 61, -1, 63, -1, + -1, -1, -1, -1, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, -1, -1, + 85, 86, 87, -1, -1, 90, -1, 92, -1, -1, + -1, -1, -1, 98, 99, 100, -1, 102, -1, 104, + 105, 106, 107, -1, -1, -1, -1, -1, 113, 114, + 115, 116, -1, -1, -1, -1, -1, -1, -1, 124, + 125, -1, 127, -1, -1, 4, -1, -1, -1, -1, + 9, -1, 11, 12, 13, 14, -1, -1, -1, -1, + -1, -1, 21, 22, 23, -1, -1, -1, -1, -1, + -1, 30, 31, -1, -1, 34, 35, -1, 37, -1, + -1, -1, 41, -1, 43, 44, 45, -1, -1, 48, + -1, -1, -1, -1, 53, -1, 55, -1, -1, -1, + -1, -1, 61, -1, 63, -1, -1, -1, -1, -1, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, -1, -1, 85, 86, 87, -1, + -1, 90, -1, 92, -1, -1, -1, -1, -1, 98, + 99, 100, -1, 102, -1, 104, 105, 106, 107, -1, + -1, -1, -1, -1, 113, 114, 115, 116, -1, -1, + -1, -1, -1, -1, -1, 124, 125, -1, 127, -1, -1, 4, -1, -1, -1, -1, 9, -1, 11, 12, 13, 14, -1, -1, -1, -1, -1, -1, 21, 22, - -1, -1, -1, -1, -1, -1, 29, 30, -1, -1, - 33, 34, -1, 36, -1, -1, -1, 40, -1, 42, - 43, 44, -1, -1, 47, -1, -1, -1, 51, -1, - 53, -1, -1, -1, -1, -1, 59, -1, 61, -1, - -1, -1, -1, -1, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, -1, -1, - 83, 84, 85, -1, -1, 88, -1, 90, -1, -1, - -1, -1, -1, 96, 97, 98, -1, 100, -1, 102, - 103, 104, -1, -1, -1, -1, -1, 110, 111, 112, - 113, -1, -1, -1, -1, -1, -1, -1, 121, 122, - -1, 124, -1, 4, -1, -1, -1, -1, 9, -1, - 11, 12, 13, 14, -1, -1, -1, -1, -1, -1, - 21, 22, -1, -1, -1, -1, -1, -1, 29, 30, - -1, -1, 33, 34, -1, 36, -1, -1, -1, 40, - -1, 42, 43, 44, -1, -1, 47, -1, -1, -1, - 51, -1, 53, -1, -1, -1, -1, -1, 59, -1, - 61, -1, -1, -1, -1, -1, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - -1, -1, 83, 84, 85, -1, -1, 88, -1, 90, - -1, -1, -1, -1, -1, 96, 97, 98, -1, 100, - -1, 102, 103, 104, -1, -1, -1, -1, -1, 110, - 111, 112, 113, -1, -1, -1, -1, -1, -1, -1, - 121, 122, -1, 124, -1, 4, -1, -1, -1, -1, - 9, -1, 11, 12, 13, 14, -1, -1, -1, -1, - -1, -1, 21, 22, -1, -1, -1, -1, -1, -1, - 29, 30, -1, -1, 33, 34, -1, 36, -1, -1, - -1, 40, -1, 42, 43, 44, -1, -1, 47, -1, - -1, -1, 51, -1, 53, -1, -1, -1, -1, -1, - 59, -1, 61, -1, -1, -1, -1, -1, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, -1, -1, 83, 84, 85, -1, -1, 88, - -1, 90, -1, -1, -1, -1, -1, 96, 97, 98, - -1, 100, -1, 102, 103, 104, -1, -1, -1, -1, - -1, 110, 111, 112, 113, -1, -1, -1, -1, -1, - -1, -1, 121, 122, -1, 124, -1, + 23, -1, -1, -1, -1, -1, -1, 30, 31, -1, + -1, 34, 35, -1, 37, -1, -1, -1, 41, -1, + 43, 44, 45, -1, -1, 48, -1, -1, -1, -1, + 53, -1, 55, -1, -1, -1, -1, -1, 61, -1, + 63, -1, -1, -1, -1, -1, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + -1, -1, 85, 86, 87, -1, -1, 90, -1, 92, + -1, -1, -1, -1, -1, 98, 99, 100, -1, 102, + -1, 104, 105, 106, 107, -1, -1, -1, -1, -1, + 113, 114, 115, 116, -1, -1, -1, -1, -1, -1, + -1, 124, 125, -1, 127, -1, -1, - 58, 181, 180, 35, 18, 182, 35, 22, 187, 14, - 185, 22, 18, 35, 22, 18, 201, 200, 28, 58, - 18, 22, 18, 35, 18, 41, 200, 172, 35, 172, - 174, 173, 18, 63, 29, 35, 18, 24, 135, 135, - 162, 182, 165, 168, 53, 58, 181, 174, 172, 53, - 41, 53, 173, 172, 174, 173, 76, 29, 95, 58, - 98, 41, 179, 172, 172, 58, 58, 173, 53, 66, - 174, 29, 53, 172, 53, 53, 174, 53, 173, 159, - 41, 58, 56, 58, 174, 58, 76, 58, 58, 58, - 173, 172, 76, 76, 41, 38, 184, 172, 29, 66, - 135, 41, 66, 53, 172, 174, 184, 173, 76, 74, - 76, 74, 74, 185, 185, 75, 172, 181, 66, 53, - 187, 182, 187, 41, 172, 172, 115, 173, 181, 173, - 182, 174, 51, 53, 58, 58, 58, 58, 77, 53, - 41, 58, 98, 95, 180, 56, 53, 24, 58, 58, - 41, 42, 24, 2, 53, 51, 53, 41, 42, 53, - 53, 2, 41, 2, 2, 41, 42, 53, 53, 58, - 2, 60, 24, 56, 24, 24, 58, 27, 58, 59, - 2, 2, 41, 24, 58, 24, 24, 41, 42, 58, - 41, 24, 24, 72, 41, 41, 41, 2, 24, 81, - 2, 27, 24, 24, 2, 41, 2, 81, 24, 38, - 41, 42, 81, 41, 24, 203, 204, 27, 117, 24, - 117, 72, 24, 117, 117, 72, 24, 72, 24, 41, - 42, 117, 117, 41, 42, 41, 72, 41, 42, -1, - 41, 41, 41, 24, 41, 85, 41, 42, 11, 12, - 53, 54, 92, 41, 41, 42, 41, 42, 41, 42, - 137, 41, 68, 135, 41, 42, 41, 42, 69, 68, - 3, 68, 41, 42, 157, 41, 42, 41, 42, 61, - 68, 69, -1, 68, 136, 41, 42, 41, 42, 41, - 42, 41, 72, 41, 42, 41, 42, 41, 42, 41, - 42, -1, 52, 85, 137, 54, 55, 41, 42, 58, - 92, 41, 42, 41, 42, -1, 72, 2, 41, 42, - 3, 137, 41, 42, 41, 42, 38, 186, 41, 42, - 41, 42, 41, 42, -1, 85, 41, 42, 178, 24, - 186, 170, 41, 42, 16, 41, 42, 41, -1, 41, - 41, 61, 85, 41, 42, -1, 137, -1, 52, 92, - 52, 52, -1, 191, 151, -1, 54, -1, 61, 41, - 41, 41, 42, 72, 151, 85, 151, 61, 41, -1, - 52, 52, 92, 41, 42, -1, 186, -1, 171, 52, - -1, 85, 85, 85, 85, 89, 178, 151, 89, 92, - 92, 85, 85, 38, 39, -1, 78, 171, 92, 92, - 68, -1, 158, -1, 85, 196, 128, 41, 130, 171, - 61, 92, 85, 151, -1, 88, -1, 175, 52, 171, - -1, 211, 41, -1, 41, 42, 205, 171, 61, 205, - 184, 171, 151, 52, 85, 178, 151, 54, 61, 41, - 42, 92, 171, 149, -1, 151, -1, 180, 170, 61, - 171, 85, 85, 41, -1, 61, -1, 180, 178, 92, - 158, 41, 85, 41, 52, 41, 85, 147, 41, 92, - 104, 151, 52, 85, 52, 178, 52, -1, 205, 85, - 92, 126, 41, -1, 178, 178, 92, 106, 156, 41, - 41, 64, 16, 52, -1, 68, 69, 85, 207, 41, - 52, 52, 41, 42, -1, 85, -1, 85, 96, 85, - 52, 91, 16, -1, -1, 93, 92, 41, 41, -1, - -1, -1, -1, -1, 41, 170, 85, 178, 52, 52, - -1, 41, 91, 85, 85, 52, 41, 41, -1, 91, - -1, 158, 52, 85, -1, 178, 148, 52, 52, 151, - 41, 102, 41, -1, 78, 178, -1, -1, 100, -1, - 41, 52, 85, 52, -1, 88, 178, -1, 85, 86, - 87, 52, 178, 41, 78, 85, 86, 87, 82, -1, - 85, 86, 87, -1, 52, -1, 41, 42, -1, 16, - 16, 41, 19, 19, 85, -1, 85, 86, 87, 54, - 55, 92, 52, 3, 85, 86, 87, -1, 147, 41, - 101, -1, 151, -1, 41, 41, -1, 85, -1, 41, - 52, 41, 41, -1, 92, 52, 52, -1, -1, 97, - 52, 16, 52, 52, -1, 85, 86, 87, 23, 16, - -1, -1, 19, 16, 21, -1, 19, -1, -1, -1, - 41, 78, 78, 85, -1, -1, 41, -1, -1, -1, - 92, 52, 94, 85, 16, 85, 85, 52, 41, 41, - 92, 23, 92, 92, -1, -1, -1, 99, -1, 52, - 52, 58, 59, 103, -1, 85, 105, 39, -1, 41, - 41, -1, 92, 78, 85, 86, 87, -1, -1, -1, - 52, 52, -1, 158, -1, 78, 4, -1, -1, 4, - -1, -1, -1, 85, 86, 87, -1, -1, 16, -1, - -1, 16, -1, -1, -1, 23, 78, -1, 23, -1, - -1, -1, -1, 16, 85, 86, 87, -1, 138, 139, - 23, 39, -1, 41, 39, 28, 41, 30, 31, 32, - 33, 34, 16, -1, 52, -1, -1, 52, -1, 23, - -1, -1, -1, -1, 28, -1, 30, 31, 32, 33, - 34, -1, 16, -1, -1, -1, -1, -1, 178, 23, - 78, -1, -1, 78, 28, -1, 30, 31, 32, 33, - 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 15, 26, 15, 15, 186, 185, 20, 37, 15, 64, + 187, 71, 15, 185, 20, 41, 15, 37, 20, 37, + 55, 37, 20, 185, 20, 30, 15, 31, 15, 185, + 187, 55, 186, 14, 194, 15, 195, 15, 199, 24, + 26, 15, 24, 201, 214, 20, 15, 24, 20, 20, + 20, 15, 15, 64, 76, 20, 50, 192, 26, 214, + 175, 37, 215, 71, 37, 66, 15, 64, 178, 15, + 37, 37, 148, 66, 69, 66, 195, 194, 66, 71, + 185, 185, 193, 31, 15, 172, 187, 71, 31, 79, + 31, 181, 15, 55, 55, 148, 187, 185, 198, 193, + 50, 15, 55, 50, 87, 64, 66, 148, 66, 143, + 89, 55, 187, 55, 71, 186, 71, 185, 55, 185, + 187, 186, 186, 55, 186, 79, 71, 55, 66, 55, + 55, 185, 88, 185, 195, 87, 87, 194, 187, 79, + 187, 186, 193, 186, 71, 55, 186, 71, 187, 71, + 89, 55, 185, 89, 89, 71, 90, 64, 71, 71, + 55, 64, 71, 69, 66, 64, 185, 195, 79, 15, + 15, 194, 66, 71, 71, 185, 66, 15, 111, 108, + 71, 15, 50, 66, 46, 66, 186, 108, 89, 50, + 199, 111, 71, 89, 66, 50, 71, 64, 128, 26, + 66, 66, 2, 50, 51, 69, 50, 50, 51, 2, + 66, 50, 15, 66, 2, 50, 2, 50, 15, 15, + 50, 71, 26, -1, 50, 29, 26, 26, 50, 50, + 20, 11, 12, 26, 71, 71, 50, 51, 26, 2, + 26, 85, 66, 67, 94, 50, 85, 37, 71, 72, + 26, 26, 85, 50, 50, 85, 66, 94, 94, 50, + 51, 50, 51, 26, 130, 130, 50, 51, 2, 71, + 2, 73, 50, 51, 130, 2, 50, 130, 50, 198, + 85, 50, 199, 201, 50, 51, 201, 20, 50, 51, + 2, 50, 26, 66, 26, 50, 51, 50, 51, 26, + 2, 26, 2, -1, 37, 50, 170, 26, 82, 81, + 50, 51, 81, 50, 26, 50, 51, 217, 218, -1, + 130, 148, 81, 46, 26, 48, 26, 98, 50, 51, + 50, 51, 50, 51, 105, -1, 81, 82, -1, 50, + 51, 81, 50, 51, 50, 51, 50, 51, 85, 50, + 51, 150, 50, 51, 50, 51, 3, 130, 50, 51, + 50, 51, -1, 50, 51, 200, 50, 50, 51, 50, + 51, 50, 51, 149, 200, 150, 50, 51, 200, 50, + 51, 65, 40, 41, 205, 43, 50, 85, 50, 51, + 50, 51, 67, 68, 50, 51, 71, 50, 51, 50, + 51, 65, 50, 51, 50, 3, 50, -1, 74, 74, + 50, 51, 17, 50, 98, -1, 139, -1, -1, 65, + 191, 65, 74, -1, 2, 150, 50, 51, 65, 164, + -1, 150, 98, 98, 98, 50, -1, 85, 102, 105, + 105, 50, 164, 67, -1, 50, 98, -1, 26, 50, + 51, 98, 98, 105, 98, -1, 65, 101, 105, 105, + 65, 98, 77, 164, 184, 102, 81, 82, 164, 50, + 51, 74, -1, 184, 74, 50, 184, 164, 184, -1, + 184, 164, 50, -1, 50, 51, 91, 17, 225, 98, + 65, 210, 101, -1, -1, 98, -1, 65, 98, -1, + 98, 219, 105, 184, 164, 105, -1, 105, 198, -1, + 184, -1, 74, 184, 193, 81, 50, 51, 171, 50, + 50, 74, 162, 98, 164, 191, 191, 219, 184, 74, + 98, 74, -1, 67, 65, 65, 98, 188, 46, 191, + 50, 51, 117, 105, 191, 98, -1, 171, -1, 50, + 50, 119, 105, 98, -1, 98, -1, 219, -1, 160, + 105, 91, 105, 164, 65, 65, 40, 98, -1, 43, + 44, 45, 50, 221, 50, 50, -1, 50, -1, 50, + 161, -1, 113, 164, 50, 51, -1, 65, 191, 65, + 65, 191, 65, 191, 65, 50, -1, 98, 98, -1, + -1, 67, 68, 169, -1, -1, 106, 17, 17, 50, + 65, -1, 21, -1, 115, -1, -1, 50, -1, -1, + 98, 50, 98, 98, 65, 98, 104, 98, 104, 191, + 105, 104, 65, 141, 105, 143, 65, 171, 191, -1, + 50, 50, -1, 98, 99, 100, 191, -1, 191, 50, + 160, -1, -1, 50, 164, 65, 65, 98, 99, 100, + -1, 50, 3, -1, 65, 98, 99, 100, 65, 98, + 99, 100, 50, -1, -1, 183, 65, 50, -1, -1, + 17, 91, 91, 50, 50, 95, 17, 65, 25, 197, + 21, -1, 65, -1, -1, -1, 17, 98, 65, 65, + 21, 98, 99, 100, -1, 171, -1, 17, 109, 98, + 99, 100, -1, 50, -1, 25, -1, -1, 50, 50, + 98, 99, 100, -1, -1, 98, 99, 100, 65, 50, + 50, 98, 98, 65, 65, 50, 50, -1, 105, 105, + 50, 107, 17, 110, 65, 65, 21, -1, 23, -1, + 65, 65, -1, -1, 91, 65, -1, 98, -1, -1, + 91, -1, -1, -1, 105, -1, 98, -1, -1, 17, + 91, -1, -1, 105, -1, -1, -1, 25, 98, 17, + -1, 91, 114, 98, 98, 105, 4, 25, -1, -1, + 105, 105, 112, -1, -1, -1, 71, 72, 17, 17, + -1, 116, 50, -1, 118, 53, 25, 25, -1, -1, + 151, 152, 50, -1, -1, 53, -1, 65, -1, -1, + 17, 4, -1, -1, -1, -1, 50, 65, 25, 48, + 48, 50, 50, 30, 17, 32, 33, 34, 35, 36, + -1, 65, 25, 91, 17, -1, 65, 65, -1, -1, + 191, -1, 25, 91, -1, -1, -1, 30, -1, 32, + 33, 34, 35, 36, -1, 48, -1, 50, -1, -1, + 17, -1, 91, 91, 98, 99, 100, -1, 25, -1, + -1, -1, 65, 30, -1, 32, 33, 34, 35, 36, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 183, 183, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 28, -1, 30, 31, 32, 33, 34, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 183, -1, -1, 30, -1, 32, 33, 34, 35, 36, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, @@ -2063,7 +2120,8 @@ const short QmlJSGrammar::action_check [] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1 + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; QT_END_NAMESPACE diff --git a/src/libs/qmljs/parser/qmljsgrammar_p.h b/src/libs/qmljs/parser/qmljsgrammar_p.h index 6d1b971dca3..e3d69b36034 100644 --- a/src/libs/qmljs/parser/qmljsgrammar_p.h +++ b/src/libs/qmljs/parser/qmljsgrammar_p.h @@ -50,152 +50,150 @@ class QML_PARSER_EXPORT QmlJSGrammar public: enum VariousConstants { EOF_SYMBOL = 0, - REDUCE_HERE = 125, + REDUCE_HERE = 128, T_AND = 1, T_AND_AND = 2, T_AND_EQ = 3, - T_ARROW = 93, - T_AS = 110, - T_AUTOMATIC_SEMICOLON = 62, + T_ARROW = 95, + T_AS = 113, + T_AUTOMATIC_SEMICOLON = 64, T_BREAK = 4, T_CASE = 5, T_CATCH = 6, - T_CLASS = 98, + T_CLASS = 100, T_COLON = 7, T_COMMA = 8, - T_COMMENT = 91, - T_COMPATIBILITY_SEMICOLON = 92, - T_CONST = 86, + T_COMMENT = 93, + T_COMPATIBILITY_SEMICOLON = 94, + T_CONST = 88, T_CONTINUE = 9, - T_DEBUGGER = 88, + T_DEBUGGER = 90, T_DEFAULT = 10, T_DELETE = 11, T_DIVIDE_ = 12, T_DIVIDE_EQ = 13, T_DO = 14, T_DOT = 15, - T_ELLIPSIS = 95, + T_ELLIPSIS = 97, T_ELSE = 16, - T_ENUM = 94, + T_ENUM = 96, T_EQ = 17, T_EQ_EQ = 18, T_EQ_EQ_EQ = 19, - T_ERROR = 114, - T_EXPORT = 101, - T_EXTENDS = 99, - T_FALSE = 85, - T_FEED_JS_EXPRESSION = 118, - T_FEED_JS_MODULE = 120, - T_FEED_JS_SCRIPT = 119, - T_FEED_JS_STATEMENT = 117, - T_FEED_UI_OBJECT_MEMBER = 116, - T_FEED_UI_PROGRAM = 115, + T_ERROR = 117, + T_EXPORT = 103, + T_EXTENDS = 101, + T_FALSE = 87, + T_FEED_JS_EXPRESSION = 121, + T_FEED_JS_MODULE = 123, + T_FEED_JS_SCRIPT = 122, + T_FEED_JS_STATEMENT = 120, + T_FEED_UI_OBJECT_MEMBER = 119, + T_FEED_UI_PROGRAM = 118, T_FINALLY = 20, T_FOR = 21, - T_FORCE_BLOCK = 122, - T_FORCE_DECLARATION = 121, - T_FOR_LOOKAHEAD_OK = 123, - T_FROM = 102, - T_FUNCTION = 22, - T_GE = 23, - T_GET = 112, - T_GT = 24, - T_GT_GT = 25, - T_GT_GT_EQ = 26, - T_GT_GT_GT = 27, - T_GT_GT_GT_EQ = 28, - T_IDENTIFIER = 29, - T_IF = 30, - T_IMPORT = 108, - T_IN = 31, - T_INSTANCEOF = 32, - T_LBRACE = 33, - T_LBRACKET = 34, - T_LE = 35, - T_LET = 87, - T_LPAREN = 36, - T_LT = 37, - T_LT_LT = 38, - T_LT_LT_EQ = 39, - T_MINUS = 40, - T_MINUS_EQ = 41, - T_MINUS_MINUS = 42, - T_MULTILINE_STRING_LITERAL = 90, - T_NEW = 43, - T_NOT = 44, - T_NOT_EQ = 45, - T_NOT_EQ_EQ = 46, - T_NO_SUBSTITUTION_TEMPLATE = 103, - T_NULL = 83, - T_NUMERIC_LITERAL = 47, - T_OF = 111, - T_ON = 124, - T_OR = 48, - T_OR_EQ = 49, - T_OR_OR = 50, - T_PLUS = 51, - T_PLUS_EQ = 52, - T_PLUS_PLUS = 53, - T_PRAGMA = 109, - T_PROPERTY = 68, - T_PUBLIC = 107, - T_QUESTION = 54, - T_RBRACE = 55, - T_RBRACKET = 56, - T_READONLY = 70, - T_REMAINDER = 57, - T_REMAINDER_EQ = 58, - T_RESERVED_WORD = 89, - T_RETURN = 59, - T_RPAREN = 60, - T_SEMICOLON = 61, - T_SET = 113, - T_SIGNAL = 69, - T_STAR = 63, - T_STAR_EQ = 66, - T_STAR_STAR = 64, - T_STAR_STAR_EQ = 65, - T_STATIC = 100, - T_STRING_LITERAL = 67, - T_SUPER = 97, - T_SWITCH = 71, - T_TEMPLATE_HEAD = 104, - T_TEMPLATE_MIDDLE = 105, - T_TEMPLATE_TAIL = 106, - T_THIS = 72, - T_THROW = 73, - T_TILDE = 74, - T_TRUE = 84, - T_TRY = 75, - T_TYPEOF = 76, - T_VAR = 77, - T_VOID = 78, - T_WHILE = 79, - T_WITH = 80, - T_XOR = 81, - T_XOR_EQ = 82, - T_YIELD = 96, + T_FORCE_BLOCK = 125, + T_FORCE_DECLARATION = 124, + T_FOR_LOOKAHEAD_OK = 126, + T_FROM = 104, + T_FUNCTION = 23, + T_FUNCTION_STAR = 22, + T_GE = 24, + T_GET = 115, + T_GT = 25, + T_GT_GT = 26, + T_GT_GT_EQ = 27, + T_GT_GT_GT = 28, + T_GT_GT_GT_EQ = 29, + T_IDENTIFIER = 30, + T_IF = 31, + T_IMPORT = 111, + T_IN = 32, + T_INSTANCEOF = 33, + T_LBRACE = 34, + T_LBRACKET = 35, + T_LE = 36, + T_LET = 89, + T_LPAREN = 37, + T_LT = 38, + T_LT_LT = 39, + T_LT_LT_EQ = 40, + T_MINUS = 41, + T_MINUS_EQ = 42, + T_MINUS_MINUS = 43, + T_MULTILINE_STRING_LITERAL = 92, + T_NEW = 44, + T_NOT = 45, + T_NOT_EQ = 46, + T_NOT_EQ_EQ = 47, + T_NO_SUBSTITUTION_TEMPLATE = 106, + T_NULL = 85, + T_NUMERIC_LITERAL = 48, + T_OF = 114, + T_ON = 127, + T_OR = 49, + T_OR_EQ = 51, + T_OR_OR = 52, + T_PLUS = 53, + T_PLUS_EQ = 54, + T_PLUS_PLUS = 55, + T_PRAGMA = 112, + T_PROPERTY = 70, + T_PUBLIC = 110, + T_QUESTION = 56, + T_RBRACE = 57, + T_RBRACKET = 58, + T_READONLY = 72, + T_REMAINDER = 59, + T_REMAINDER_EQ = 60, + T_REQUIRED = 105, + T_RESERVED_WORD = 91, + T_RETURN = 61, + T_RPAREN = 62, + T_SEMICOLON = 63, + T_SET = 116, + T_SIGNAL = 71, + T_STAR = 65, + T_STAR_EQ = 68, + T_STAR_STAR = 66, + T_STAR_STAR_EQ = 67, + T_STATIC = 102, + T_STRING_LITERAL = 69, + T_SUPER = 99, + T_SWITCH = 73, + T_TEMPLATE_HEAD = 107, + T_TEMPLATE_MIDDLE = 108, + T_TEMPLATE_TAIL = 109, + T_THEN = 129, + T_THIS = 74, + T_THROW = 75, + T_TILDE = 76, + T_TRUE = 86, + T_TRY = 77, + T_TYPEOF = 78, + T_VAR = 79, + T_VERSION_NUMBER = 50, + T_VOID = 80, + T_WHILE = 81, + T_WITH = 82, + T_XOR = 83, + T_XOR_EQ = 84, + T_YIELD = 98, - ACCEPT_STATE = 1008, - RULE_COUNT = 586, - STATE_COUNT = 1009, - TERMINAL_COUNT = 126, - NON_TERMINAL_COUNT = 213, + ACCEPT_STATE = 1055, + RULE_COUNT = 591, + STATE_COUNT = 1056, + TERMINAL_COUNT = 130, + NON_TERMINAL_COUNT = 227, - GOTO_INDEX_OFFSET = 1009, - GOTO_INFO_OFFSET = 5937, - GOTO_CHECK_OFFSET = 5937 + GOTO_INDEX_OFFSET = 1056, + GOTO_INFO_OFFSET = 6757, + GOTO_CHECK_OFFSET = 6757 }; static const char *const spell[]; static const short lhs[]; static const short rhs[]; - -#ifndef QLALR_NO_QMLJSGRAMMAR_DEBUG_INFO - static const int rule_index[]; - static const int rule_info[]; -#endif // QLALR_NO_QMLJSGRAMMAR_DEBUG_INFO - static const short goto_default[]; static const short action_default[]; static const short action_index[]; diff --git a/src/libs/qmljs/parser/qmljskeywords_p.h b/src/libs/qmljs/parser/qmljskeywords_p.h index cc03e7599f0..c59cab83257 100644 --- a/src/libs/qmljs/parser/qmljskeywords_p.h +++ b/src/libs/qmljs/parser/qmljskeywords_p.h @@ -728,6 +728,18 @@ static inline int classify8(const QChar *s, int parseModeFlags) { } } } + } else if (s[2].unicode() == 'q') { + if (s[3].unicode() == 'u') { + if (s[4].unicode() == 'i') { + if (s[5].unicode() == 'r') { + if (s[6].unicode() == 'e') { + if (s[7].unicode() == 'd') { + return Lexer::T_REQUIRED; + } + } + } + } + } } } } diff --git a/src/libs/qmljs/parser/qmljslexer.cpp b/src/libs/qmljs/parser/qmljslexer.cpp index ab7a33917e0..2af11acb760 100644 --- a/src/libs/qmljs/parser/qmljslexer.cpp +++ b/src/libs/qmljs/parser/qmljslexer.cpp @@ -31,6 +31,7 @@ #include #include #include +#include QT_BEGIN_NAMESPACE Q_CORE_EXPORT double qstrtod(const char *s00, char const **se, bool *ok); @@ -255,16 +256,29 @@ int Lexer::lex() ++_bracesCount; Q_FALLTHROUGH(); case T_SEMICOLON: + _importState = ImportState::NoQmlImport; + Q_FALLTHROUGH(); case T_QUESTION: case T_COLON: case T_TILDE: _delimited = true; break; + case T_AUTOMATIC_SEMICOLON: + case T_AS: + _importState = ImportState::NoQmlImport; + Q_FALLTHROUGH(); default: if (isBinop(_tokenKind)) _delimited = true; break; + case T_IMPORT: + if (qmlMode() || (_handlingDirectives && previousTokenKind == T_DOT)) + _importState = ImportState::SawImport; + if (isBinop(_tokenKind)) + _delimited = true; + break; + case T_IF: case T_FOR: case T_WHILE: @@ -462,6 +476,42 @@ int Lexer::scanToken() again: _validTokenText = false; + // handle comment can be called after a '/' has been read + // and returns true if it actually encountered a comment + auto handleComment = [this](){ + if (_char == QLatin1Char('*')) { + scanChar(); + while (_codePtr <= _endPtr) { + if (_char == QLatin1Char('*')) { + scanChar(); + if (_char == QLatin1Char('/')) { + scanChar(); + + if (_engine) { + _engine->addComment(tokenOffset() + 2, _codePtr - _tokenStartPtr - 1 - 4, + tokenStartLine(), tokenStartColumn() + 2); + } + + return true; + } + } else { + scanChar(); + } + } + } else if (_char == QLatin1Char('/')) { + while (_codePtr <= _endPtr && !isLineTerminator()) { + scanChar(); + } + if (_engine) { + _engine->addComment(tokenOffset() + 2, _codePtr - _tokenStartPtr - 1 - 2, + tokenStartLine(), tokenStartColumn() + 2); + } + return true; + } + return false; + }; + + while (_char.isSpace()) { if (isLineTerminator()) { if (_restrictedKeyword) { @@ -569,41 +619,17 @@ again: case ':': return T_COLON; case '/': - if (_char == QLatin1Char('*')) { - scanChar(); - while (_codePtr <= _endPtr) { - if (_char == QLatin1Char('*')) { - scanChar(); - if (_char == QLatin1Char('/')) { - scanChar(); - - if (_engine) { - _engine->addComment(tokenOffset() + 2, _codePtr - _tokenStartPtr - 1 - 4, - tokenStartLine(), tokenStartColumn() + 2); - } - - goto again; - } - } else { - scanChar(); - } - } - } else if (_char == QLatin1Char('/')) { - while (_codePtr <= _endPtr && !isLineTerminator()) { - scanChar(); - } - if (_engine) { - _engine->addComment(tokenOffset() + 2, _codePtr - _tokenStartPtr - 1 - 2, - tokenStartLine(), tokenStartColumn() + 2); - } + if (handleComment()) goto again; - } if (_char == QLatin1Char('=')) { + else if (_char == QLatin1Char('=')) { scanChar(); return T_DIVIDE_EQ; } return T_DIVIDE_; case '.': + if (_importState == ImportState::SawImport) + return T_DOT; if (isDecimalDigit(_char.unicode())) return scanNumber(ch); if (_char == QLatin1Char('.')) { @@ -714,7 +740,10 @@ again: case '7': case '8': case '9': - return scanNumber(ch); + if (_importState == ImportState::SawImport) + return scanVersionNumber(ch); + else + return scanNumber(ch); default: { uint c = ch.unicode(); @@ -794,6 +823,21 @@ again: if (!identifierWithEscapeChars) kind = classify(_tokenStartPtr, _tokenLength, parseModeFlags()); + if (kind == T_FUNCTION) { + continue_skipping: + while (_codePtr < _endPtr && _char.isSpace()) + scanChar(); + if (_char == QLatin1Char('*')) { + _tokenLength = _codePtr - _tokenStartPtr - 1; + kind = T_FUNCTION_STAR; + scanChar(); + } else if (_char == QLatin1Char('/')) { + scanChar(); + if (handleComment()) + goto continue_skipping; + } + } + if (_engine) { if (kind == T_IDENTIFIER && identifierWithEscapeChars) _tokenSpell = _engine->newStringRef(_tokenText); @@ -1132,6 +1176,26 @@ int Lexer::scanNumber(QChar ch) return T_NUMERIC_LITERAL; } +int Lexer::scanVersionNumber(QChar ch) +{ + if (ch == QLatin1Char('0')) { + _tokenValue = 0; + return T_VERSION_NUMBER; + } + + int acc = 0; + acc += ch.digitValue(); + + while (_char.isDigit()) { + acc *= 10; + acc += _char.digitValue(); + scanChar(); // consume the digit + } + + _tokenValue = acc; + return T_VERSION_NUMBER; +} + bool Lexer::scanRegExp(RegExpBodyPrefix prefix) { _tokenText.resize(0); @@ -1352,6 +1416,7 @@ static const int uriTokens[] = { QmlJSGrammar::T_FINALLY, QmlJSGrammar::T_FOR, QmlJSGrammar::T_FUNCTION, + QmlJSGrammar::T_FUNCTION_STAR, QmlJSGrammar::T_IF, QmlJSGrammar::T_IN, QmlJSGrammar::T_OF, @@ -1388,6 +1453,13 @@ static inline bool isUriToken(int token) bool Lexer::scanDirectives(Directives *directives, DiagnosticMessage *error) { + auto setError = [error, this](QString message) { + error->message = std::move(message); + error->loc.startLine = tokenStartLine(); + error->loc.startColumn = tokenStartColumn(); + }; + + QScopedValueRollback directivesGuard(_handlingDirectives, true); Q_ASSERT(!_qmlMode); lex(); // fetch the first token @@ -1408,9 +1480,7 @@ bool Lexer::scanDirectives(Directives *directives, DiagnosticMessage *error) if (! (directiveName == QLatin1String("pragma") || directiveName == QLatin1String("import"))) { - error->message = QCoreApplication::translate("QmlParser", "Syntax error"); - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); + setError(QCoreApplication::translate("QmlParser", "Syntax error")); return false; // not a valid directive name } @@ -1418,9 +1488,7 @@ bool Lexer::scanDirectives(Directives *directives, DiagnosticMessage *error) if (directiveName == QLatin1String("pragma")) { // .pragma library if (! (lex() == T_IDENTIFIER && tokenText() == QLatin1String("library"))) { - error->message = QCoreApplication::translate("QmlParser", "Syntax error"); - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); + setError(QCoreApplication::translate("QmlParser", "Syntax error")); return false; // expected `library } @@ -1442,20 +1510,15 @@ bool Lexer::scanDirectives(Directives *directives, DiagnosticMessage *error) pathOrUri = tokenText(); if (!pathOrUri.endsWith(QLatin1String("js"))) { - error->message = QCoreApplication::translate("QmlParser","Imported file must be a script"); - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); + setError(QCoreApplication::translate("QmlParser","Imported file must be a script")); return false; } } else if (_tokenKind == T_IDENTIFIER) { - // .import T_IDENTIFIER (. T_IDENTIFIER)* T_NUMERIC_LITERAL as T_IDENTIFIER - + // .import T_IDENTIFIER (. T_IDENTIFIER)* T_VERSION_NUMBER . T_VERSION_NUMBER as T_IDENTIFIER while (true) { if (!isUriToken(_tokenKind)) { - error->message = QCoreApplication::translate("QmlParser","Invalid module URI"); - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); + setError(QCoreApplication::translate("QmlParser","Invalid module URI")); return false; } @@ -1463,9 +1526,7 @@ bool Lexer::scanDirectives(Directives *directives, DiagnosticMessage *error) lex(); if (tokenStartLine() != lineNumber) { - error->message = QCoreApplication::translate("QmlParser","Invalid module URI"); - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); + setError(QCoreApplication::translate("QmlParser","Invalid module URI")); return false; } if (_tokenKind != QmlJSGrammar::T_DOT) @@ -1475,21 +1536,30 @@ bool Lexer::scanDirectives(Directives *directives, DiagnosticMessage *error) lex(); if (tokenStartLine() != lineNumber) { - error->message = QCoreApplication::translate("QmlParser","Invalid module URI"); - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); + setError(QCoreApplication::translate("QmlParser","Invalid module URI")); return false; } } - if (_tokenKind != T_NUMERIC_LITERAL) { - error->message = QCoreApplication::translate("QmlParser","Module import requires a version"); - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); + if (_tokenKind != T_VERSION_NUMBER) { + setError(QCoreApplication::translate("QmlParser","Module import requires a version")); return false; // expected the module version number } version = tokenText(); + lex(); + if (_tokenKind != T_DOT) { + setError(QCoreApplication::translate( "QmlParser", "Module import requires a minor version (missing dot)")); + return false; // expected the module version number + } + version += QLatin1Char('.'); + + lex(); + if (_tokenKind != T_VERSION_NUMBER) { + setError(QCoreApplication::translate( "QmlParser", "Module import requires a minor version (missing number)")); + return false; // expected the module version number + } + version += tokenText(); } // @@ -1497,34 +1567,27 @@ bool Lexer::scanDirectives(Directives *directives, DiagnosticMessage *error) // if (! (lex() == T_AS && tokenStartLine() == lineNumber)) { if (fileImport) - error->message = QCoreApplication::translate("QmlParser", "File import requires a qualifier"); + setError(QCoreApplication::translate("QmlParser", "File import requires a qualifier")); else - error->message = QCoreApplication::translate("QmlParser", "Module import requires a qualifier"); + setError(QCoreApplication::translate("QmlParser", "Module import requires a qualifier")); if (tokenStartLine() != lineNumber) { error->loc.startLine = lineNumber; error->loc.startColumn = column; - } else { - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); } return false; // expected `as' } if (lex() != T_IDENTIFIER || tokenStartLine() != lineNumber) { if (fileImport) - error->message = QCoreApplication::translate("QmlParser", "File import requires a qualifier"); + setError(QCoreApplication::translate("QmlParser", "File import requires a qualifier")); else - error->message = QCoreApplication::translate("QmlParser", "Module import requires a qualifier"); - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); + setError(QCoreApplication::translate("QmlParser", "Module import requires a qualifier")); return false; // expected module name } const QString module = tokenText(); if (!module.at(0).isUpper()) { - error->message = QCoreApplication::translate("QmlParser","Invalid import qualifier"); - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); + setError(QCoreApplication::translate("QmlParser","Invalid import qualifier")); return false; } @@ -1535,9 +1598,7 @@ bool Lexer::scanDirectives(Directives *directives, DiagnosticMessage *error) } if (tokenStartLine() != lineNumber) { - error->message = QCoreApplication::translate("QmlParser", "Syntax error"); - error->loc.startLine = tokenStartLine(); - error->loc.startColumn = tokenStartColumn(); + setError(QCoreApplication::translate("QmlParser", "Syntax error")); return false; // the directives cannot span over multiple lines } diff --git a/src/libs/qmljs/parser/qmljslexer_p.h b/src/libs/qmljs/parser/qmljslexer_p.h index 5773606c399..24edb72c25e 100644 --- a/src/libs/qmljs/parser/qmljslexer_p.h +++ b/src/libs/qmljs/parser/qmljslexer_p.h @@ -109,6 +109,11 @@ public: StaticIsKeyword = 0x4 }; + enum class ImportState { + SawImport, + NoQmlImport + }; + public: Lexer(Engine *engine); @@ -173,6 +178,7 @@ private: inline void scanChar(); int scanToken(); int scanNumber(QChar ch); + int scanVersionNumber(QChar ch); enum ScanStringMode { SingleQuote = '\'', DoubleQuote = '"', @@ -227,6 +233,7 @@ private: int _tokenLength; int _tokenLine; int _tokenColumn; + ImportState _importState = ImportState::NoQmlImport; bool _validTokenText; bool _prohibitAutomaticSemicolon; @@ -238,6 +245,7 @@ private: bool _skipLinefeed = false; int _generatorLevel = 0; bool _staticIsKeyword = false; + bool _handlingDirectives = false; }; } // end of namespace QmlJS diff --git a/src/libs/qmljs/parser/qmljsparser.cpp b/src/libs/qmljs/parser/qmljsparser.cpp index d7f23855b8e..7c112e5b923 100644 --- a/src/libs/qmljs/parser/qmljsparser.cpp +++ b/src/libs/qmljs/parser/qmljsparser.cpp @@ -1,5 +1,5 @@ -#line 127 "qmljs.g" +#line 131 "qmljs.g" /**************************************************************************** ** ** Copyright (C) 2016 The Qt Company Ltd. @@ -50,7 +50,7 @@ #include -#line 461 "qmljs.g" +#line 489 "qmljs.g" #include "qmljsparser_p.h" @@ -86,6 +86,7 @@ void Parser::reallocateStack() state_stack = reinterpret_cast (realloc(state_stack, stack_size * sizeof(int))); location_stack = reinterpret_cast (realloc(location_stack, stack_size * sizeof(AST::SourceLocation))); string_stack.resize(stack_size); + rawString_stack.resize(stack_size); } Parser::Parser(Engine *engine): @@ -143,9 +144,12 @@ AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr) void Parser::pushToken(int token) { + Q_ASSERT(last_token); + Q_ASSERT(last_token < &token_buffer[TOKEN_BUFFER_SIZE]); last_token->token = yytoken; last_token->dval = yylval; last_token->spell = yytokenspell; + last_token->raw = yytokenraw; last_token->loc = yylloc; ++last_token; yytoken = token; @@ -157,11 +161,27 @@ int Parser::lookaheadToken(Lexer *lexer) yytoken = lexer->lex(); yylval = lexer->tokenValue(); yytokenspell = lexer->tokenSpell(); + yytokenraw = lexer->rawString(); yylloc = location(lexer); } return yytoken; } +bool Parser::ensureNoFunctionTypeAnnotations(AST::TypeAnnotation *returnValueAnnotation, AST::FormalParameterList *formals) +{ + for (auto formal = formals; formal; formal = formal->next) { + if (formal->element && formal->element->typeAnnotation) { + syntaxError(formal->element->typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in function parameters in JavaScript functions"); + return false; + } + } + if (returnValueAnnotation) { + syntaxError(returnValueAnnotation->firstSourceLocation(), "Type annotations are not permitted for the return value of JavaScript functions"); + return false; + } + return true; +} + //#define PARSER_DEBUG bool Parser::parse(int startToken) @@ -209,11 +229,13 @@ bool Parser::parse(int startToken) yytoken = lexer->lex(); yylval = lexer->tokenValue(); yytokenspell = lexer->tokenSpell(); + yytokenraw = lexer->rawString(); yylloc = location(lexer); } else { yytoken = first_token->token; yylval = first_token->dval; yytokenspell = first_token->spell; + yytokenraw = first_token->raw; yylloc = first_token->loc; ++first_token; if (first_token == last_token) @@ -234,6 +256,7 @@ bool Parser::parse(int startToken) yytoken = -1; sym(1).dval = yylval; stringRef(1) = yytokenspell; + rawStringRef(1) = yytokenraw; loc(1) = yylloc; } else { --tos; @@ -249,128 +272,152 @@ bool Parser::parse(int startToken) switch (r) { -#line 665 "qmljs.g" +#line 716 "qmljs.g" case 0: { sym(1).Node = sym(2).Node; program = sym(1).Node; } break; -#line 673 "qmljs.g" +#line 724 "qmljs.g" case 1: { sym(1).Node = sym(2).Node; program = sym(1).Node; } break; -#line 681 "qmljs.g" +#line 732 "qmljs.g" case 2: { sym(1).Node = sym(2).Node; program = sym(1).Node; } break; -#line 689 "qmljs.g" +#line 740 "qmljs.g" case 3: { sym(1).Node = sym(2).Node; program = sym(1).Node; } break; -#line 697 "qmljs.g" +#line 748 "qmljs.g" case 4: { sym(1).Node = sym(2).Node; program = sym(1).Node; } break; -#line 705 "qmljs.g" +#line 756 "qmljs.g" case 5: { sym(1).Node = sym(2).Node; program = sym(1).Node; } break; -#line 714 "qmljs.g" +#line 765 "qmljs.g" case 6: { sym(1).UiProgram = new (pool) AST::UiProgram(sym(1).UiHeaderItemList, sym(2).UiObjectMemberList->finish()); } break; -#line 722 "qmljs.g" +#line 773 "qmljs.g" case 8: { sym(1).Node = sym(1).UiHeaderItemList->finish(); } break; -#line 729 "qmljs.g" +#line 780 "qmljs.g" case 9: { sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiPragma); } break; -#line 736 "qmljs.g" +#line 787 "qmljs.g" case 10: { sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiImport); } break; -#line 743 "qmljs.g" +#line 794 "qmljs.g" case 11: { sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiHeaderItemList, sym(2).UiPragma); } break; -#line 750 "qmljs.g" +#line 801 "qmljs.g" case 12: { sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiHeaderItemList, sym(2).UiImport); } break; -#line 760 "qmljs.g" +#line 813 "qmljs.g" - case 15: { + case 16: { AST::UiPragma *pragma = new (pool) AST::UiPragma(stringRef(2)); pragma->pragmaToken = loc(1); pragma->semicolonToken = loc(3); sym(1).Node = pragma; } break; -#line 773 "qmljs.g" +#line 825 "qmljs.g" case 18: { sym(1).UiImport->semicolonToken = loc(2); } break; -#line 781 "qmljs.g" +#line 832 "qmljs.g" + + case 19: { + auto version = new (pool) AST::UiVersionSpecifier(sym(1).dval, sym(3).dval); + version->majorToken = loc(1); + version->minorToken = loc(3); + sym(1).UiVersionSpecifier = version; + } break; + +#line 843 "qmljs.g" case 20: { - sym(1).UiImport->versionToken = loc(2); + auto version = new (pool) AST::UiVersionSpecifier(sym(1).dval, 0); + version->majorToken = loc(1); + sym(1).UiVersionSpecifier = version; + } break; + +#line 852 "qmljs.g" + + case 21: { + auto versionToken = loc(2); + auto version = sym(2).UiVersionSpecifier; + sym(1).UiImport->version = version; + if (version->minorToken.isValid()) { + versionToken.length += version->minorToken.length + (version->minorToken.offset - versionToken.offset - versionToken.length); + } + sym(1).UiImport->versionToken = versionToken; sym(1).UiImport->semicolonToken = loc(3); } break; -#line 790 "qmljs.g" +#line 866 "qmljs.g" case 22: { sym(1).UiImport->versionToken = loc(2); + sym(1).UiImport->version = sym(2).UiVersionSpecifier; sym(1).UiImport->asToken = loc(3); sym(1).UiImport->importIdToken = loc(4); sym(1).UiImport->importId = stringRef(4); sym(1).UiImport->semicolonToken = loc(5); } break; -#line 802 "qmljs.g" +#line 878 "qmljs.g" - case 24: { + case 23: { sym(1).UiImport->asToken = loc(2); sym(1).UiImport->importIdToken = loc(3); sym(1).UiImport->importId = stringRef(3); sym(1).UiImport->semicolonToken = loc(4); } break; -#line 812 "qmljs.g" +#line 888 "qmljs.g" - case 25: { + case 24: { AST::UiImport *node = 0; if (AST::StringLiteral *importIdLiteral = AST::cast(sym(2).Expression)) { @@ -386,80 +433,80 @@ bool Parser::parse(int startToken) if (node) { node->importToken = loc(1); } else { - diagnostic_messages.append(DiagnosticMessage(Severity::Error, loc(1), + diagnostic_messages.append(compileError(loc(1), QLatin1String("Expected a qualified name id or a string literal"))); return false; // ### remove me } } break; -#line 838 "qmljs.g" +#line 914 "qmljs.g" - case 26: { + case 25: { sym(1).Node = nullptr; } break; -#line 845 "qmljs.g" +#line 921 "qmljs.g" + + case 26: { + sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember); + } break; + +#line 928 "qmljs.g" case 27: { sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember); } break; -#line 852 "qmljs.g" +#line 935 "qmljs.g" case 28: { - sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember); - } break; - -#line 859 "qmljs.g" - - case 29: { AST::UiObjectMemberList *node = new (pool) AST:: UiObjectMemberList(sym(1).UiObjectMemberList, sym(2).UiObjectMember); sym(1).Node = node; } break; -#line 867 "qmljs.g" +#line 943 "qmljs.g" - case 30: { + case 29: { sym(1).Node = new (pool) AST::UiArrayMemberList(sym(1).UiObjectMember); } break; -#line 874 "qmljs.g" +#line 950 "qmljs.g" - case 31: { + case 30: { AST::UiArrayMemberList *node = new (pool) AST::UiArrayMemberList(sym(1).UiArrayMemberList, sym(3).UiObjectMember); node->commaToken = loc(2); sym(1).Node = node; } break; -#line 883 "qmljs.g" +#line 959 "qmljs.g" - case 32: { + case 31: { AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer((AST::UiObjectMemberList*)0); node->lbraceToken = loc(1); node->rbraceToken = loc(2); sym(1).Node = node; } break; -#line 893 "qmljs.g" +#line 969 "qmljs.g" - case 33: { + case 32: { AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer(sym(2).UiObjectMemberList->finish()); node->lbraceToken = loc(1); node->rbraceToken = loc(3); sym(1).Node = node; } break; -#line 903 "qmljs.g" +#line 979 "qmljs.g" - case 34: { + case 33: { AST::UiObjectDefinition *node = new (pool) AST::UiObjectDefinition(sym(1).UiQualifiedId, sym(2).UiObjectInitializer); sym(1).Node = node; } break; -#line 913 "qmljs.g" +#line 989 "qmljs.g" - case 36: { + case 35: { AST::UiArrayBinding *node = new (pool) AST::UiArrayBinding(sym(1).UiQualifiedId, sym(5).UiArrayMemberList->finish()); node->colonToken = loc(2); node->lbracketToken = loc(4); @@ -467,18 +514,18 @@ bool Parser::parse(int startToken) sym(1).Node = node; } break; -#line 924 "qmljs.g" +#line 1000 "qmljs.g" - case 37: { + case 36: { AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding( sym(1).UiQualifiedId, sym(4).UiQualifiedId, sym(5).UiObjectInitializer); node->colonToken = loc(2); sym(1).Node = node; } break; -#line 934 "qmljs.g" +#line 1010 "qmljs.g" - case 38: { + case 37: { AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding( sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer); node->colonToken = loc(2); @@ -486,11 +533,11 @@ bool Parser::parse(int startToken) sym(1).Node = node; } break; -#line 946 "qmljs.g" - case 39: Q_FALLTHROUGH(); -#line 948 "qmljs.g" +#line 1022 "qmljs.g" + case 38: Q_FALLTHROUGH(); +#line 1024 "qmljs.g" - case 40: { + case 39: { AST::ObjectPattern *l = new (pool) AST::ObjectPattern(sym(3).PatternPropertyList->finish()); l->lbraceToken = loc(1); l->rbraceToken = loc(4); @@ -498,74 +545,84 @@ bool Parser::parse(int startToken) sym(1).Node = node; } break; -#line 960 "qmljs.g" +#line 1036 "qmljs.g" + case 40: Q_FALLTHROUGH(); +#line 1038 "qmljs.g" case 41: Q_FALLTHROUGH(); -#line 962 "qmljs.g" - case 42: Q_FALLTHROUGH(); -#line 964 "qmljs.g" +#line 1040 "qmljs.g" - case 43: { + case 42: { sym(1).Node = sym(3).Node; } break; -#line 972 "qmljs.g" +#line 1048 "qmljs.g" + case 43: Q_FALLTHROUGH(); +#line 1050 "qmljs.g" case 44: Q_FALLTHROUGH(); -#line 974 "qmljs.g" +#line 1052 "qmljs.g" case 45: Q_FALLTHROUGH(); -#line 976 "qmljs.g" +#line 1054 "qmljs.g" case 46: Q_FALLTHROUGH(); -#line 978 "qmljs.g" +#line 1056 "qmljs.g" case 47: Q_FALLTHROUGH(); -#line 980 "qmljs.g" - case 48: Q_FALLTHROUGH(); -#line 982 "qmljs.g" +#line 1058 "qmljs.g" - case 49: { + case 48: { sym(1).Node = sym(2).Node; } break; -#line 989 "qmljs.g" +#line 1065 "qmljs.g" -case 50: +case 49: { AST::UiScriptBinding *node = new (pool) AST::UiScriptBinding(sym(1).UiQualifiedId, sym(3).Statement); node->colonToken = loc(2); sym(1).Node = node; } break; -#line 999 "qmljs.g" +#line 1075 "qmljs.g" + case 50: Q_FALLTHROUGH(); +#line 1077 "qmljs.g" case 51: Q_FALLTHROUGH(); -#line 1001 "qmljs.g" - case 52: Q_FALLTHROUGH(); -#line 1003 "qmljs.g" +#line 1079 "qmljs.g" - case 53: { + case 52: { AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(stringRef(1)); node->identifierToken = loc(1); sym(1).Node = node; } break; -#line 1012 "qmljs.g" +#line 1088 "qmljs.g" - case 54: { + case 53: { AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(sym(1).UiQualifiedId, stringRef(3)); node->identifierToken = loc(3); sym(1).Node = node; } break; -#line 1021 "qmljs.g" +#line 1097 "qmljs.g" - case 55: { + case 54: { sym(1).Node = nullptr; } break; -#line 1028 "qmljs.g" +#line 1104 "qmljs.g" - case 56: { + case 55: { sym(1).Node = sym(1).UiParameterList->finish(); } break; -#line 1035 "qmljs.g" +#line 1111 "qmljs.g" + + case 56: { + AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(3).UiQualifiedId->finish(), stringRef(1)); + node->identifierToken = loc(1); + node->colonToken = loc(2); + node->propertyTypeToken = loc(3); + sym(1).Node = node; + } break; + +#line 1122 "qmljs.g" case 57: { AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiQualifiedId->finish(), stringRef(2)); @@ -574,9 +631,20 @@ case 50: sym(1).Node = node; } break; -#line 1045 "qmljs.g" +#line 1132 "qmljs.g" case 58: { + AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiParameterList, sym(5).UiQualifiedId->finish(), stringRef(3)); + node->propertyTypeToken = loc(5); + node->commaToken = loc(2); + node->identifierToken = loc(3); + node->colonToken = loc(4); + sym(1).Node = node; + } break; + +#line 1144 "qmljs.g" + + case 59: { AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiParameterList, sym(3).UiQualifiedId->finish(), stringRef(4)); node->propertyTypeToken = loc(3); node->commaToken = loc(2); @@ -584,7 +652,7 @@ case 50: sym(1).Node = node; } break; -#line 1057 "qmljs.g" +#line 1155 "qmljs.g" case 60: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(nullptr, stringRef(2)); @@ -597,9 +665,9 @@ case 50: sym(1).Node = node; } break; -#line 1072 "qmljs.g" +#line 1169 "qmljs.g" - case 62: { + case 61: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(nullptr, stringRef(2)); node->type = AST::UiPublicMember::Signal; node->propertyToken = loc(1); @@ -609,9 +677,9 @@ case 50: sym(1).Node = node; } break; -#line 1086 "qmljs.g" +#line 1182 "qmljs.g" - case 64: { + case 62: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(4).UiQualifiedId->finish(), stringRef(6)); node->typeModifier = stringRef(2); node->propertyToken = loc(1); @@ -622,9 +690,18 @@ case 50: sym(1).Node = node; } break; -#line 1101 "qmljs.g" +#line 1198 "qmljs.g" - case 66: { + case 64: { + AST::UiPublicMember *node = sym(2).UiPublicMember; + node->isReadonlyMember = true; + node->readonlyToken = loc(1); + sym(1).Node = node; + } break; + +#line 1208 "qmljs.g" + + case 65: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(2).UiQualifiedId->finish(), stringRef(3)); node->propertyToken = loc(1); node->typeToken = loc(2); @@ -633,37 +710,41 @@ case 50: sym(1).Node = node; } break; -#line 1114 "qmljs.g" +#line 1223 "qmljs.g" + + case 67: { + AST::UiPublicMember *node = sym(2).UiPublicMember; + node->isDefaultMember = true; + node->defaultToken = loc(1); + sym(1).Node = node; + } break; + +#line 1233 "qmljs.g" case 68: { - AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4)); + AST::UiPublicMember *node = sym(2).UiPublicMember; 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; -#line 1129 "qmljs.g" +#line 1243 "qmljs.g" - case 70: { - AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(5).UiQualifiedId->finish(), stringRef(7)); - node->isDefaultMember = true; - node->defaultToken = loc(1); - node->typeModifier = stringRef(3); - node->propertyToken = loc(2); - node->typeModifierToken = loc(2); - node->typeToken = loc(4); - node->identifierToken = loc(7); - node->semicolonToken = loc(8); - sym(1).Node = node; - } break; +/* we need OptionalSemicolon because UiScriptStatement might already parse the last semicolon + and then we would miss a semicolon (see tests/auto/quick/qquickvisualdatamodel/data/objectlist.qml)*/ -#line 1145 "qmljs.g" +#line 1249 "qmljs.g" case 71: { + AST::UiPublicMember *node = sym(2).UiPublicMember; + node->requiredToken = loc(1); + node->isRequired = true; + sym(1).Node = node; + } break; + +#line 1260 "qmljs.g" + + case 72: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(2).UiQualifiedId->finish(), stringRef(3), sym(5).Statement); node->propertyToken = loc(1); node->typeToken = loc(2); @@ -672,35 +753,27 @@ case 50: sym(1).Node = node; } break; -#line 1157 "qmljs.g" - - case 72: { - AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4), sym(6).Statement); - node->isReadonlyMember = true; - node->readonlyToken = loc(1); - node->propertyToken = loc(2); - node->typeToken = loc(3); - node->identifierToken = loc(4); - node->colonToken = loc(5); - sym(1).Node = node; - } break; - -#line 1171 "qmljs.g" - - case 73: { - AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4), sym(6).Statement); - node->isDefaultMember = true; - node->defaultToken = loc(1); - node->propertyToken = loc(2); - node->typeToken = loc(3); - node->identifierToken = loc(4); - node->colonToken = loc(5); - sym(1).Node = node; - } break; - -#line 1185 "qmljs.g" +#line 1274 "qmljs.g" case 74: { + AST::UiPublicMember *node = sym(2).UiPublicMember; + node->isReadonlyMember = true; + node->readonlyToken = loc(1); + sym(1).Node = node; + } break; + +#line 1284 "qmljs.g" + + case 75: { + AST::UiPublicMember *node = sym(2).UiPublicMember; + node->isDefaultMember = true; + node->defaultToken = loc(1); + sym(1).Node = node; + } break; + +#line 1294 "qmljs.g" + + case 76: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(4).UiQualifiedId->finish(), stringRef(6)); node->typeModifier = stringRef(2); node->propertyToken = loc(1); @@ -723,9 +796,18 @@ case 50: sym(1).Node = node; } break; -#line 1211 "qmljs.g" +#line 1322 "qmljs.g" - case 75: { + case 78: { + AST::UiPublicMember *node = sym(2).UiPublicMember; + node->isReadonlyMember = true; + node->readonlyToken = loc(1); + sym(1).Node = node; + } break; + +#line 1332 "qmljs.g" + + case 79: { AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(2).UiQualifiedId->finish(), stringRef(3)); node->propertyToken = loc(1); node->typeToken = loc(2); @@ -745,48 +827,40 @@ case 50: sym(1).Node = node; } break; -#line 1234 "qmljs.g" +#line 1357 "qmljs.g" - case 76: { - AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4)); + case 81: { + AST::UiPublicMember *node = sym(2).UiPublicMember; node->isReadonlyMember = true; node->readonlyToken = loc(1); - node->propertyToken = loc(2); - node->typeToken = loc(3); - node->identifierToken = loc(4); - node->semicolonToken = loc(5); // insert a fake ';' before ':' - - AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(4)); - propertyName->identifierToken = loc(4); - propertyName->next = 0; - - AST::UiObjectBinding *binding = new (pool) AST::UiObjectBinding( - propertyName, sym(7).UiQualifiedId, sym(8).UiObjectInitializer); - binding->colonToken = loc(5); - - node->binding = binding; - sym(1).Node = node; } break; -#line 1259 "qmljs.g" +#line 1367 "qmljs.g" - case 77: { + case 82: { + auto node = new (pool) AST::UiSourceElement(sym(1).Node); + sym(1).Node = node; + } break; + +#line 1375 "qmljs.g" + + case 83: { sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node); } break; -#line 1266 "qmljs.g" +#line 1382 "qmljs.g" - case 78: { + case 84: { sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node); } break; -#line 1273 "qmljs.g" +#line 1389 "qmljs.g" - case 79: { + case 85: { if (AST::ArrayMemberExpression *mem = AST::cast(sym(1).Expression)) { - diagnostic_messages.append(DiagnosticMessage(Severity::Warning, mem->lbracketToken, - QLatin1String("Ignored annotation"))); + diagnostic_messages.append(compileError(mem->lbracketToken, + QLatin1String("Ignored annotation"), Severity::Warning)); sym(1).Expression = mem->base; } @@ -796,16 +870,16 @@ case 50: } else { sym(1).UiQualifiedId = 0; - diagnostic_messages.append(DiagnosticMessage(Severity::Error, loc(1), + diagnostic_messages.append(compileError(loc(1), QLatin1String("Expected a qualified name id"))); return false; // ### recover } } break; -#line 1296 "qmljs.g" +#line 1412 "qmljs.g" - case 80: { + case 86: { AST::UiEnumDeclaration *enumDeclaration = new (pool) AST::UiEnumDeclaration(stringRef(2), sym(4).UiEnumMemberList->finish()); enumDeclaration->enumToken = loc(1); enumDeclaration->rbraceToken = loc(5); @@ -813,18 +887,18 @@ case 50: break; } -#line 1307 "qmljs.g" +#line 1423 "qmljs.g" - case 81: { + case 87: { AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(stringRef(1)); node->memberToken = loc(1); sym(1).Node = node; break; } -#line 1317 "qmljs.g" +#line 1433 "qmljs.g" - case 82: { + case 88: { AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(stringRef(1), sym(3).dval); node->memberToken = loc(1); node->valueToken = loc(3); @@ -832,18 +906,18 @@ case 50: break; } -#line 1328 "qmljs.g" +#line 1444 "qmljs.g" - case 83: { + case 89: { AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(sym(1).UiEnumMemberList, stringRef(3)); node->memberToken = loc(3); sym(1).Node = node; break; } -#line 1338 "qmljs.g" +#line 1454 "qmljs.g" - case 84: { + case 90: { AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(sym(1).UiEnumMemberList, stringRef(3), sym(5).dval); node->memberToken = loc(3); node->valueToken = loc(5); @@ -851,34 +925,79 @@ case 50: break; } -#line 1378 "qmljs.g" +#line 1496 "qmljs.g" - case 107: { + case 115: { + sym(1).TypeArgumentList = new (pool) AST::TypeArgumentList(sym(1).Type); + } break; + +#line 1503 "qmljs.g" + + case 116: { + sym(1).TypeArgumentList = new (pool) AST::TypeArgumentList(sym(1).TypeArgumentList, sym(3).Type); + } break; + +#line 1510 "qmljs.g" + + case 117: { + sym(1).Type = new (pool) AST::Type(sym(1).UiQualifiedId, sym(3).TypeArgumentList->finish()); + } break; + +#line 1517 "qmljs.g" + + case 118: { + AST::UiQualifiedId *id = new (pool) AST::UiQualifiedId(stringRef(1)); + id->identifierToken = loc(1); + sym(1).Type = new (pool) AST::Type(id->finish()); + } break; + +#line 1526 "qmljs.g" + + case 119: { + sym(1).Type = new (pool) AST::Type(sym(1).UiQualifiedId); + } break; + +#line 1533 "qmljs.g" + + case 120: { + sym(1).TypeAnnotation = new (pool) AST::TypeAnnotation(sym(2).Type); + sym(1).TypeAnnotation->colonToken = loc(1); + } break; + +#line 1542 "qmljs.g" + + case 122: { + sym(1).TypeAnnotation = nullptr; + } break; + +#line 1553 "qmljs.g" + + case 123: { AST::ThisExpression *node = new (pool) AST::ThisExpression(); node->thisToken = loc(1); sym(1).Node = node; } break; -#line 1387 "qmljs.g" +#line 1562 "qmljs.g" - case 108: { + case 124: { AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1)); node->identifierToken = loc(1); sym(1).Node = node; } break; -#line 1405 "qmljs.g" +#line 1580 "qmljs.g" - case 117: { + case 133: { if (coverExpressionType != CE_ParenthesizedExpression) { syntaxError(coverExpressionErrorLocation, "Expected token ')'."); return false; } } break; -#line 1416 "qmljs.g" +#line 1591 "qmljs.g" - case 118: { + case 134: { AST::NestedExpression *node = new (pool) AST::NestedExpression(sym(2).Expression); node->lparenToken = loc(1); node->rparenToken = loc(3); @@ -886,26 +1005,26 @@ case 50: coverExpressionType = CE_ParenthesizedExpression; } break; -#line 1427 "qmljs.g" +#line 1602 "qmljs.g" - case 119: { + case 135: { sym(1).Node = nullptr; coverExpressionErrorLocation = loc(2); coverExpressionType = CE_FormalParameterList; } break; -#line 1436 "qmljs.g" +#line 1611 "qmljs.g" - case 120: { + case 136: { AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(2).PatternElement))->finish(pool); sym(1).Node = node; coverExpressionErrorLocation = loc(2); coverExpressionType = CE_FormalParameterList; } break; -#line 1446 "qmljs.g" +#line 1621 "qmljs.g" - case 121: { + case 137: { AST::FormalParameterList *list = sym(2).Expression->reparseAsFormalParameterList(pool); if (!list) { syntaxError(loc(1), "Invalid Arrow parameter list."); @@ -919,66 +1038,66 @@ case 50: sym(1).Node = list->finish(pool); } break; -#line 1463 "qmljs.g" +#line 1638 "qmljs.g" - case 122: { + case 138: { AST::NullExpression *node = new (pool) AST::NullExpression(); node->nullToken = loc(1); sym(1).Node = node; } break; -#line 1472 "qmljs.g" +#line 1647 "qmljs.g" - case 123: { + case 139: { AST::TrueLiteral *node = new (pool) AST::TrueLiteral(); node->trueToken = loc(1); sym(1).Node = node; } break; -#line 1481 "qmljs.g" +#line 1656 "qmljs.g" - case 124: { + case 140: { AST::FalseLiteral *node = new (pool) AST::FalseLiteral(); node->falseToken = loc(1); sym(1).Node = node; } break; -#line 1490 "qmljs.g" +#line 1665 "qmljs.g" - case 125: { + case 141: { AST::NumericLiteral *node = new (pool) AST::NumericLiteral(sym(1).dval); node->literalToken = loc(1); sym(1).Node = node; } break; -#line 1499 "qmljs.g" - case 126: Q_FALLTHROUGH(); -#line 1502 "qmljs.g" +#line 1674 "qmljs.g" + case 142: Q_FALLTHROUGH(); +#line 1677 "qmljs.g" - case 127: { + case 143: { AST::StringLiteral *node = new (pool) AST::StringLiteral(stringRef(1)); node->literalToken = loc(1); sym(1).Node = node; } break; -#line 1514 "qmljs.g" +#line 1689 "qmljs.g" { Lexer::RegExpBodyPrefix prefix; - case 128: + case 144: prefix = Lexer::NoPrefix; goto scan_regexp; -#line 1526 "qmljs.g" +#line 1701 "qmljs.g" - case 129: + case 145: prefix = Lexer::EqualPrefix; goto scan_regexp; scan_regexp: { bool rx = lexer->scanRegExp(prefix); if (!rx) { - diagnostic_messages.append(DiagnosticMessage(Severity::Error, location(lexer), lexer->errorMessage())); + diagnostic_messages.append(compileError(location(lexer), lexer->errorMessage())); return false; } @@ -991,9 +1110,9 @@ case 50: } break; } -#line 1550 "qmljs.g" +#line 1725 "qmljs.g" - case 130: { + case 146: { AST::PatternElementList *list = nullptr; if (sym(2).Elision) list = (new (pool) AST::PatternElementList(sym(2).Elision, nullptr))->finish(); @@ -1003,18 +1122,18 @@ case 50: sym(1).Node = node; } break; -#line 1563 "qmljs.g" +#line 1738 "qmljs.g" - case 131: { + case 147: { AST::ArrayPattern *node = new (pool) AST::ArrayPattern(sym(2).PatternElementList->finish()); node->lbracketToken = loc(1); node->rbracketToken = loc(3); sym(1).Node = node; } break; -#line 1573 "qmljs.g" +#line 1748 "qmljs.g" - case 132: { + case 148: { auto *list = sym(2).PatternElementList; if (sym(4).Elision) { AST::PatternElementList *l = new (pool) AST::PatternElementList(sym(4).Elision, nullptr); @@ -1028,124 +1147,124 @@ case 50: Q_ASSERT(node->isValidArrayLiteral()); } break; -#line 1590 "qmljs.g" +#line 1765 "qmljs.g" - case 133: { + case 149: { AST::PatternElement *e = new (pool) AST::PatternElement(sym(1).Expression); sym(1).Node = new (pool) AST::PatternElementList(nullptr, e); } break; -#line 1598 "qmljs.g" +#line 1773 "qmljs.g" - case 134: { + case 150: { AST::PatternElement *e = new (pool) AST::PatternElement(sym(2).Expression); sym(1).Node = new (pool) AST::PatternElementList(sym(1).Elision->finish(), e); } break; -#line 1606 "qmljs.g" +#line 1781 "qmljs.g" - case 135: { + case 151: { AST::PatternElementList *node = new (pool) AST::PatternElementList(sym(1).Elision, sym(2).PatternElement); sym(1).Node = node; } break; -#line 1614 "qmljs.g" +#line 1789 "qmljs.g" - case 136: { + case 152: { AST::PatternElement *e = new (pool) AST::PatternElement(sym(4).Expression); AST::PatternElementList *node = new (pool) AST::PatternElementList(sym(3).Elision, e); sym(1).Node = sym(1).PatternElementList->append(node); } break; -#line 1623 "qmljs.g" +#line 1798 "qmljs.g" - case 137: { + case 153: { AST::PatternElementList *node = new (pool) AST::PatternElementList(sym(3).Elision, sym(4).PatternElement); sym(1).Node = sym(1).PatternElementList->append(node); } break; -#line 1631 "qmljs.g" +#line 1806 "qmljs.g" - case 138: { + case 154: { AST::Elision *node = new (pool) AST::Elision(); node->commaToken = loc(1); sym(1).Node = node; } break; -#line 1640 "qmljs.g" +#line 1815 "qmljs.g" - case 139: { + case 155: { AST::Elision *node = new (pool) AST::Elision(sym(1).Elision); node->commaToken = loc(2); sym(1).Node = node; } break; -#line 1649 "qmljs.g" +#line 1824 "qmljs.g" - case 140: { + case 156: { sym(1).Node = nullptr; } break; -#line 1656 "qmljs.g" +#line 1831 "qmljs.g" - case 141: { + case 157: { sym(1).Node = sym(1).Elision->finish(); } break; -#line 1663 "qmljs.g" +#line 1838 "qmljs.g" - case 142: { + case 158: { AST::PatternElement *node = new (pool) AST::PatternElement(sym(2).Expression, AST::PatternElement::SpreadElement); sym(1).Node = node; } break; -#line 1671 "qmljs.g" +#line 1846 "qmljs.g" - case 143: { + case 159: { AST::ObjectPattern *node = new (pool) AST::ObjectPattern(); node->lbraceToken = loc(1); node->rbraceToken = loc(2); sym(1).Node = node; } break; -#line 1681 "qmljs.g" +#line 1856 "qmljs.g" - case 144: { + case 160: { AST::ObjectPattern *node = new (pool) AST::ObjectPattern(sym(2).PatternPropertyList->finish()); node->lbraceToken = loc(1); node->rbraceToken = loc(3); sym(1).Node = node; } break; -#line 1691 "qmljs.g" +#line 1866 "qmljs.g" - case 145: { + case 161: { AST::ObjectPattern *node = new (pool) AST::ObjectPattern(sym(2).PatternPropertyList->finish()); node->lbraceToken = loc(1); node->rbraceToken = loc(4); sym(1).Node = node; } break; -#line 1702 "qmljs.g" - case 146: Q_FALLTHROUGH(); -#line 1704 "qmljs.g" +#line 1877 "qmljs.g" + case 162: Q_FALLTHROUGH(); +#line 1879 "qmljs.g" - case 147: { + case 163: { sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternProperty); } break; -#line 1711 "qmljs.g" - case 148: Q_FALLTHROUGH(); -#line 1713 "qmljs.g" +#line 1886 "qmljs.g" + case 164: Q_FALLTHROUGH(); +#line 1888 "qmljs.g" - case 149: { + case 165: { AST::PatternPropertyList *node = new (pool) AST::PatternPropertyList(sym(1).PatternPropertyList, sym(3).PatternProperty); sym(1).Node = node; } break; -#line 1721 "qmljs.g" +#line 1896 "qmljs.g" - case 150: { + case 166: { AST::IdentifierPropertyName *name = new (pool) AST::IdentifierPropertyName(stringRef(1)); name->propertyNameToken = loc(1); AST::IdentifierExpression *expr = new (pool) AST::IdentifierExpression(stringRef(1)); @@ -1155,9 +1274,9 @@ case 50: sym(1).Node = node; } break; -#line 1737 "qmljs.g" +#line 1912 "qmljs.g" - case 152: { + case 168: { AST::IdentifierPropertyName *name = new (pool) AST::IdentifierPropertyName(stringRef(1)); name->propertyNameToken = loc(1); AST::IdentifierExpression *left = new (pool) AST::IdentifierExpression(stringRef(1)); @@ -1174,16 +1293,12 @@ case 50: } break; -#line 1757 "qmljs.g" - case 153: Q_FALLTHROUGH(); -#line 1759 "qmljs.g" +#line 1932 "qmljs.g" + case 169: Q_FALLTHROUGH(); +#line 1934 "qmljs.g" - case 154: { + case 170: { AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, sym(3).Expression); - if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression)) { - if (!AST::cast(sym(1).PropertyName)) - f->name = driver->newStringRef(sym(1).PropertyName->asString()); - } if (auto *c = asAnonymousClassDefinition(sym(3).Expression)) { if (!AST::cast(sym(1).PropertyName)) c->name = driver->newStringRef(sym(1).PropertyName->asString()); @@ -1192,120 +1307,120 @@ case 50: sym(1).Node = node; } break; -#line 1781 "qmljs.g" +#line 1952 "qmljs.g" - case 158: { + case 174: { AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1)); node->propertyNameToken = loc(1); sym(1).Node = node; } break; -#line 1790 "qmljs.g" - case 159: Q_FALLTHROUGH(); -#line 1792 "qmljs.g" +#line 1961 "qmljs.g" + case 175: Q_FALLTHROUGH(); +#line 1963 "qmljs.g" - case 160: { + case 176: { AST::StringLiteralPropertyName *node = new (pool) AST::StringLiteralPropertyName(stringRef(1)); node->propertyNameToken = loc(1); sym(1).Node = node; } break; -#line 1801 "qmljs.g" - case 161: Q_FALLTHROUGH(); -#line 1803 "qmljs.g" +#line 1972 "qmljs.g" + case 177: Q_FALLTHROUGH(); +#line 1974 "qmljs.g" - case 162: { + case 178: { AST::NumericLiteralPropertyName *node = new (pool) AST::NumericLiteralPropertyName(sym(1).dval); node->propertyNameToken = loc(1); sym(1).Node = node; } break; -#line 1854 "qmljs.g" +#line 2025 "qmljs.g" - case 203: { + case 219: { AST::ComputedPropertyName *node = new (pool) AST::ComputedPropertyName(sym(2).Expression); node->propertyNameToken = loc(1); sym(1).Node = node; } break; -#line 1863 "qmljs.g" - case 204: Q_FALLTHROUGH(); -#line 1865 "qmljs.g" +#line 2034 "qmljs.g" + case 220: Q_FALLTHROUGH(); +#line 2036 "qmljs.g" -case 205: { +case 221: { sym(1) = sym(2); } break; -#line 1873 "qmljs.g" - case 206: Q_FALLTHROUGH(); -#line 1875 "qmljs.g" +#line 2044 "qmljs.g" + case 222: Q_FALLTHROUGH(); +#line 2046 "qmljs.g" - case 207: { + case 223: { sym(1).Node = nullptr; } break; -#line 1885 "qmljs.g" - case 210: Q_FALLTHROUGH(); -#line 1888 "qmljs.g" +#line 2056 "qmljs.g" + case 226: Q_FALLTHROUGH(); +#line 2059 "qmljs.g" - case 211: { - AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), nullptr); + case 227: { + AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), rawStringRef(1), nullptr); node->literalToken = loc(1); sym(1).Node = node; } break; -#line 1897 "qmljs.g" - case 212: Q_FALLTHROUGH(); -#line 1900 "qmljs.g" +#line 2068 "qmljs.g" + case 228: Q_FALLTHROUGH(); +#line 2071 "qmljs.g" - case 213: { - AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), sym(2).Expression); + case 229: { + AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), rawStringRef(1), sym(2).Expression); node->next = sym(3).Template; node->literalToken = loc(1); sym(1).Node = node; } break; -#line 1913 "qmljs.g" +#line 2084 "qmljs.g" - case 215: { + case 231: { AST::SuperLiteral *node = new (pool) AST::SuperLiteral(); node->superToken = loc(1); sym(1).Node = node; } break; -#line 1923 "qmljs.g" - case 216: Q_FALLTHROUGH(); -#line 1925 "qmljs.g" +#line 2094 "qmljs.g" + case 232: Q_FALLTHROUGH(); +#line 2096 "qmljs.g" - case 217: { + case 233: { AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression); node->lbracketToken = loc(2); node->rbracketToken = loc(4); sym(1).Node = node; } break; -#line 1937 "qmljs.g" - case 218: +#line 2108 "qmljs.g" + case 234: { AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1)); node->identifierToken= loc(1); sym(1).Node = node; } Q_FALLTHROUGH(); -#line 1945 "qmljs.g" - case 219: Q_FALLTHROUGH(); -#line 1947 "qmljs.g" +#line 2116 "qmljs.g" + case 235: Q_FALLTHROUGH(); +#line 2118 "qmljs.g" - case 220: { + case 236: { AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3)); node->dotToken = loc(2); node->identifierToken = loc(3); sym(1).Node = node; } break; -#line 1959 "qmljs.g" +#line 2130 "qmljs.g" - case 222: { + case 238: { AST::NewMemberExpression *node = new (pool) AST::NewMemberExpression(sym(2).Expression, sym(4).ArgumentList); node->newToken = loc(1); node->lparenToken = loc(3); @@ -1313,416 +1428,416 @@ case 205: { sym(1).Node = node; } break; -#line 1975 "qmljs.g" +#line 2146 "qmljs.g" - case 225: { + case 241: { AST::NewExpression *node = new (pool) AST::NewExpression(sym(2).Expression); node->newToken = loc(1); sym(1).Node = node; } break; -#line 1985 "qmljs.g" - case 226: Q_FALLTHROUGH(); -#line 1987 "qmljs.g" +#line 2156 "qmljs.g" + case 242: Q_FALLTHROUGH(); +#line 2158 "qmljs.g" - case 227: { + case 243: { AST::TaggedTemplate *node = new (pool) AST::TaggedTemplate(sym(1).Expression, sym(2).Template); sym(1).Node = node; } break; -#line 1995 "qmljs.g" +#line 2166 "qmljs.g" - case 228: { + case 244: { AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList); node->lparenToken = loc(2); node->rparenToken = loc(4); sym(1).Node = node; } break; -#line 2005 "qmljs.g" - case 229: Q_FALLTHROUGH(); -#line 2007 "qmljs.g" +#line 2176 "qmljs.g" + case 245: Q_FALLTHROUGH(); +#line 2178 "qmljs.g" - case 230: { + case 246: { AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList); node->lparenToken = loc(2); node->rparenToken = loc(4); sym(1).Node = node; } break; -#line 2017 "qmljs.g" +#line 2188 "qmljs.g" - case 231: { + case 247: { AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression); node->lbracketToken = loc(2); node->rbracketToken = loc(4); sym(1).Node = node; } break; -#line 2027 "qmljs.g" +#line 2198 "qmljs.g" - case 232: { + case 248: { AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3)); node->dotToken = loc(2); node->identifierToken = loc(3); sym(1).Node = node; } break; -#line 2037 "qmljs.g" +#line 2208 "qmljs.g" - case 233: { + case 249: { sym(1).Node = nullptr; } break; -#line 2044 "qmljs.g" - case 234: Q_FALLTHROUGH(); -#line 2046 "qmljs.g" +#line 2215 "qmljs.g" + case 250: Q_FALLTHROUGH(); +#line 2217 "qmljs.g" - case 235: { + case 251: { sym(1).Node = sym(1).ArgumentList->finish(); } break; -#line 2053 "qmljs.g" +#line 2224 "qmljs.g" - case 236: { + case 252: { sym(1).Node = new (pool) AST::ArgumentList(sym(1).Expression); } break; -#line 2060 "qmljs.g" +#line 2231 "qmljs.g" - case 237: { + case 253: { AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(2).Expression); node->isSpreadElement = true; sym(1).Node = node; } break; -#line 2069 "qmljs.g" +#line 2240 "qmljs.g" - case 238: { + case 254: { AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(3).Expression); node->commaToken = loc(2); sym(1).Node = node; } break; -#line 2078 "qmljs.g" +#line 2249 "qmljs.g" - case 239: { + case 255: { AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(4).Expression); node->commaToken = loc(2); node->isSpreadElement = true; sym(1).Node = node; } break; -#line 2093 "qmljs.g" +#line 2264 "qmljs.g" - case 243: { + case 259: { AST::PostIncrementExpression *node = new (pool) AST::PostIncrementExpression(sym(1).Expression); node->incrementToken = loc(2); sym(1).Node = node; } break; -#line 2102 "qmljs.g" +#line 2273 "qmljs.g" - case 244: { + case 260: { AST::PostDecrementExpression *node = new (pool) AST::PostDecrementExpression(sym(1).Expression); node->decrementToken = loc(2); sym(1).Node = node; } break; -#line 2111 "qmljs.g" +#line 2282 "qmljs.g" - case 245: { + case 261: { AST::PreIncrementExpression *node = new (pool) AST::PreIncrementExpression(sym(2).Expression); node->incrementToken = loc(1); sym(1).Node = node; } break; -#line 2120 "qmljs.g" +#line 2291 "qmljs.g" - case 246: { + case 262: { AST::PreDecrementExpression *node = new (pool) AST::PreDecrementExpression(sym(2).Expression); node->decrementToken = loc(1); sym(1).Node = node; } break; -#line 2131 "qmljs.g" +#line 2302 "qmljs.g" - case 248: { + case 264: { AST::DeleteExpression *node = new (pool) AST::DeleteExpression(sym(2).Expression); node->deleteToken = loc(1); sym(1).Node = node; } break; -#line 2140 "qmljs.g" +#line 2311 "qmljs.g" - case 249: { + case 265: { AST::VoidExpression *node = new (pool) AST::VoidExpression(sym(2).Expression); node->voidToken = loc(1); sym(1).Node = node; } break; -#line 2149 "qmljs.g" +#line 2320 "qmljs.g" - case 250: { + case 266: { AST::TypeOfExpression *node = new (pool) AST::TypeOfExpression(sym(2).Expression); node->typeofToken = loc(1); sym(1).Node = node; } break; -#line 2158 "qmljs.g" +#line 2329 "qmljs.g" - case 251: { + case 267: { AST::UnaryPlusExpression *node = new (pool) AST::UnaryPlusExpression(sym(2).Expression); node->plusToken = loc(1); sym(1).Node = node; } break; -#line 2167 "qmljs.g" +#line 2338 "qmljs.g" - case 252: { + case 268: { AST::UnaryMinusExpression *node = new (pool) AST::UnaryMinusExpression(sym(2).Expression); node->minusToken = loc(1); sym(1).Node = node; } break; -#line 2176 "qmljs.g" +#line 2347 "qmljs.g" - case 253: { + case 269: { AST::TildeExpression *node = new (pool) AST::TildeExpression(sym(2).Expression); node->tildeToken = loc(1); sym(1).Node = node; } break; -#line 2185 "qmljs.g" +#line 2356 "qmljs.g" - case 254: { + case 270: { AST::NotExpression *node = new (pool) AST::NotExpression(sym(2).Expression); node->notToken = loc(1); sym(1).Node = node; } break; -#line 2196 "qmljs.g" +#line 2367 "qmljs.g" - case 256: { + case 272: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Exp, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2207 "qmljs.g" +#line 2378 "qmljs.g" - case 258: { + case 274: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, sym(2).ival, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2216 "qmljs.g" +#line 2387 "qmljs.g" - case 259: { + case 275: { sym(1).ival = QSOperator::Mul; } break; -#line 2223 "qmljs.g" +#line 2394 "qmljs.g" - case 260: { + case 276: { sym(1).ival = QSOperator::Div; } break; -#line 2230 "qmljs.g" +#line 2401 "qmljs.g" - case 261: { + case 277: { sym(1).ival = QSOperator::Mod; } break; -#line 2239 "qmljs.g" +#line 2410 "qmljs.g" - case 263: { + case 279: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Add, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2248 "qmljs.g" +#line 2419 "qmljs.g" - case 264: { + case 280: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Sub, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2259 "qmljs.g" +#line 2430 "qmljs.g" - case 266: { + case 282: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::LShift, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2268 "qmljs.g" +#line 2439 "qmljs.g" - case 267: { + case 283: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::RShift, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2277 "qmljs.g" +#line 2448 "qmljs.g" - case 268: { + case 284: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::URShift, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2289 "qmljs.g" - case 271: Q_FALLTHROUGH(); -#line 2291 "qmljs.g" +#line 2460 "qmljs.g" + case 287: Q_FALLTHROUGH(); +#line 2462 "qmljs.g" - case 272: { + case 288: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, sym(2).ival, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2300 "qmljs.g" +#line 2471 "qmljs.g" - case 273: { + case 289: { sym(1).ival = QSOperator::Lt; } break; -#line 2306 "qmljs.g" +#line 2477 "qmljs.g" - case 274: { + case 290: { sym(1).ival = QSOperator::Gt; } break; -#line 2312 "qmljs.g" +#line 2483 "qmljs.g" - case 275: { + case 291: { sym(1).ival = QSOperator::Le; } break; -#line 2318 "qmljs.g" +#line 2489 "qmljs.g" - case 276: { + case 292: { sym(1).ival = QSOperator::Ge; } break; -#line 2324 "qmljs.g" +#line 2495 "qmljs.g" - case 277: { + case 293: { sym(1).ival = QSOperator::InstanceOf; } break; -#line 2331 "qmljs.g" +#line 2502 "qmljs.g" - case 278: { + case 294: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::In, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2343 "qmljs.g" - case 281: Q_FALLTHROUGH(); -#line 2345 "qmljs.g" +#line 2514 "qmljs.g" + case 297: Q_FALLTHROUGH(); +#line 2516 "qmljs.g" - case 282: { + case 298: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, sym(2).ival, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2354 "qmljs.g" +#line 2525 "qmljs.g" - case 283: { + case 299: { sym(1).ival = QSOperator::Equal; } break; -#line 2360 "qmljs.g" +#line 2531 "qmljs.g" - case 284: { + case 300: { sym(1).ival = QSOperator::NotEqual; } break; -#line 2366 "qmljs.g" +#line 2537 "qmljs.g" - case 285: { + case 301: { sym(1).ival = QSOperator::StrictEqual; } break; -#line 2372 "qmljs.g" +#line 2543 "qmljs.g" - case 286: { + case 302: { sym(1).ival = QSOperator::StrictNotEqual; } break; -#line 2383 "qmljs.g" - case 289: Q_FALLTHROUGH(); -#line 2385 "qmljs.g" +#line 2554 "qmljs.g" + case 305: Q_FALLTHROUGH(); +#line 2556 "qmljs.g" - case 290: { + case 306: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::BitAnd, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2398 "qmljs.g" - case 293: Q_FALLTHROUGH(); -#line 2400 "qmljs.g" +#line 2569 "qmljs.g" + case 309: Q_FALLTHROUGH(); +#line 2571 "qmljs.g" - case 294: { + case 310: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::BitXor, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2412 "qmljs.g" - case 297: Q_FALLTHROUGH(); -#line 2414 "qmljs.g" +#line 2583 "qmljs.g" + case 313: Q_FALLTHROUGH(); +#line 2585 "qmljs.g" - case 298: { + case 314: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::BitOr, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2426 "qmljs.g" - case 301: Q_FALLTHROUGH(); -#line 2428 "qmljs.g" +#line 2597 "qmljs.g" + case 317: Q_FALLTHROUGH(); +#line 2599 "qmljs.g" - case 302: { + case 318: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::And, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2440 "qmljs.g" - case 305: Q_FALLTHROUGH(); -#line 2442 "qmljs.g" +#line 2611 "qmljs.g" + case 321: Q_FALLTHROUGH(); +#line 2613 "qmljs.g" - case 306: { + case 322: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Or, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2455 "qmljs.g" - case 309: Q_FALLTHROUGH(); -#line 2457 "qmljs.g" +#line 2626 "qmljs.g" + case 325: Q_FALLTHROUGH(); +#line 2628 "qmljs.g" - case 310: { + case 326: { AST::ConditionalExpression *node = new (pool) AST::ConditionalExpression(sym(1).Expression, sym(3).Expression, sym(5).Expression); node->questionToken = loc(2); node->colonToken = loc(4); sym(1).Node = node; } break; -#line 2476 "qmljs.g" - case 317: Q_FALLTHROUGH(); -#line 2478 "qmljs.g" +#line 2647 "qmljs.g" + case 333: Q_FALLTHROUGH(); +#line 2649 "qmljs.g" - case 318: { + case 334: { // need to convert the LHS to an AssignmentPattern if it was an Array/ObjectLiteral if (AST::Pattern *p = sym(1).Expression->patternCast()) { AST::SourceLocation errorLoc; @@ -1747,275 +1862,282 @@ case 205: { sym(1).Node = node; } break; -#line 2506 "qmljs.g" - case 319: Q_FALLTHROUGH(); -#line 2508 "qmljs.g" +#line 2677 "qmljs.g" + case 335: Q_FALLTHROUGH(); +#line 2679 "qmljs.g" - case 320: { + case 336: { AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, sym(2).ival, sym(3).Expression); node->operatorToken = loc(2); sym(1).Node = node; } break; -#line 2517 "qmljs.g" +#line 2688 "qmljs.g" - case 321: { + case 337: { sym(1).ival = QSOperator::InplaceMul; } break; -#line 2524 "qmljs.g" +#line 2695 "qmljs.g" - case 322: { + case 338: { sym(1).ival = QSOperator::InplaceExp; } break; -#line 2531 "qmljs.g" +#line 2702 "qmljs.g" - case 323: { + case 339: { sym(1).ival = QSOperator::InplaceDiv; } break; -#line 2538 "qmljs.g" +#line 2709 "qmljs.g" - case 324: { + case 340: { sym(1).ival = QSOperator::InplaceMod; } break; -#line 2545 "qmljs.g" +#line 2716 "qmljs.g" - case 325: { + case 341: { sym(1).ival = QSOperator::InplaceAdd; } break; -#line 2552 "qmljs.g" +#line 2723 "qmljs.g" - case 326: { + case 342: { sym(1).ival = QSOperator::InplaceSub; } break; -#line 2559 "qmljs.g" +#line 2730 "qmljs.g" - case 327: { + case 343: { sym(1).ival = QSOperator::InplaceLeftShift; } break; -#line 2566 "qmljs.g" +#line 2737 "qmljs.g" - case 328: { + case 344: { sym(1).ival = QSOperator::InplaceRightShift; } break; -#line 2573 "qmljs.g" +#line 2744 "qmljs.g" - case 329: { + case 345: { sym(1).ival = QSOperator::InplaceURightShift; } break; -#line 2580 "qmljs.g" +#line 2751 "qmljs.g" - case 330: { + case 346: { sym(1).ival = QSOperator::InplaceAnd; } break; -#line 2587 "qmljs.g" +#line 2758 "qmljs.g" - case 331: { + case 347: { sym(1).ival = QSOperator::InplaceXor; } break; -#line 2594 "qmljs.g" +#line 2765 "qmljs.g" - case 332: { + case 348: { sym(1).ival = QSOperator::InplaceOr; } break; -#line 2604 "qmljs.g" - case 335: Q_FALLTHROUGH(); -#line 2606 "qmljs.g" +#line 2775 "qmljs.g" + case 351: Q_FALLTHROUGH(); +#line 2777 "qmljs.g" - case 336: { + case 352: { AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression); node->commaToken = loc(2); sym(1).Node = node; } break; -#line 2615 "qmljs.g" - case 337: Q_FALLTHROUGH(); -#line 2617 "qmljs.g" +#line 2786 "qmljs.g" + case 353: Q_FALLTHROUGH(); +#line 2788 "qmljs.g" - case 338: { + case 354: { sym(1).Node = nullptr; } break; -#line 2629 "qmljs.g" +#line 2800 "qmljs.g" - case 341: { + case 357: { sym(1).Node = sym(3).Node; } break; -#line 2636 "qmljs.g" - case 342: Q_FALLTHROUGH(); -#line 2638 "qmljs.g" - case 343: Q_FALLTHROUGH(); -#line 2640 "qmljs.g" - case 344: Q_FALLTHROUGH(); -#line 2642 "qmljs.g" - case 345: Q_FALLTHROUGH(); -#line 2644 "qmljs.g" - case 346: Q_FALLTHROUGH(); -#line 2646 "qmljs.g" - case 347: Q_FALLTHROUGH(); -#line 2648 "qmljs.g" - case 348: Q_FALLTHROUGH(); -#line 2650 "qmljs.g" - case 349: Q_FALLTHROUGH(); -#line 2652 "qmljs.g" - case 350: Q_FALLTHROUGH(); -#line 2654 "qmljs.g" - case 351: Q_FALLTHROUGH(); -#line 2656 "qmljs.g" - case 352: Q_FALLTHROUGH(); -#line 2658 "qmljs.g" - case 353: Q_FALLTHROUGH(); -#line 2660 "qmljs.g" +#line 2807 "qmljs.g" + case 358: Q_FALLTHROUGH(); +#line 2809 "qmljs.g" + case 359: Q_FALLTHROUGH(); +#line 2811 "qmljs.g" + case 360: Q_FALLTHROUGH(); +#line 2813 "qmljs.g" + case 361: Q_FALLTHROUGH(); +#line 2815 "qmljs.g" + case 362: Q_FALLTHROUGH(); +#line 2817 "qmljs.g" + case 363: Q_FALLTHROUGH(); +#line 2819 "qmljs.g" + case 364: Q_FALLTHROUGH(); +#line 2821 "qmljs.g" + case 365: Q_FALLTHROUGH(); +#line 2823 "qmljs.g" + case 366: Q_FALLTHROUGH(); +#line 2825 "qmljs.g" + case 367: Q_FALLTHROUGH(); +#line 2827 "qmljs.g" + case 368: Q_FALLTHROUGH(); +#line 2829 "qmljs.g" + case 369: Q_FALLTHROUGH(); +#line 2831 "qmljs.g" - case 354: { + case 370: { sym(1).Node = sym(2).Node; } break; -#line 2682 "qmljs.g" +#line 2853 "qmljs.g" - case 365: { + case 381: { AST::Block *node = new (pool) AST::Block(sym(2).StatementList); node->lbraceToken = loc(1); node->rbraceToken = loc(3); sym(1).Node = node; } break; -#line 2694 "qmljs.g" +#line 2865 "qmljs.g" - case 367: { + case 383: { sym(1).StatementList = sym(1).StatementList->append(sym(2).StatementList); } break; -#line 2701 "qmljs.g" +#line 2872 "qmljs.g" - case 368: { + case 384: { sym(1).StatementList = new (pool) AST::StatementList(sym(1).Statement); } break; -#line 2709 "qmljs.g" +#line 2879 "qmljs.g" - case 370: { + case 385: { sym(1).Node = new (pool) AST::StatementList(sym(3).FunctionDeclaration); } break; -#line 2716 "qmljs.g" +#line 2886 "qmljs.g" - case 371: { + case 386: { sym(1).Node = nullptr; } break; -#line 2723 "qmljs.g" +#line 2893 "qmljs.g" - case 372: { + case 387: { sym(1).Node = sym(1).StatementList->finish(); } break; -#line 2730 "qmljs.g" +#line 2900 "qmljs.g" - case 373: { + case 388: { sym(1).scope = AST::VariableScope::Let; } break; -#line 2736 "qmljs.g" +#line 2906 "qmljs.g" - case 374: { + case 389: { sym(1).scope = AST::VariableScope::Const; } break; -#line 2743 "qmljs.g" +#line 2913 "qmljs.g" - case 375: { + case 390: { sym(1).scope = AST::VariableScope::Var; } break; -#line 2750 "qmljs.g" - case 376: Q_FALLTHROUGH(); -#line 2752 "qmljs.g" - case 377: Q_FALLTHROUGH(); -#line 2754 "qmljs.g" - case 378: Q_FALLTHROUGH(); -#line 2756 "qmljs.g" +#line 2920 "qmljs.g" + case 391: Q_FALLTHROUGH(); +#line 2922 "qmljs.g" + case 392: Q_FALLTHROUGH(); +#line 2924 "qmljs.g" + case 393: Q_FALLTHROUGH(); +#line 2926 "qmljs.g" - case 379: { - AST::VariableStatement *node = new (pool) AST::VariableStatement(sym(2).VariableDeclarationList->finish(sym(1).scope)); + case 394: { + AST::VariableDeclarationList *declarations = sym(2).VariableDeclarationList->finish(sym(1).scope); + for (auto it = declarations; it; it = it->next) { + if (it->declaration && it->declaration->typeAnnotation) { + syntaxError(it->declaration->typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in variable declarations"); + return false; + } + } + AST::VariableStatement *node = new (pool) AST::VariableStatement(declarations); node->declarationKindToken = loc(1); sym(1).Node = node; } break; -#line 2768 "qmljs.g" - case 382: Q_FALLTHROUGH(); -#line 2770 "qmljs.g" - case 383: Q_FALLTHROUGH(); -#line 2772 "qmljs.g" - case 384: Q_FALLTHROUGH(); -#line 2774 "qmljs.g" +#line 2944 "qmljs.g" + case 396: Q_FALLTHROUGH(); +#line 2946 "qmljs.g" + case 397: Q_FALLTHROUGH(); +#line 2948 "qmljs.g" + case 398: Q_FALLTHROUGH(); +#line 2950 "qmljs.g" - case 385: { + case 399: { sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).PatternElement); } break; -#line 2781 "qmljs.g" - case 386: Q_FALLTHROUGH(); -#line 2783 "qmljs.g" - case 387: Q_FALLTHROUGH(); -#line 2785 "qmljs.g" - case 388: Q_FALLTHROUGH(); -#line 2787 "qmljs.g" +#line 2957 "qmljs.g" + case 400: Q_FALLTHROUGH(); +#line 2959 "qmljs.g" + case 401: Q_FALLTHROUGH(); +#line 2961 "qmljs.g" + case 402: Q_FALLTHROUGH(); +#line 2963 "qmljs.g" - case 389: { + case 403: { AST::VariableDeclarationList *node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclarationList, sym(3).PatternElement); node->commaToken = loc(2); sym(1).Node = node; } break; -#line 2796 "qmljs.g" - case 390: Q_FALLTHROUGH(); -#line 2798 "qmljs.g" - case 391: Q_FALLTHROUGH(); -#line 2800 "qmljs.g" - case 392: Q_FALLTHROUGH(); -#line 2802 "qmljs.g" +#line 2972 "qmljs.g" + case 404: Q_FALLTHROUGH(); +#line 2974 "qmljs.g" + case 405: Q_FALLTHROUGH(); +#line 2976 "qmljs.g" + case 406: Q_FALLTHROUGH(); +#line 2978 "qmljs.g" - case 393: { - auto *node = new (pool) AST::PatternElement(stringRef(1), sym(2).Expression); + case 407: { + auto *node = new (pool) AST::PatternElement(stringRef(1), sym(2).TypeAnnotation, sym(3).Expression); node->identifierToken = loc(1); sym(1).Node = node; // if initializer is an anonymous function expression, we need to assign identifierref as it's name - if (auto *f = asAnonymousFunctionDefinition(sym(2).Expression)) + if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression)) f->name = stringRef(1); - if (auto *c = asAnonymousClassDefinition(sym(2).Expression)) + if (auto *c = asAnonymousClassDefinition(sym(3).Expression)) c->name = stringRef(1); } break; -#line 2816 "qmljs.g" - case 394: Q_FALLTHROUGH(); -#line 2818 "qmljs.g" - case 395: Q_FALLTHROUGH(); -#line 2820 "qmljs.g" - case 396: Q_FALLTHROUGH(); -#line 2822 "qmljs.g" +#line 2992 "qmljs.g" + case 408: Q_FALLTHROUGH(); +#line 2994 "qmljs.g" + case 409: Q_FALLTHROUGH(); +#line 2996 "qmljs.g" + case 410: Q_FALLTHROUGH(); +#line 2998 "qmljs.g" - case 397: { + case 411: { auto *node = new (pool) AST::PatternElement(sym(1).Pattern, sym(2).Expression); node->identifierToken = loc(1); sym(1).Node = node; } break; -#line 2831 "qmljs.g" +#line 3007 "qmljs.g" - case 398: { + case 412: { auto *node = new (pool) AST::ObjectPattern(sym(2).PatternPropertyList); node->lbraceToken = loc(1); node->rbraceToken = loc(3); @@ -2023,9 +2145,9 @@ case 205: { sym(1).Node = node; } break; -#line 2842 "qmljs.g" +#line 3018 "qmljs.g" - case 399: { + case 413: { auto *node = new (pool) AST::ArrayPattern(sym(2).PatternElementList); node->lbracketToken = loc(1); node->rbracketToken = loc(3); @@ -2033,23 +2155,23 @@ case 205: { sym(1).Node = node; } break; -#line 2853 "qmljs.g" +#line 3029 "qmljs.g" - case 400: { + case 414: { sym(1).Node = nullptr; } break; -#line 2860 "qmljs.g" - case 401: -#line 2862 "qmljs.g" +#line 3036 "qmljs.g" + case 415: +#line 3038 "qmljs.g" - case 402: { + case 416: { sym(1).Node = sym(1).PatternPropertyList->finish(); } break; -#line 2869 "qmljs.g" +#line 3045 "qmljs.g" - case 403: { + case 417: { if (sym(1).Elision || sym(2).Node) { auto *l = new (pool) AST::PatternElementList(sym(1).Elision, sym(2).PatternElement); sym(1).Node = l->finish(); @@ -2058,15 +2180,15 @@ case 205: { } } break; -#line 2881 "qmljs.g" +#line 3057 "qmljs.g" - case 404: { + case 418: { sym(1).Node = sym(1).PatternElementList->finish(); } break; -#line 2888 "qmljs.g" +#line 3064 "qmljs.g" - case 405: { + case 419: { if (sym(3).Elision || sym(4).Node) { auto *l = new (pool) AST::PatternElementList(sym(3).Elision, sym(4).PatternElement); l = sym(1).PatternElementList->append(l); @@ -2075,33 +2197,33 @@ case 205: { sym(1).Node = sym(1).PatternElementList->finish(); } break; -#line 2900 "qmljs.g" +#line 3076 "qmljs.g" - case 406: { + case 420: { sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternProperty); } break; -#line 2907 "qmljs.g" +#line 3083 "qmljs.g" - case 407: { + case 421: { sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternPropertyList, sym(3).PatternProperty); } break; -#line 2916 "qmljs.g" +#line 3092 "qmljs.g" - case 409: { + case 423: { sym(1).PatternElementList = sym(1).PatternElementList->append(sym(3).PatternElementList); } break; -#line 2923 "qmljs.g" +#line 3099 "qmljs.g" - case 410: { + case 424: { sym(1).Node = new (pool) AST::PatternElementList(sym(1).Elision, sym(2).PatternElement); } break; -#line 2931 "qmljs.g" +#line 3107 "qmljs.g" - case 411: { + case 425: { AST::StringLiteralPropertyName *name = new (pool) AST::StringLiteralPropertyName(stringRef(1)); name->propertyNameToken = loc(1); // if initializer is an anonymous function expression, we need to assign identifierref as it's name @@ -2112,90 +2234,90 @@ case 205: { sym(1).Node = new (pool) AST::PatternProperty(name, stringRef(1), sym(2).Expression); } break; -#line 2945 "qmljs.g" +#line 3121 "qmljs.g" - case 412: { + case 426: { AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, stringRef(3), sym(4).Expression); sym(1).Node = node; } break; -#line 2953 "qmljs.g" +#line 3129 "qmljs.g" - case 413: { + case 427: { AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, sym(3).Pattern, sym(4).Expression); sym(1).Node = node; } break; -#line 2961 "qmljs.g" +#line 3137 "qmljs.g" - case 414: { - AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1), sym(2).Expression); + case 428: { + AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1), sym(2).TypeAnnotation, sym(3).Expression); node->identifierToken = loc(1); // if initializer is an anonymous function expression, we need to assign identifierref as it's name - if (auto *f = asAnonymousFunctionDefinition(sym(2).Expression)) + if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression)) f->name = stringRef(1); - if (auto *c = asAnonymousClassDefinition(sym(2).Expression)) + if (auto *c = asAnonymousClassDefinition(sym(3).Expression)) c->name = stringRef(1); sym(1).Node = node; } break; -#line 2975 "qmljs.g" +#line 3151 "qmljs.g" - case 415: { + case 429: { AST::PatternElement *node = new (pool) AST::PatternElement(sym(1).Pattern, sym(2).Expression); sym(1).Node = node; } break; -#line 2983 "qmljs.g" +#line 3159 "qmljs.g" - case 416: { - AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(2), nullptr, AST::PatternElement::RestElement); + case 430: { + AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(2), /*type annotation*/nullptr, nullptr, AST::PatternElement::RestElement); node->identifierToken = loc(2); sym(1).Node = node; } break; -#line 2992 "qmljs.g" +#line 3168 "qmljs.g" - case 417: { + case 431: { AST::PatternElement *node = new (pool) AST::PatternElement(sym(2).Pattern, nullptr, AST::PatternElement::RestElement); sym(1).Node = node; } break; -#line 3000 "qmljs.g" +#line 3176 "qmljs.g" - case 418: { + case 432: { sym(1).Node = nullptr; } break; -#line 3010 "qmljs.g" +#line 3186 "qmljs.g" - case 420: { + case 434: { AST::EmptyStatement *node = new (pool) AST::EmptyStatement(); node->semicolonToken = loc(1); sym(1).Node = node; } break; -#line 3025 "qmljs.g" +#line 3201 "qmljs.g" - case 421: { + case 435: { int token = lookaheadToken(lexer); if (token == T_LBRACE) pushToken(T_FORCE_BLOCK); - else if (token == T_FUNCTION || token == T_CLASS || token == T_LET || token == T_CONST) + else if (token == T_FUNCTION || token == T_FUNCTION_STAR || token == T_CLASS || token == T_LET || token == T_CONST) pushToken(T_FORCE_DECLARATION); } break; -#line 3037 "qmljs.g" +#line 3212 "qmljs.g" - case 423: { + case 436: { AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(sym(1).Expression); node->semicolonToken = loc(2); sym(1).Node = node; } break; -#line 3046 "qmljs.g" +#line 3221 "qmljs.g" - case 424: { + case 437: { AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement, sym(7).Statement); node->ifToken = loc(1); node->lparenToken = loc(2); @@ -2204,9 +2326,9 @@ case 205: { sym(1).Node = node; } break; -#line 3058 "qmljs.g" +#line 3233 "qmljs.g" - case 425: { + case 438: { AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement); node->ifToken = loc(1); node->lparenToken = loc(2); @@ -2214,9 +2336,9 @@ case 205: { sym(1).Node = node; } break; -#line 3072 "qmljs.g" +#line 3246 "qmljs.g" - case 428: { + case 440: { AST::DoWhileStatement *node = new (pool) AST::DoWhileStatement(sym(2).Statement, sym(5).Expression); node->doToken = loc(1); node->whileToken = loc(3); @@ -2226,9 +2348,9 @@ case 205: { sym(1).Node = node; } break; -#line 3085 "qmljs.g" +#line 3259 "qmljs.g" - case 429: { + case 441: { AST::WhileStatement *node = new (pool) AST::WhileStatement(sym(3).Expression, sym(5).Statement); node->whileToken = loc(1); node->lparenToken = loc(2); @@ -2236,9 +2358,9 @@ case 205: { sym(1).Node = node; } break; -#line 3096 "qmljs.g" +#line 3270 "qmljs.g" - case 430: { + case 442: { AST::ForStatement *node = new (pool) AST::ForStatement(sym(3).Expression, sym(5).Expression, sym(7).Expression, sym(9).Statement); node->forToken = loc(1); node->lparenToken = loc(2); @@ -2248,11 +2370,11 @@ case 205: { sym(1).Node = node; } break; -#line 3109 "qmljs.g" - case 431: Q_FALLTHROUGH(); -#line 3111 "qmljs.g" +#line 3283 "qmljs.g" + case 443: Q_FALLTHROUGH(); +#line 3285 "qmljs.g" - case 432: { + case 444: { // ### get rid of the static_cast! AST::ForStatement *node = new (pool) AST::ForStatement( static_cast(sym(3).Node)->declarations, sym(5).Expression, @@ -2265,21 +2387,21 @@ case 205: { sym(1).Node = node; } break; -#line 3127 "qmljs.g" +#line 3301 "qmljs.g" - case 433: { + case 445: { sym(1).forEachType = AST::ForEachType::In; } break; -#line 3134 "qmljs.g" +#line 3308 "qmljs.g" - case 434: { + case 446: { sym(1).forEachType = AST::ForEachType::Of; } break; -#line 3141 "qmljs.g" +#line 3315 "qmljs.g" - case 435: { + case 447: { // need to convert the LHS to an AssignmentPattern if it was an Array/ObjectLiteral if (AST::Pattern *p = sym(3).Expression->patternCast()) { AST::SourceLocation errorLoc; @@ -2298,9 +2420,9 @@ case 205: { sym(1).Node = node; } break; -#line 3163 "qmljs.g" +#line 3337 "qmljs.g" - case 436: { + case 448: { AST::ForEachStatement *node = new (pool) AST::ForEachStatement(sym(3).PatternElement, sym(5).Expression, sym(7).Statement); node->forToken = loc(1); node->lparenToken = loc(2); @@ -2310,41 +2432,45 @@ case 205: { sym(1).Node = node; } break; -#line 3176 "qmljs.g" - case 437: Q_FALLTHROUGH(); -#line 3178 "qmljs.g" +#line 3350 "qmljs.g" + case 449: Q_FALLTHROUGH(); +#line 3352 "qmljs.g" - case 438: { - auto *node = new (pool) AST::PatternElement(stringRef(2), nullptr); + case 450: { + if (auto typeAnnotation = sym(3).TypeAnnotation) { + syntaxError(typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in variable declarations"); + return false; + } + auto *node = new (pool) AST::PatternElement(stringRef(2), sym(3).TypeAnnotation, nullptr); node->identifierToken = loc(2); node->scope = sym(1).scope; node->isForDeclaration = true; sym(1).Node = node; } break; -#line 3189 "qmljs.g" - case 439: Q_FALLTHROUGH(); -#line 3191 "qmljs.g" +#line 3367 "qmljs.g" + case 451: Q_FALLTHROUGH(); +#line 3369 "qmljs.g" - case 440: { + case 452: { auto *node = new (pool) AST::PatternElement(sym(2).Pattern, nullptr); node->scope = sym(1).scope; node->isForDeclaration = true; sym(1).Node = node; } break; -#line 3202 "qmljs.g" +#line 3379 "qmljs.g" - case 442: { + case 453: { AST::ContinueStatement *node = new (pool) AST::ContinueStatement(); node->continueToken = loc(1); node->semicolonToken = loc(2); sym(1).Node = node; } break; -#line 3213 "qmljs.g" +#line 3389 "qmljs.g" - case 444: { + case 454: { AST::ContinueStatement *node = new (pool) AST::ContinueStatement(stringRef(2)); node->continueToken = loc(1); node->identifierToken = loc(2); @@ -2352,18 +2478,18 @@ case 205: { sym(1).Node = node; } break; -#line 3225 "qmljs.g" +#line 3400 "qmljs.g" - case 446: { + case 455: { AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef()); node->breakToken = loc(1); node->semicolonToken = loc(2); sym(1).Node = node; } break; -#line 3236 "qmljs.g" +#line 3410 "qmljs.g" - case 448: { + case 456: { AST::BreakStatement *node = new (pool) AST::BreakStatement(stringRef(2)); node->breakToken = loc(1); node->identifierToken = loc(2); @@ -2371,9 +2497,9 @@ case 205: { sym(1).Node = node; } break; -#line 3248 "qmljs.g" +#line 3421 "qmljs.g" - case 450: { + case 457: { if (!functionNestingLevel) { syntaxError(loc(1), "Return statement not allowed outside of Function declaration."); return false; @@ -2384,9 +2510,9 @@ case 205: { sym(1).Node = node; } break; -#line 3262 "qmljs.g" +#line 3435 "qmljs.g" - case 451: { + case 458: { AST::WithStatement *node = new (pool) AST::WithStatement(sym(3).Expression, sym(5).Statement); node->withToken = loc(1); node->lparenToken = loc(2); @@ -2394,9 +2520,9 @@ case 205: { sym(1).Node = node; } break; -#line 3273 "qmljs.g" +#line 3446 "qmljs.g" - case 452: { + case 459: { AST::SwitchStatement *node = new (pool) AST::SwitchStatement(sym(3).Expression, sym(5).CaseBlock); node->switchToken = loc(1); node->lparenToken = loc(2); @@ -2404,118 +2530,118 @@ case 205: { sym(1).Node = node; } break; -#line 3284 "qmljs.g" +#line 3457 "qmljs.g" - case 453: { + case 460: { AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses); node->lbraceToken = loc(1); node->rbraceToken = loc(3); sym(1).Node = node; } break; -#line 3294 "qmljs.g" +#line 3467 "qmljs.g" - case 454: { + case 461: { AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses); node->lbraceToken = loc(1); node->rbraceToken = loc(5); sym(1).Node = node; } break; -#line 3304 "qmljs.g" +#line 3477 "qmljs.g" - case 455: { + case 462: { sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClause); } break; -#line 3311 "qmljs.g" +#line 3484 "qmljs.g" - case 456: { + case 463: { sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClauses, sym(2).CaseClause); } break; -#line 3318 "qmljs.g" +#line 3491 "qmljs.g" - case 457: { + case 464: { sym(1).Node = nullptr; } break; -#line 3325 "qmljs.g" +#line 3498 "qmljs.g" - case 458: { + case 465: { sym(1).Node = sym(1).CaseClauses->finish(); } break; -#line 3332 "qmljs.g" +#line 3505 "qmljs.g" - case 459: { + case 466: { AST::CaseClause *node = new (pool) AST::CaseClause(sym(2).Expression, sym(4).StatementList); node->caseToken = loc(1); node->colonToken = loc(3); sym(1).Node = node; } break; -#line 3342 "qmljs.g" +#line 3515 "qmljs.g" - case 460: { + case 467: { AST::DefaultClause *node = new (pool) AST::DefaultClause(sym(3).StatementList); node->defaultToken = loc(1); node->colonToken = loc(2); sym(1).Node = node; } break; -#line 3352 "qmljs.g" +#line 3525 "qmljs.g" - case 461: { + case 468: { AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement); node->identifierToken = loc(1); node->colonToken = loc(2); sym(1).Node = node; } break; -#line 3364 "qmljs.g" +#line 3537 "qmljs.g" - case 463: { + case 470: { syntaxError(loc(3), "FunctionDeclarations are not allowed after a label."); return false; } break; -#line 3373 "qmljs.g" +#line 3545 "qmljs.g" - case 465: { + case 471: { AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression); node->throwToken = loc(1); node->semicolonToken = loc(3); sym(1).Node = node; } break; -#line 3383 "qmljs.g" +#line 3555 "qmljs.g" - case 466: { + case 472: { AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch); node->tryToken = loc(1); sym(1).Node = node; } break; -#line 3392 "qmljs.g" +#line 3564 "qmljs.g" - case 467: { + case 473: { AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Finally); node->tryToken = loc(1); sym(1).Node = node; } break; -#line 3401 "qmljs.g" +#line 3573 "qmljs.g" - case 468: { + case 474: { AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch, sym(4).Finally); node->tryToken = loc(1); sym(1).Node = node; } break; -#line 3410 "qmljs.g" +#line 3582 "qmljs.g" - case 469: { + case 475: { AST::Catch *node = new (pool) AST::Catch(sym(3).PatternElement, sym(5).Block); node->catchToken = loc(1); node->lparenToken = loc(2); @@ -2524,150 +2650,176 @@ case 205: { sym(1).Node = node; } break; -#line 3422 "qmljs.g" +#line 3594 "qmljs.g" - case 470: { + case 476: { AST::Finally *node = new (pool) AST::Finally(sym(2).Block); node->finallyToken = loc(1); sym(1).Node = node; } break; -#line 3431 "qmljs.g" +#line 3603 "qmljs.g" - case 471: { + case 477: { AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1)); node->identifierToken = loc(1); node->scope = AST::VariableScope::Let; sym(1).Node = node; } break; -#line 3441 "qmljs.g" +#line 3613 "qmljs.g" - case 472: { + case 478: { AST::PatternElement *node = new (pool) AST::PatternElement(sym(1).Pattern); node->scope = AST::VariableScope::Let; sym(1).Node = node; } break; -#line 3451 "qmljs.g" +#line 3622 "qmljs.g" - case 474: { + case 479: { AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement(); node->debuggerToken = loc(1); node->semicolonToken = loc(2); sym(1).Node = node; } break; -#line 3468 "qmljs.g" +#line 3639 "qmljs.g" - case 476: { - AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + case 481: { + if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList)) + return false; + AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList, + /*type annotation*/nullptr); node->functionToken = loc(1); node->identifierToken = loc(2); node->lparenToken = loc(3); node->rparenToken = loc(5); + node->lbraceToken = loc(7); + node->rbraceToken = loc(9); + sym(1).Node = node; + } break; + +#line 3656 "qmljs.g" + + case 482: { + AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList, + sym(6).TypeAnnotation); + node->functionToken = loc(1); + node->identifierToken = loc(2); + node->lparenToken = loc(3); + node->rparenToken = loc(5); + node->lbraceToken = loc(7); + node->rbraceToken = loc(9); + sym(1).Node = node; + } break; + +#line 3672 "qmljs.g" + + case 484: { + if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList)) + return false; + AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(3).FormalParameterList, sym(7).StatementList, + /*type annotation*/nullptr); + node->functionToken = loc(1); + node->lparenToken = loc(2); + node->rparenToken = loc(4); node->lbraceToken = loc(6); node->rbraceToken = loc(8); sym(1).Node = node; } break; -#line 3484 "qmljs.g" +#line 3688 "qmljs.g" - case 478: { - AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList); - node->functionToken = loc(1); - node->lparenToken = loc(2); - node->rparenToken = loc(4); - node->lbraceToken = loc(5); - node->rbraceToken = loc(7); - sym(1).Node = node; - } break; - -#line 3497 "qmljs.g" - - case 479: { - AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + case 485: { + if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList)) + return false; + AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList, + /*type annotation*/nullptr); node->functionToken = loc(1); if (! stringRef(2).isNull()) node->identifierToken = loc(2); node->lparenToken = loc(3); node->rparenToken = loc(5); + node->lbraceToken = loc(7); + node->rbraceToken = loc(9); + sym(1).Node = node; + } break; + +#line 3706 "qmljs.g" + + case 486: { + if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList)) + return false; + AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(7).StatementList, + /*type annotation*/nullptr); + node->functionToken = loc(1); + node->lparenToken = loc(2); + node->rparenToken = loc(4); node->lbraceToken = loc(6); node->rbraceToken = loc(8); sym(1).Node = node; } break; -#line 3512 "qmljs.g" +#line 3724 "qmljs.g" - case 480: { - AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList); - node->functionToken = loc(1); - node->lparenToken = loc(2); - node->rparenToken = loc(4); - node->lbraceToken = loc(5); - node->rbraceToken = loc(7); - sym(1).Node = node; - } break; - -#line 3527 "qmljs.g" - - case 482: { + case 488: { sym(1).Node = nullptr; } break; -#line 3534 "qmljs.g" +#line 3731 "qmljs.g" - case 483: { + case 489: { AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement))->finish(pool); sym(1).Node = node; } break; -#line 3542 "qmljs.g" - case 484: -#line 3544 "qmljs.g" +#line 3739 "qmljs.g" + case 490: +#line 3741 "qmljs.g" - case 485: { + case 491: { sym(1).Node = sym(1).FormalParameterList->finish(pool); } break; -#line 3551 "qmljs.g" +#line 3748 "qmljs.g" - case 486: { + case 492: { AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(sym(1).FormalParameterList, sym(3).PatternElement))->finish(pool); sym(1).Node = node; } break; -#line 3559 "qmljs.g" +#line 3756 "qmljs.g" - case 487: { + case 493: { AST::FormalParameterList *node = new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement); sym(1).Node = node; } break; -#line 3568 "qmljs.g" +#line 3765 "qmljs.g" - case 488: { + case 494: { AST::FormalParameterList *node = new (pool) AST::FormalParameterList(sym(1).FormalParameterList, sym(3).PatternElement); sym(1).Node = node; } break; -#line 3578 "qmljs.g" +#line 3775 "qmljs.g" - case 490: { + case 496: { ++functionNestingLevel; } break; -#line 3585 "qmljs.g" +#line 3782 "qmljs.g" - case 491: { + case 497: { --functionNestingLevel; } break; -#line 3595 "qmljs.g" - case 493: Q_FALLTHROUGH(); -#line 3597 "qmljs.g" +#line 3792 "qmljs.g" + case 499: Q_FALLTHROUGH(); +#line 3794 "qmljs.g" - case 494: { + case 500: { AST::ReturnStatement *ret = new (pool) AST::ReturnStatement(sym(4).Expression); ret->returnToken = sym(4).Node->firstSourceLocation(); ret->semicolonToken = sym(4).Node->lastSourceLocation(); @@ -2680,11 +2832,11 @@ case 205: { sym(1).Node = f; } break; -#line 3613 "qmljs.g" - case 495: Q_FALLTHROUGH(); -#line 3615 "qmljs.g" +#line 3810 "qmljs.g" + case 501: Q_FALLTHROUGH(); +#line 3812 "qmljs.g" - case 496: { + case 502: { AST::FunctionExpression *f = new (pool) AST::FunctionExpression(QStringRef(), sym(1).FormalParameterList, sym(6).StatementList); f->isArrowFunction = true; f->functionToken = sym(1).Node ? sym(1).Node->firstSourceLocation() : loc(1); @@ -2693,17 +2845,17 @@ case 205: { sym(1).Node = f; } break; -#line 3627 "qmljs.g" +#line 3824 "qmljs.g" - case 497: { - AST::PatternElement *e = new (pool) AST::PatternElement(stringRef(1), nullptr, AST::PatternElement::Binding); + case 503: { + AST::PatternElement *e = new (pool) AST::PatternElement(stringRef(1), /*type annotation*/nullptr, nullptr, AST::PatternElement::Binding); e->identifierToken = loc(1); sym(1).FormalParameterList = (new (pool) AST::FormalParameterList(nullptr, e))->finish(pool); } break; -#line 3638 "qmljs.g" +#line 3835 "qmljs.g" - case 498: { + case 504: { if (coverExpressionType != CE_FormalParameterList) { AST::NestedExpression *ne = static_cast(sym(1).Node); AST::FormalParameterList *list = ne->expression->reparseAsFormalParameterList(pool); @@ -2715,179 +2867,187 @@ case 205: { } } break; -#line 3656 "qmljs.g" +#line 3853 "qmljs.g" - case 499: { + case 505: { if (lookaheadToken(lexer) == T_LBRACE) pushToken(T_FORCE_BLOCK); } break; -#line 3664 "qmljs.g" +#line 3861 "qmljs.g" - case 500: { - AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(1), sym(3).FormalParameterList, sym(6).StatementList); + case 506: { + if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList)) + return false; + AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(1), sym(3).FormalParameterList, sym(7).StatementList); f->functionToken = sym(1).PropertyName->firstSourceLocation(); f->lparenToken = loc(2); f->rparenToken = loc(4); - f->lbraceToken = loc(5); - f->rbraceToken = loc(7); - AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, f); + f->lbraceToken = loc(6); + f->rbraceToken = loc(8); + AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, f, AST::PatternProperty::Method); node->colonToken = loc(2); sym(1).Node = node; } break; -#line 3679 "qmljs.g" +#line 3878 "qmljs.g" - case 501: { - AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + case 507: { + if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList)) + return false; + AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList); f->functionToken = sym(2).PropertyName->firstSourceLocation(); f->lparenToken = loc(3); f->rparenToken = loc(5); - f->lbraceToken = loc(6); - f->rbraceToken = loc(8); + f->lbraceToken = loc(7); + f->rbraceToken = loc(9); f->isGenerator = true; - AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f); + AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Method); node->colonToken = loc(2); sym(1).Node = node; } break; -#line 3696 "qmljs.g" +#line 3897 "qmljs.g" - case 502: { - AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), nullptr, sym(6).StatementList); + case 508: { + if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, /*formals*/nullptr)) + return false; + AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), nullptr, sym(7).StatementList); f->functionToken = sym(2).PropertyName->firstSourceLocation(); f->lparenToken = loc(3); f->rparenToken = loc(4); - f->lbraceToken = loc(5); - f->rbraceToken = loc(7); + f->lbraceToken = loc(6); + f->rbraceToken = loc(8); AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Getter); node->colonToken = loc(2); sym(1).Node = node; } break; -#line 3711 "qmljs.g" +#line 3914 "qmljs.g" - case 503: { - AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + case 509: { + if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList)) + return false; + AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList); f->functionToken = sym(2).PropertyName->firstSourceLocation(); f->lparenToken = loc(3); f->rparenToken = loc(5); - f->lbraceToken = loc(6); - f->rbraceToken = loc(8); + f->lbraceToken = loc(7); + f->rbraceToken = loc(9); AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Setter); node->colonToken = loc(2); sym(1).Node = node; } break; -#line 3727 "qmljs.g" +#line 3932 "qmljs.g" - case 504: { + case 510: { AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement))->finish(pool); sym(1).Node = node; } break; -#line 3735 "qmljs.g" +#line 3940 "qmljs.g" - case 505: { + case 511: { lexer->enterGeneratorBody(); } break; -#line 3742 "qmljs.g" +#line 3947 "qmljs.g" - case 506: { + case 512: { --functionNestingLevel; lexer->leaveGeneratorBody(); } break; -#line 3750 "qmljs.g" - - case 507: { - AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(3), sym(5).FormalParameterList, sym(8).StatementList); - node->functionToken = loc(1); - node->identifierToken = loc(3); - node->lparenToken = loc(4); - node->rparenToken = loc(6); - node->lbraceToken = loc(7); - node->rbraceToken = loc(9); - node->isGenerator = true; - sym(1).Node = node; - } break; - -#line 3766 "qmljs.g" - - case 509: { - AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(4).FormalParameterList, sym(7).StatementList); - node->functionToken = loc(1); - node->lparenToken = loc(3); - node->rparenToken = loc(5); - node->lbraceToken = loc(6); - node->rbraceToken = loc(8); - node->isGenerator = true; - sym(1).Node = node; - } break; - -#line 3780 "qmljs.g" - - case 510: { - AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(3), sym(5).FormalParameterList, sym(8).StatementList); - node->functionToken = loc(1); - if (!stringRef(3).isNull()) - node->identifierToken = loc(3); - node->lparenToken = loc(4); - node->rparenToken = loc(6); - node->lbraceToken = loc(7); - node->rbraceToken = loc(9); - node->isGenerator = true; - sym(1).Node = node; - } break; - -#line 3796 "qmljs.g" - - case 511: { - AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(4).FormalParameterList, sym(7).StatementList); - node->functionToken = loc(1); - node->lparenToken = loc(3); - node->rparenToken = loc(5); - node->lbraceToken = loc(6); - node->rbraceToken = loc(8); - node->isGenerator = true; - sym(1).Node = node; - } break; - -#line 3812 "qmljs.g" - case 513: Q_FALLTHROUGH(); -#line 3814 "qmljs.g" +#line 3957 "qmljs.g" case 514: { + AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + node->functionToken = loc(1); + node->identifierToken = loc(2); + node->lparenToken = loc(3); + node->rparenToken = loc(5); + node->lbraceToken = loc(6); + node->rbraceToken = loc(8); + node->isGenerator = true; + sym(1).Node = node; + } break; + +#line 3973 "qmljs.g" + + case 516: { + AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList); + node->functionToken = loc(1); + node->lparenToken = loc(2); + node->rparenToken = loc(4); + node->lbraceToken = loc(5); + node->rbraceToken = loc(7); + node->isGenerator = true; + sym(1).Node = node; + } break; + +#line 3987 "qmljs.g" + + case 517: { + AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList); + node->functionToken = loc(1); + if (!stringRef(2).isNull()) + node->identifierToken = loc(2); + node->lparenToken = loc(3); + node->rparenToken = loc(5); + node->lbraceToken = loc(6); + node->rbraceToken = loc(8); + node->isGenerator = true; + sym(1).Node = node; + } break; + +#line 4003 "qmljs.g" + + case 518: { + AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList); + node->functionToken = loc(1); + node->lparenToken = loc(2); + node->rparenToken = loc(4); + node->lbraceToken = loc(5); + node->rbraceToken = loc(7); + node->isGenerator = true; + sym(1).Node = node; + } break; + +#line 4019 "qmljs.g" + case 520: Q_FALLTHROUGH(); +#line 4021 "qmljs.g" + + case 521: { AST::YieldExpression *node = new (pool) AST::YieldExpression(); node->yieldToken = loc(1); sym(1).Node = node; } break; -#line 3823 "qmljs.g" - case 515: Q_FALLTHROUGH(); -#line 3825 "qmljs.g" +#line 4030 "qmljs.g" + case 522: Q_FALLTHROUGH(); +#line 4032 "qmljs.g" - case 516: { + case 523: { AST::YieldExpression *node = new (pool) AST::YieldExpression(sym(3).Expression); node->yieldToken = loc(1); node->isYieldStar = true; sym(1).Node = node; } break; -#line 3835 "qmljs.g" - case 517: Q_FALLTHROUGH(); -#line 3837 "qmljs.g" +#line 4042 "qmljs.g" + case 524: Q_FALLTHROUGH(); +#line 4044 "qmljs.g" - case 518: { + case 525: { AST::YieldExpression *node = new (pool) AST::YieldExpression(sym(2).Expression); node->yieldToken = loc(1); sym(1).Node = node; } break; -#line 3847 "qmljs.g" +#line 4054 "qmljs.g" - case 519: { + case 526: { AST::ClassDeclaration *node = new (pool) AST::ClassDeclaration(stringRef(2), sym(3).Expression, sym(5).ClassElementList); node->classToken = loc(1); node->identifierToken = loc(2); @@ -2896,9 +3056,9 @@ case 205: { sym(1).Node = node; } break; -#line 3859 "qmljs.g" +#line 4066 "qmljs.g" - case 520: { + case 527: { AST::ClassExpression *node = new (pool) AST::ClassExpression(stringRef(2), sym(3).Expression, sym(5).ClassElementList); node->classToken = loc(1); node->identifierToken = loc(2); @@ -2907,9 +3067,9 @@ case 205: { sym(1).Node = node; } break; -#line 3871 "qmljs.g" +#line 4078 "qmljs.g" - case 521: { + case 528: { AST::ClassDeclaration *node = new (pool) AST::ClassDeclaration(QStringRef(), sym(2).Expression, sym(4).ClassElementList); node->classToken = loc(1); node->lbraceToken = loc(3); @@ -2917,9 +3077,9 @@ case 205: { sym(1).Node = node; } break; -#line 3882 "qmljs.g" +#line 4089 "qmljs.g" - case 522: { + case 529: { AST::ClassExpression *node = new (pool) AST::ClassExpression(QStringRef(), sym(2).Expression, sym(4).ClassElementList); node->classToken = loc(1); node->lbraceToken = loc(3); @@ -2927,296 +3087,296 @@ case 205: { sym(1).Node = node; } break; -#line 3895 "qmljs.g" +#line 4102 "qmljs.g" - case 524: { + case 531: { lexer->setStaticIsKeyword(true); } break; -#line 3902 "qmljs.g" - case 525: -#line 3904 "qmljs.g" +#line 4109 "qmljs.g" + case 532: +#line 4111 "qmljs.g" - case 526: { + case 533: { lexer->setStaticIsKeyword(false); } break; -#line 3911 "qmljs.g" +#line 4118 "qmljs.g" - case 527: { + case 534: { sym(1).Node = nullptr; } break; -#line 3918 "qmljs.g" +#line 4125 "qmljs.g" - case 528: { + case 535: { sym(1).Node = sym(2).Node; } break; -#line 3925 "qmljs.g" - - case 529: { - sym(1).Node = nullptr; - } break; - -#line 3932 "qmljs.g" - - case 530: { - if (sym(1).Node) - sym(1).Node = sym(1).ClassElementList->finish(); - } break; - -#line 3942 "qmljs.g" - - case 532: { - if (sym(2).Node) - sym(1).ClassElementList = sym(1).ClassElementList->append(sym(2).ClassElementList); - } break; - -#line 3950 "qmljs.g" - - case 533: { - AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(1).PatternProperty, false); - sym(1).Node = node; - } break; - -#line 3958 "qmljs.g" - - case 534: { - lexer->setStaticIsKeyword(true); - AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(2).PatternProperty, true); - sym(1).Node = node; - } break; - -#line 3967 "qmljs.g" - - case 535: { - sym(1).Node = nullptr; - } break; - -#line 3976 "qmljs.g" +#line 4132 "qmljs.g" case 536: { sym(1).Node = nullptr; } break; -#line 3985 "qmljs.g" +#line 4139 "qmljs.g" - case 538: { + case 537: { + if (sym(1).Node) + sym(1).Node = sym(1).ClassElementList->finish(); + } break; + +#line 4149 "qmljs.g" + + case 539: { + if (sym(1).Node) { + if (sym(2).Node) + sym(1).ClassElementList = sym(1).ClassElementList->append(sym(2).ClassElementList); + } else if (sym(2).Node) { + sym(1).Node = sym(2).Node; + } + } break; + +#line 4161 "qmljs.g" + + case 540: { + AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(1).PatternProperty, false); + sym(1).Node = node; + } break; + +#line 4169 "qmljs.g" + + case 541: { + lexer->setStaticIsKeyword(true); + AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(2).PatternProperty, true); + sym(1).Node = node; + } break; + +#line 4178 "qmljs.g" + + case 542: { + sym(1).Node = nullptr; + } break; + +#line 4187 "qmljs.g" + + case 543: { + sym(1).Node = nullptr; + } break; + +#line 4196 "qmljs.g" + + case 545: { sym(1).Node = new (pool) AST::Program(sym(1).StatementList->finish()); } break; -#line 3992 "qmljs.g" - case 539: { +#line 4203 "qmljs.g" + case 546: { sym(1).Node = new (pool) AST::ESModule(sym(1).StatementList); } break; -#line 3998 "qmljs.g" +#line 4209 "qmljs.g" - case 540: { + case 547: { sym(1).StatementList = sym(1).StatementList->finish(); } break; -#line 4005 "qmljs.g" +#line 4216 "qmljs.g" - case 541: { + case 548: { sym(1).StatementList = nullptr; } break; -#line 4015 "qmljs.g" +#line 4226 "qmljs.g" - case 544: { + case 551: { sym(1).StatementList = sym(1).StatementList->append(sym(2).StatementList); } break; -#line 4022 "qmljs.g" - case 545: Q_FALLTHROUGH(); -#line 4024 "qmljs.g" - case 546: Q_FALLTHROUGH(); -#line 4026 "qmljs.g" - case 547: Q_FALLTHROUGH(); -#line 4028 "qmljs.g" +#line 4234 "qmljs.g" + case 552: Q_FALLTHROUGH(); +#line 4236 "qmljs.g" - case 548: { + case 553: { sym(1).StatementList = new (pool) AST::StatementList(sym(1).Node); } break; -#line 4037 "qmljs.g" +#line 4245 "qmljs.g" - case 550: { + case 555: { auto decl = new (pool) AST::ImportDeclaration(sym(2).ImportClause, sym(3).FromClause); decl->importToken = loc(1); sym(1).Node = decl; } break; -#line 4045 "qmljs.g" +#line 4253 "qmljs.g" - case 551: { + case 556: { auto decl = new (pool) AST::ImportDeclaration(stringRef(2)); decl->importToken = loc(1); decl->moduleSpecifierToken = loc(2); sym(1).Node = decl; } break; -#line 4055 "qmljs.g" +#line 4263 "qmljs.g" - case 552: { + case 557: { auto clause = new (pool) AST::ImportClause(stringRef(1)); clause->importedDefaultBindingToken = loc(1); sym(1).ImportClause = clause; } break; -#line 4063 "qmljs.g" +#line 4271 "qmljs.g" - case 553: { + case 558: { sym(1).ImportClause = new (pool) AST::ImportClause(sym(1).NameSpaceImport); } break; -#line 4069 "qmljs.g" +#line 4277 "qmljs.g" - case 554: { + case 559: { sym(1).ImportClause = new (pool) AST::ImportClause(sym(1).NamedImports); } break; -#line 4075 "qmljs.g" +#line 4283 "qmljs.g" - case 555: { + case 560: { auto importClause = new (pool) AST::ImportClause(stringRef(1), sym(3).NameSpaceImport); importClause->importedDefaultBindingToken = loc(1); sym(1).ImportClause = importClause; } break; -#line 4083 "qmljs.g" +#line 4291 "qmljs.g" - case 556: { + case 561: { auto importClause = new (pool) AST::ImportClause(stringRef(1), sym(3).NamedImports); importClause->importedDefaultBindingToken = loc(1); sym(1).ImportClause = importClause; } break; -#line 4094 "qmljs.g" +#line 4302 "qmljs.g" - case 558: { + case 563: { auto import = new (pool) AST::NameSpaceImport(stringRef(3)); import->starToken = loc(1); import->importedBindingToken = loc(3); sym(1).NameSpaceImport = import; } break; -#line 4104 "qmljs.g" +#line 4312 "qmljs.g" - case 559: { + case 564: { auto namedImports = new (pool) AST::NamedImports(); namedImports->leftBraceToken = loc(1); namedImports->rightBraceToken = loc(2); sym(1).NamedImports = namedImports; } break; -#line 4113 "qmljs.g" +#line 4321 "qmljs.g" - case 560: { + case 565: { auto namedImports = new (pool) AST::NamedImports(sym(2).ImportsList->finish()); namedImports->leftBraceToken = loc(1); namedImports->rightBraceToken = loc(3); sym(1).NamedImports = namedImports; } break; -#line 4122 "qmljs.g" +#line 4330 "qmljs.g" - case 561: { + case 566: { auto namedImports = new (pool) AST::NamedImports(sym(2).ImportsList->finish()); namedImports->leftBraceToken = loc(1); namedImports->rightBraceToken = loc(4); sym(1).NamedImports = namedImports; } break; -#line 4132 "qmljs.g" +#line 4340 "qmljs.g" - case 562: { + case 567: { auto clause = new (pool) AST::FromClause(stringRef(2)); clause->fromToken = loc(1); clause->moduleSpecifierToken = loc(2); sym(1).FromClause = clause; } break; -#line 4142 "qmljs.g" +#line 4350 "qmljs.g" - case 563: { + case 568: { auto importsList = new (pool) AST::ImportsList(sym(1).ImportSpecifier); importsList->importSpecifierToken = loc(1); sym(1).ImportsList = importsList; } break; -#line 4150 "qmljs.g" +#line 4358 "qmljs.g" - case 564: { + case 569: { auto importsList = new (pool) AST::ImportsList(sym(1).ImportsList, sym(3).ImportSpecifier); importsList->importSpecifierToken = loc(3); sym(1).ImportsList = importsList; } break; -#line 4159 "qmljs.g" +#line 4367 "qmljs.g" - case 565: { + case 570: { auto importSpecifier = new (pool) AST::ImportSpecifier(stringRef(1)); importSpecifier->importedBindingToken = loc(1); sym(1).ImportSpecifier = importSpecifier; } break; -#line 4167 "qmljs.g" +#line 4375 "qmljs.g" - case 566: { + case 571: { auto importSpecifier = new (pool) AST::ImportSpecifier(stringRef(1), stringRef(3)); importSpecifier->identifierToken = loc(1); importSpecifier->importedBindingToken = loc(3); sym(1).ImportSpecifier = importSpecifier; } break; -#line 4184 "qmljs.g" +#line 4392 "qmljs.g" - case 569: { + case 574: { int token = lookaheadToken(lexer); - if (token == T_FUNCTION || token == T_CLASS) + if (token == T_FUNCTION || token == T_FUNCTION_STAR || token == T_CLASS) pushToken(T_FORCE_DECLARATION); } break; -#line 4193 "qmljs.g" +#line 4401 "qmljs.g" - case 570: { + case 575: { auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(3).FromClause); exportDeclaration->exportToken = loc(1); sym(1).ExportDeclaration = exportDeclaration; } break; -#line 4201 "qmljs.g" +#line 4409 "qmljs.g" - case 571: { + case 576: { auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(2).ExportClause, sym(3).FromClause); exportDeclaration->exportToken = loc(1); sym(1).ExportDeclaration = exportDeclaration; } break; -#line 4209 "qmljs.g" +#line 4417 "qmljs.g" - case 572: { + case 577: { auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(2).ExportClause); exportDeclaration->exportToken = loc(1); sym(1).ExportDeclaration = exportDeclaration; } break; -#line 4217 "qmljs.g" - case 573: Q_FALLTHROUGH(); -#line 4219 "qmljs.g" +#line 4425 "qmljs.g" + case 578: Q_FALLTHROUGH(); +#line 4427 "qmljs.g" - case 574: { + case 579: { auto exportDeclaration = new (pool) AST::ExportDeclaration(/*exportDefault=*/false, sym(2).Node); exportDeclaration->exportToken = loc(1); sym(1).ExportDeclaration = exportDeclaration; } break; -#line 4227 "qmljs.g" +#line 4435 "qmljs.g" - case 575: { + case 580: { if (auto *f = AST::cast(sym(5).Node)) { if (f->name.isEmpty()) { f->name = stringRef(2); @@ -3225,9 +3385,9 @@ case 205: { } } Q_FALLTHROUGH(); -#line 4238 "qmljs.g" +#line 4446 "qmljs.g" - case 576: { + case 581: { // Emulate 15.2.3.11 if (auto *cls = AST::cast(sym(5).Node)) { if (cls->name.isEmpty()) { @@ -3241,9 +3401,9 @@ case 205: { sym(1).ExportDeclaration = exportDeclaration; } break; -#line 4254 "qmljs.g" +#line 4462 "qmljs.g" - case 577: { + case 582: { // if lhs is an identifier expression and rhs is an anonymous function expression, we need to assign the name of lhs to the function if (auto *f = asAnonymousFunctionDefinition(sym(4).Node)) { f->name = stringRef(2); @@ -3257,63 +3417,63 @@ case 205: { sym(1).ExportDeclaration = exportDeclaration; } break; -#line 4271 "qmljs.g" +#line 4479 "qmljs.g" - case 578: { + case 583: { auto exportClause = new (pool) AST::ExportClause(); exportClause->leftBraceToken = loc(1); exportClause->rightBraceToken = loc(2); sym(1).ExportClause = exportClause; } break; -#line 4280 "qmljs.g" +#line 4488 "qmljs.g" - case 579: { + case 584: { auto exportClause = new (pool) AST::ExportClause(sym(2).ExportsList->finish()); exportClause->leftBraceToken = loc(1); exportClause->rightBraceToken = loc(3); sym(1).ExportClause = exportClause; } break; -#line 4289 "qmljs.g" +#line 4497 "qmljs.g" - case 580: { + case 585: { auto exportClause = new (pool) AST::ExportClause(sym(2).ExportsList->finish()); exportClause->leftBraceToken = loc(1); exportClause->rightBraceToken = loc(4); sym(1).ExportClause = exportClause; } break; -#line 4299 "qmljs.g" +#line 4507 "qmljs.g" - case 581: { + case 586: { sym(1).ExportsList = new (pool) AST::ExportsList(sym(1).ExportSpecifier); } break; -#line 4305 "qmljs.g" +#line 4513 "qmljs.g" - case 582: { + case 587: { sym(1).ExportsList = new (pool) AST::ExportsList(sym(1).ExportsList, sym(3).ExportSpecifier); } break; -#line 4312 "qmljs.g" +#line 4520 "qmljs.g" - case 583: { + case 588: { auto exportSpecifier = new (pool) AST::ExportSpecifier(stringRef(1)); exportSpecifier->identifierToken = loc(1); sym(1).ExportSpecifier = exportSpecifier; } break; -#line 4320 "qmljs.g" +#line 4528 "qmljs.g" - case 584: { + case 589: { auto exportSpecifier = new (pool) AST::ExportSpecifier(stringRef(1), stringRef(3)); exportSpecifier->identifierToken = loc(1); exportSpecifier->exportedIdentifierToken = loc(3); sym(1).ExportSpecifier = exportSpecifier; } break; -#line 4331 "qmljs.g" +#line 4539 "qmljs.g" // ------------ end of switch statement } // switch @@ -3338,6 +3498,7 @@ case 205: { tk.token = yytoken; tk.dval = yylval; tk.spell = yytokenspell; + tk.raw = yytokenraw; tk.loc = yylloc; yylloc = yyprevlloc; @@ -3345,8 +3506,8 @@ case 205: { yylloc.startColumn += yylloc.length; yylloc.length = 0; - //const QString msg = QCoreApplication::translate("QmlParser", "Missing `;'"); - //diagnostic_messages.append(DiagnosticMessage(Severity::Warning, yylloc, msg)); + //const QString msg = QCoreApplication::translate("QQmlParser", "Missing `;'"); + //diagnostic_messages.append(compileError(yyloc, msg, Severity::Warning)); first_token = &token_buffer[0]; last_token = &token_buffer[1]; @@ -3364,21 +3525,26 @@ case 205: { token_buffer[0].token = yytoken; token_buffer[0].dval = yylval; token_buffer[0].spell = yytokenspell; + token_buffer[0].raw = yytokenraw; token_buffer[0].loc = yylloc; token_buffer[1].token = yytoken = lexer->lex(); token_buffer[1].dval = yylval = lexer->tokenValue(); token_buffer[1].spell = yytokenspell = lexer->tokenSpell(); + token_buffer[1].raw = yytokenraw = lexer->rawString(); token_buffer[1].loc = yylloc = location(lexer); if (t_action(errorState, yytoken)) { +#ifdef PARSER_DEBUG + qDebug() << "Parse error, trying to recover."; +#endif QString msg; int token = token_buffer[0].token; if (token < 0 || token >= TERMINAL_COUNT) - msg = QCoreApplication::translate("QmlParser", "Syntax error"); + msg = QCoreApplication::translate("QQmlParser", "Syntax error"); else - msg = QCoreApplication::translate("QmlParser", "Unexpected token `%1'").arg(QLatin1String(spell[token])); - diagnostic_messages.append(DiagnosticMessage(Severity::Error, token_buffer[0].loc, msg)); + msg = QCoreApplication::translate("QQmlParser", "Unexpected token `%1'").arg(QLatin1String(spell[token])); + diagnostic_messages.append(compileError(token_buffer[0].loc, msg)); action = errorState; goto _Lcheck_token; @@ -3405,18 +3571,13 @@ case 205: { for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) { int a = t_action(errorState, *tk); if (a > 0 && t_action(a, yytoken)) { - const QString msg = QCoreApplication::translate("QmlParser", "Expected token `%1'").arg(QLatin1String(spell[*tk])); - diagnostic_messages.append(DiagnosticMessage(Severity::Error, token_buffer[0].loc, msg)); +#ifdef PARSER_DEBUG + qDebug() << "Parse error, trying to recover (2)."; +#endif + const QString msg = QCoreApplication::translate("QQmlParser", "Expected token `%1'").arg(QLatin1String(spell[*tk])); + diagnostic_messages.append(compileError(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; + pushToken(*tk); goto _Lcheck_token; } } @@ -3428,21 +3589,16 @@ case 205: { int a = t_action(errorState, tk); if (a > 0 && t_action(a, yytoken)) { - const QString msg = QCoreApplication::translate("QmlParser", "Expected token `%1'").arg(QLatin1String(spell[tk])); - diagnostic_messages.append(DiagnosticMessage(Severity::Error, token_buffer[0].loc, msg)); + const QString msg = QCoreApplication::translate("QQmlParser", "Expected token `%1'").arg(QLatin1String(spell[tk])); + diagnostic_messages.append(compileError(token_buffer[0].loc, msg)); - yytoken = tk; - yylval = 0; - yylloc = token_buffer[0].loc; - yylloc.length = 0; - - action = errorState; + pushToken(tk); goto _Lcheck_token; } } - const QString msg = QCoreApplication::translate("QmlParser", "Syntax error"); - diagnostic_messages.append(DiagnosticMessage(Severity::Error, token_buffer[0].loc, msg)); + const QString msg = QCoreApplication::translate("QQmlParser", "Syntax error"); + diagnostic_messages.append(compileError(token_buffer[0].loc, msg)); } return false; diff --git a/src/libs/qmljs/parser/qmljsparser_p.h b/src/libs/qmljs/parser/qmljsparser_p.h index 48478e32c5d..5dfa141d73c 100644 --- a/src/libs/qmljs/parser/qmljsparser_p.h +++ b/src/libs/qmljs/parser/qmljsparser_p.h @@ -1,5 +1,5 @@ -#line 178 "qmljs.g" +#line 182 "qmljs.g" /**************************************************************************** ** ** Copyright (C) 2016 The Qt Company Ltd. @@ -122,6 +122,9 @@ public: AST::ExportsList *ExportsList; AST::ExportClause *ExportClause; AST::ExportDeclaration *ExportDeclaration; + AST::TypeAnnotation *TypeAnnotation; + AST::TypeArgumentList *TypeArgumentList; + AST::Type *Type; AST::UiProgram *UiProgram; AST::UiHeaderItemList *UiHeaderItemList; @@ -139,6 +142,7 @@ public: AST::UiArrayMemberList *UiArrayMemberList; AST::UiQualifiedId *UiQualifiedId; AST::UiEnumMemberList *UiEnumMemberList; + AST::UiVersionSpecifier *UiVersionSpecifier; }; public: @@ -217,6 +221,9 @@ protected: inline QStringRef &stringRef(int index) { return string_stack [tos + index - 1]; } + inline QStringRef &rawStringRef(int index) + { return rawString_stack [tos + index - 1]; } + inline AST::SourceLocation &loc(int index) { return location_stack [tos + index - 1]; } @@ -225,13 +232,25 @@ protected: void pushToken(int token); int lookaheadToken(Lexer *lexer); + static DiagnosticMessage compileError(const AST::SourceLocation &location, + const QString &message, Severity::Enum kind = Severity::Error) + { + DiagnosticMessage error; + error.loc = location; + error.message = message; + error.kind = kind; + return error; + } + void syntaxError(const AST::SourceLocation &location, const char *message) { - diagnostic_messages.append(DiagnosticMessage(Severity::Error, location, QLatin1String(message))); + diagnostic_messages.append(compileError(location, QLatin1String(message))); } void syntaxError(const AST::SourceLocation &location, const QString &message) { - diagnostic_messages.append(DiagnosticMessage(Severity::Error, location, message)); + diagnostic_messages.append(compileError(location, message)); } + bool ensureNoFunctionTypeAnnotations(AST::TypeAnnotation *returnTypeAnnotation, AST::FormalParameterList *formals); + protected: Engine *driver; MemoryPool *pool; @@ -241,6 +260,7 @@ protected: int *state_stack = nullptr; AST::SourceLocation *location_stack = nullptr; QVector string_stack; + QVector rawString_stack; AST::Node *program = nullptr; @@ -252,11 +272,13 @@ protected: double dval; AST::SourceLocation loc; QStringRef spell; + QStringRef raw; }; int yytoken = -1; double yylval = 0.; QStringRef yytokenspell; + QStringRef yytokenraw; AST::SourceLocation yylloc; AST::SourceLocation yyprevlloc; @@ -281,27 +303,27 @@ protected: -#line 1511 "qmljs.g" +#line 1686 "qmljs.g" -#define J_SCRIPT_REGEXPLITERAL_RULE1 128 +#define J_SCRIPT_REGEXPLITERAL_RULE1 144 -#line 1523 "qmljs.g" +#line 1698 "qmljs.g" -#define J_SCRIPT_REGEXPLITERAL_RULE2 129 +#define J_SCRIPT_REGEXPLITERAL_RULE2 145 -#line 3022 "qmljs.g" +#line 3198 "qmljs.g" -#define J_SCRIPT_EXPRESSIONSTATEMENTLOOKAHEAD_RULE 421 +#define J_SCRIPT_EXPRESSIONSTATEMENTLOOKAHEAD_RULE 435 -#line 3653 "qmljs.g" +#line 3850 "qmljs.g" -#define J_SCRIPT_CONCISEBODYLOOKAHEAD_RULE 499 +#define J_SCRIPT_CONCISEBODYLOOKAHEAD_RULE 505 -#line 4181 "qmljs.g" +#line 4389 "qmljs.g" -#define J_SCRIPT_EXPORTDECLARATIONLOOKAHEAD_RULE 569 +#define J_SCRIPT_EXPORTDECLARATIONLOOKAHEAD_RULE 574 -#line 4469 "qmljs.g" +#line 4673 "qmljs.g" QT_QML_END_NAMESPACE diff --git a/src/libs/qmljs/qmljscheck.cpp b/src/libs/qmljs/qmljscheck.cpp index e3fe353b951..dee6053f00a 100644 --- a/src/libs/qmljs/qmljscheck.cpp +++ b/src/libs/qmljs/qmljscheck.cpp @@ -66,7 +66,7 @@ public: return _message; } - void setMessage(Type type) + void setMessage(StaticAnalysis::Type type) { _message = Message(type, _location); } @@ -511,7 +511,7 @@ protected: } private: - void addMessage(Type type, const SourceLocation &loc, const QString &arg1 = QString()) + void addMessage(StaticAnalysis::Type type, const SourceLocation &loc, const QString &arg1 = QString()) { _messages.append(Message(type, loc, arg1)); } @@ -695,12 +695,12 @@ QList Check::operator()() return _messages; } -void Check::enableMessage(Type type) +void Check::enableMessage(StaticAnalysis::Type type) { _enabledMessages.insert(type); } -void Check::disableMessage(Type type) +void Check::disableMessage(StaticAnalysis::Type type) { _enabledMessages.remove(type); } @@ -1267,7 +1267,7 @@ bool Check::visit(BinaryExpression *ast) const QLatin1Char newline('\n'); if (ast->op == QSOperator::Add || ast->op == QSOperator::Sub) { QChar match; - Type msg; + StaticAnalysis::Type msg; if (ast->op == QSOperator::Add) { match = '+'; msg = WarnConfusingPluses; @@ -1522,7 +1522,7 @@ void Check::addMessage(const Message &message) } } -void Check::addMessage(Type type, const SourceLocation &location, const QString &arg1, const QString &arg2) +void Check::addMessage(StaticAnalysis::Type type, const SourceLocation &location, const QString &arg1, const QString &arg2) { addMessage(Message(type, location, arg1, arg2)); }