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)); }