diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2e1132622c08fd68d804056576166bbab01af036 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# Poject set up + +1. \ No newline at end of file diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 1784a2b082ce46ee87fd97e36d0760824b03cc65..67e2605a12dec9cb6fc68325684defc1725a666f 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -10,6 +10,7 @@ plugins { // Apply the application plugin to add support for building a CLI application in Java. application antlr + java } repositories { @@ -59,6 +60,17 @@ application { mainClass.set("githubsqlfinder.App") } +//val mode: String by project.extra + +// Set the default value for the parameter +//project.extra["mode"] = "1" + +// Define your run task +tasks.named<JavaExec>("run") { + // Pass the custom parameter as an argument to your application + args(System.getProperty("files", "100"), System.getProperty("batch", "100"), System.getProperty("mode", "2"), System.getProperty("offset", "0"), System.getProperty("sample", "1")) +} + tasks.named<Test>("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() diff --git a/app/sample.db b/app/sample.db new file mode 100644 index 0000000000000000000000000000000000000000..74b87f052289e1921c5ccfe6353c957d1fd09cf0 Binary files /dev/null and b/app/sample.db differ diff --git a/app/src/main/antlr/PhpLexer.g4 b/app/src/main/antlr/PhpLexer.g4 new file mode 100644 index 0000000000000000000000000000000000000000..b516acb5bd35b91807608dad42be9a3a37c81a68 --- /dev/null +++ b/app/src/main/antlr/PhpLexer.g4 @@ -0,0 +1,386 @@ +/* +PHP grammar. +The MIT License (MIT). +Copyright (c) 2015-2020, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies. +Copyright (c) 2019, Thierry Marianne (thierry.marianne@weaving-the-web.org) +Copyright (c) 2019-2020, Student Main for php7, php8 support. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine +// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true + +lexer grammar PhpLexer; + +channels { + PhpComments, + ErrorLexem, + SkipChannel +} + +options { + superClass = PhpLexerBase; + caseInsensitive = true; +} + +// Insert here @header for C++ lexer. + +SeaWhitespace : [ \t\r\n]+ -> channel(HIDDEN); +HtmlText : ~[<#]+; +XmlStart : '<?xml' -> pushMode(XML); +PHPStartEcho : PhpStartEchoFragment -> type(Echo), pushMode(PHP); +PHPStart : PhpStartFragment -> channel(SkipChannel), pushMode(PHP); +HtmlScriptOpen : '<script' { this._scriptTag = true; } -> pushMode(INSIDE); +HtmlStyleOpen : '<style' { this._styleTag = true; } -> pushMode(INSIDE); +HtmlComment : '<!' '--' .*? '-->' -> channel(HIDDEN); +HtmlDtd : '<!' .*? '>'; +HtmlOpen : '<' -> pushMode(INSIDE); +Shebang : '#' { this.IsNewLineOrStart(-2) }? '!' ~[\r\n]*; +NumberSign : '#' ~'<'* -> more; +Error : . -> channel(ErrorLexem); + +// TODO: parse xml attributes. +mode XML; + +XmlText : ~'?'+; +XmlClose : '?>' -> popMode; +XmlText2 : '?' -> type(XmlText); + +mode INSIDE; + +PHPStartEchoInside : PhpStartEchoFragment -> type(Echo), pushMode(PHP); +PHPStartInside : PhpStartFragment -> channel(SkipChannel), pushMode(PHP); +HtmlClose : '>' { this.PushModeOnHtmlClose(); }; +HtmlSlashClose : '/>' -> popMode; +HtmlSlash : '/'; +HtmlEquals : '='; + +HtmlStartQuoteString : '\\'? '\'' -> pushMode(HtmlQuoteStringMode); +HtmlStartDoubleQuoteString : '\\'? '"' -> pushMode(HtmlDoubleQuoteStringMode); +HtmlHex : '#' HexDigit+; +HtmlDecimal : Digit+; +HtmlSpace : [ \t\r\n]+ -> channel(HIDDEN); +HtmlName : HtmlNameStartChar HtmlNameChar*; +ErrorInside : . -> channel(ErrorLexem); + +mode HtmlQuoteStringMode; + +PHPStartEchoInsideQuoteString : PhpStartEchoFragment -> type(Echo), pushMode(PHP); +PHPStartInsideQuoteString : PhpStartFragment -> channel(SkipChannel), pushMode(PHP); +HtmlEndQuoteString : '\'' '\''? -> popMode; +HtmlQuoteString : ~[<']+; +ErrorHtmlQuote : . -> channel(ErrorLexem); + +mode HtmlDoubleQuoteStringMode; + +PHPStartEchoDoubleQuoteString : PhpStartEchoFragment -> type(Echo), pushMode(PHP); +PHPStartDoubleQuoteString : PhpStartFragment -> channel(SkipChannel), pushMode(PHP); +HtmlEndDoubleQuoteString : '"' '"'? -> popMode; +HtmlDoubleQuoteString : ~[<"]+; +ErrorHtmlDoubleQuote : . -> channel(ErrorLexem); + +// Parse JavaScript with https://github.com/antlr/grammars-v4/tree/master/javascript if necessary. +// Php blocks can exist inside Script blocks too. +mode SCRIPT; + +ScriptText: ~'<'+; +// TODO: handle JS strings, but handle <?php tags inside them +//ScriptString: '"' (~'"' | '\\' ('\r'? '\n' | .))* '"' -> type(ScriptText); +//ScriptString2: '\'' (~'\'' | '\\' ('\r'? '\n' | .))* '\'' -> type(ScriptText); +HtmlScriptClose : '</' 'script'? '>' -> popMode; +PHPStartInsideScriptEcho : PhpStartEchoFragment -> type(Echo), pushMode(PHP); +PHPStartInsideScript : PhpStartFragment -> channel(SkipChannel), pushMode(PHP); +ScriptText2 : '<' -> type(ScriptText); + +mode STYLE; + +StyleBody: .*? '</' 'style'? '>' -> popMode; + +mode PHP; + +PHPEnd : ('?' | '%' {this.HasAspTags()}?) '>' | '</script>' {this.HasPhpScriptTag()}?; +Whitespace : [ \t\r\n]+ -> channel(SkipChannel); +MultiLineComment : '/*' .*? '*/' -> channel(PhpComments); +SingleLineComment : '//' -> channel(SkipChannel), pushMode(SingleLineCommentMode); +ShellStyleComment : '#' -> channel(SkipChannel), pushMode(SingleLineCommentMode); + +AttributeStart: '#['; + +Abstract : 'abstract'; +Array : 'array'; +As : 'as'; +BinaryCast : 'binary'; +BoolType : 'bool' 'ean'?; +BooleanConstant : 'true' | 'false'; +Break : 'break'; +Callable : 'callable'; +Case : 'case'; +Catch : 'catch'; +Class : 'class'; +Clone : 'clone'; +Const : 'const'; +Continue : 'continue'; +Declare : 'declare'; +Default : 'default'; +Do : 'do'; +DoubleCast : 'real'; +DoubleType : 'double'; +Echo : 'echo'; +Else : 'else'; +ElseIf : 'elseif'; +Empty : 'empty'; +Enum_ : 'enum'; + +EndDeclare : 'enddeclare'; +EndFor : 'endfor'; +EndForeach : 'endforeach'; +EndIf : 'endif'; +EndSwitch : 'endswitch'; +EndWhile : 'endwhile'; + +Eval : 'eval'; +Exit : 'die'; +Extends : 'extends'; +Final : 'final'; +Finally : 'finally'; +FloatCast : 'float'; +For : 'for'; +Foreach : 'foreach'; +Function_ : 'function'; +Global : 'global'; +Goto : 'goto'; +If : 'if'; +Implements : 'implements'; +Import : 'import'; +Include : 'include'; +IncludeOnce : 'include_once'; +InstanceOf : 'instanceof'; +InsteadOf : 'insteadof'; +Int8Cast : 'int8'; +Int16Cast : 'int16'; +Int64Type : 'int64'; +IntType : 'int' 'eger'?; +Interface : 'interface'; +IsSet : 'isset'; +List : 'list'; +LogicalAnd : 'and'; +LogicalOr : 'or'; +LogicalXor : 'xor'; +Match_ : 'match'; +Namespace : 'namespace'; +New : 'new'; +Null : 'null'; +ObjectType : 'object'; +Parent_ : 'parent'; +Partial : 'partial'; +Print : 'print'; +Private : 'private'; +Protected : 'protected'; +Public : 'public'; +Readonly : 'readonly'; +Require : 'require'; +RequireOnce : 'require_once'; +Resource : 'resource'; +Return : 'return'; +Static : 'static'; +StringType : 'string'; +Switch : 'switch'; +Throw : 'throw'; +Trait : 'trait'; +Try : 'try'; +Typeof : 'clrtypeof'; +UintCast : 'uint' ('8' | '16' | '64')?; +UnicodeCast : 'unicode'; +Unset : 'unset'; +Use : 'use'; +Var : 'var'; +While : 'while'; +Yield : 'yield'; +From : 'from'; +LambdaFn : 'fn'; +Ticks : 'ticks'; +Encoding : 'encoding'; +StrictTypes : 'strict_types'; + +Get : '__get'; +Set : '__set'; +Call : '__call'; +CallStatic : '__callstatic'; +Constructor : '__construct'; +Destruct : '__destruct'; +Wakeup : '__wakeup'; +Sleep : '__sleep'; +Autoload : '__autoload'; +IsSet__ : '__isset'; +Unset__ : '__unset'; +ToString__ : '__tostring'; +Invoke : '__invoke'; +SetState : '__set_state'; +Clone__ : '__clone'; +DebugInfo : '__debuginfo'; +Namespace__ : '__namespace__'; +Class__ : '__class__'; +Traic__ : '__trait__'; +Function__ : '__function__'; +Method__ : '__method__'; +Line__ : '__line__'; +File__ : '__file__'; +Dir__ : '__dir__'; + +Spaceship : '<=>'; +Lgeneric : '<:'; +Rgeneric : ':>'; +DoubleArrow : '=>'; +Inc : '++'; +Dec : '--'; +IsIdentical : '==='; +IsNoidentical : '!=='; +IsEqual : '=='; +IsNotEq : '<>' | '!='; +IsSmallerOrEqual : '<='; +IsGreaterOrEqual : '>='; +PlusEqual : '+='; +MinusEqual : '-='; +MulEqual : '*='; +Pow : '**'; +PowEqual : '**='; +DivEqual : '/='; +Concaequal : '.='; +ModEqual : '%='; +ShiftLeftEqual : '<<='; +ShiftRightEqual : '>>='; +AndEqual : '&='; +OrEqual : '|='; +XorEqual : '^='; +BooleanOr : '||'; +BooleanAnd : '&&'; + +NullCoalescing : '??'; +NullCoalescingEqual : '??='; + +ShiftLeft : '<<'; +ShiftRight : '>>'; +DoubleColon : '::'; +ObjectOperator : '->'; +NamespaceSeparator : '\\'; +Ellipsis : '...'; +Less : '<'; +Greater : '>'; +Ampersand : '&'; +Pipe : '|'; +Bang : '!'; +Caret : '^'; +Plus : '+'; +Minus : '-'; +Asterisk : '*'; +Percent : '%'; +Divide : '/'; +Tilde : '~'; +SuppressWarnings : '@'; +Dollar : '$'; +Dot : '.'; +QuestionMark : '?'; +OpenRoundBracket : '('; +CloseRoundBracket : ')'; +OpenSquareBracket : '['; +CloseSquareBracket : ']'; +OpenCurlyBracket : '{'; +CloseCurlyBracket : '}' { this.PopModeOnCurlyBracketClose(); }; +Comma : ','; +Colon : ':'; +SemiColon : ';'; +Eq : '='; +Quote : '\''; +BackQuote : '`'; + +VarName : '$' NameString; +Label : [a-z_][a-z_0-9]*; +Octal : '0' 'o'? OctalDigit+ ('_' OctalDigit+)*; +Decimal : '0' | NonZeroDigit Digit* ('_' Digit+)*; +Real : (LNum '.' LNum? | LNum? '.' LNum) ExponentPart? | LNum+ ExponentPart; +Hex : '0x' HexDigit+ ('_' HexDigit+)*; +Binary : '0b' [01]+ ('_' [01]+)*; + +BackQuoteString : '`' ~'`'* '`'; +SingleQuoteString : '\'' (~('\'' | '\\') | '\\' .)* '\''; +DoubleQuote : '"' -> pushMode(InterpolationString); + +StartNowDoc: + '<<<' [ \t]* '\'' NameString '\'' { this.ShouldPushHereDocMode(1) }? -> pushMode(HereDoc) +; +StartHereDoc : '<<<' [ \t]* NameString { this.ShouldPushHereDocMode(1) }? -> pushMode(HereDoc); +ErrorPhp : . -> channel(ErrorLexem); + +mode InterpolationString; + +VarNameInInterpolation : '$' NameString -> type(VarName); // TODO: fix such cases: "$people->john" +DollarString : '$' -> type(StringPart); +CurlyDollar: + '{' { this.IsCurlyDollar(1) }? { this.SetInsideString(); } -> channel(SkipChannel), pushMode(PHP) +; +CurlyString : '{' -> type(StringPart); +EscapedChar : '\\' . -> type(StringPart); +DoubleQuoteInInterpolation : '"' -> type(DoubleQuote), popMode; +UnicodeEscape : '\\u{' [a-z0-9][a-z0-9]+ '}'; +StringPart : ~[${\\"]+; + +mode SingleLineCommentMode; + +Comment : ~[\r\n?]+ -> channel(PhpComments); +PHPEndSingleLineComment : '?' '>'; +CommentQuestionMark : '?' -> type(Comment), channel(PhpComments); +CommentEnd : [\r\n] -> channel(SkipChannel), popMode; // exit from comment. + +mode HereDoc; +// TODO: interpolation for heredoc strings. + +HereDocText: ~[\r\n]*? ('\r'? '\n' | '\r'); + +// fragments. +// '<?=' will be transformed to 'echo' token. +// '<?= "Hello world"; ?>' will be transformed to '<?php echo "Hello world"; ?>' +fragment PhpStartEchoFragment : '<' ('?' '=' | { this.HasAspTags() }? '%' '='); +fragment PhpStartFragment : '<' ('?' 'php'? | { this.HasAspTags() }? '%'); +fragment NameString : [a-zA-Z_\u0080-\ufffe][a-zA-Z0-9_\u0080-\ufffe]*; +fragment HtmlNameChar : + HtmlNameStartChar + | '-' + | '_' + | '.' + | Digit + | '\u00B7' + | '\u0300' ..'\u036F' + | '\u203F' ..'\u2040' +; +fragment HtmlNameStartChar : + [:a-zA-Z] + | '\u2070' ..'\u218F' + | '\u2C00' ..'\u2FEF' + | '\u3001' ..'\uD7FF' + | '\uF900' ..'\uFDCF' + | '\uFDF0' ..'\uFFFD' +; +fragment LNum : Digit+ ('_' Digit+)*; +fragment ExponentPart : 'e' [+-]? LNum; +fragment NonZeroDigit : [1-9]; +fragment Digit : [0-9]; +fragment OctalDigit : [0-7]; +fragment HexDigit : [a-f0-9]; \ No newline at end of file diff --git a/app/src/main/antlr/PhpParser.g4 b/app/src/main/antlr/PhpParser.g4 new file mode 100644 index 0000000000000000000000000000000000000000..3ba7eb3dd6eb22df32e3186862ae128e5e632b6c --- /dev/null +++ b/app/src/main/antlr/PhpParser.g4 @@ -0,0 +1,980 @@ +/* +PHP grammar. +The MIT License (MIT). +Copyright (c) 2015-2020, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies. +Copyright (c) 2019-2020, Student Main for php7, php8 support. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging + +parser grammar PhpParser; + +options { + tokenVocab = PhpLexer; +} + +// HTML +// Also see here: https://github.com/antlr/grammars-v4/tree/master/html + +htmlDocument + : Shebang? (inlineHtml | phpBlock)* EOF + ; + +inlineHtml + : htmlElement+ + | scriptText + ; + +// TODO: split into html, css and xml elements +htmlElement + : HtmlDtd + | HtmlClose + | HtmlStyleOpen + | HtmlOpen + | HtmlName + | HtmlSlashClose + | HtmlSlash + | HtmlText + | HtmlEquals + | HtmlStartQuoteString + | HtmlEndQuoteString + | HtmlStartDoubleQuoteString + | HtmlEndDoubleQuoteString + | HtmlHex + | HtmlDecimal + | HtmlQuoteString + | HtmlDoubleQuoteString + | StyleBody + | HtmlScriptOpen + | HtmlScriptClose + | XmlStart XmlText* XmlClose + ; + +// Script +// Parse JavaScript with https://github.com/antlr/grammars-v4/tree/master/javascript if necessary. + +scriptText + : ScriptText+ + ; + +// PHP + +phpBlock + : importStatement* topStatement+ + ; + +importStatement + : Import Namespace namespaceNameList SemiColon + ; + +topStatement + : statement + | useDeclaration + | namespaceDeclaration + | functionDeclaration + | classDeclaration + | globalConstantDeclaration + | enumDeclaration + ; + +useDeclaration + : Use (Function_ | Const)? useDeclarationContentList SemiColon + ; + +useDeclarationContentList + : '\\'? useDeclarationContent (',' '\\'? useDeclarationContent)* + ; + +useDeclarationContent + : namespaceNameList + ; + +namespaceDeclaration + : Namespace ( + namespaceNameList? OpenCurlyBracket namespaceStatement* CloseCurlyBracket + | namespaceNameList SemiColon + ) + ; + +namespaceStatement + : statement + | useDeclaration + | functionDeclaration + | classDeclaration + | globalConstantDeclaration + ; + +functionDeclaration + : attributes? Function_ '&'? identifier typeParameterListInBrackets? '(' formalParameterList ')' ( + ':' QuestionMark? typeHint + )? blockStatement + ; + +classDeclaration + : attributes? Private? modifier? Partial? ( + classEntryType identifier typeParameterListInBrackets? (Extends qualifiedStaticTypeRef)? ( + Implements interfaceList + )? + | Interface identifier typeParameterListInBrackets? (Extends interfaceList)? + ) OpenCurlyBracket classStatement* CloseCurlyBracket + ; + +classEntryType + : Class + | Trait + ; + +interfaceList + : qualifiedStaticTypeRef (',' qualifiedStaticTypeRef)* + ; + +typeParameterListInBrackets + : '<:' typeParameterList ':>' + | '<:' typeParameterWithDefaultsList ':>' + | '<:' typeParameterList ',' typeParameterWithDefaultsList ':>' + ; + +typeParameterList + : typeParameterDecl (',' typeParameterDecl)* + ; + +typeParameterWithDefaultsList + : typeParameterWithDefaultDecl (',' typeParameterWithDefaultDecl)* + ; + +typeParameterDecl + : attributes? identifier + ; + +typeParameterWithDefaultDecl + : attributes? identifier Eq (qualifiedStaticTypeRef | primitiveType) + ; + +genericDynamicArgs + : '<:' typeRef (',' typeRef)* ':>' + ; + +attributes + : attributeGroup+ + ; + +attributeGroup + : AttributeStart (identifier ':')? attribute (',' attribute)* ']' + ; + +attribute + : qualifiedNamespaceName arguments? + ; + +innerStatementList + : innerStatement* + ; + +innerStatement + : statement + | functionDeclaration + | classDeclaration + ; + +// Statements + +statement + : identifier ':' + | blockStatement + | ifStatement + | whileStatement + | doWhileStatement + | forStatement + | switchStatement + | breakStatement + | continueStatement + | returnStatement + | yieldExpression SemiColon + | globalStatement + | staticVariableStatement + | echoStatement + | expressionStatement + | unsetStatement + | foreachStatement + | tryCatchFinally + | throwStatement + | gotoStatement + | declareStatement + | emptyStatement_ + | inlineHtmlStatement + ; + +emptyStatement_ + : SemiColon + ; + +blockStatement + : OpenCurlyBracket innerStatementList CloseCurlyBracket + ; + +ifStatement + : If parentheses statement elseIfStatement* elseStatement? + | If parentheses ':' innerStatementList elseIfColonStatement* elseColonStatement? EndIf SemiColon + ; + +elseIfStatement + : ElseIf parentheses statement + ; + +elseIfColonStatement + : ElseIf parentheses ':' innerStatementList + ; + +elseStatement + : Else statement + ; + +elseColonStatement + : Else ':' innerStatementList + ; + +whileStatement + : While parentheses (statement | ':' innerStatementList EndWhile SemiColon) + ; + +doWhileStatement + : Do statement While parentheses SemiColon + ; + +forStatement + : For '(' forInit? SemiColon expressionList? SemiColon forUpdate? ')' ( + statement + | ':' innerStatementList EndFor SemiColon + ) + ; + +forInit + : expressionList + ; + +forUpdate + : expressionList + ; + +switchStatement + : Switch parentheses ( + OpenCurlyBracket SemiColon? switchBlock* CloseCurlyBracket + | ':' SemiColon? switchBlock* EndSwitch SemiColon + ) + ; + +switchBlock + : ((Case expression | Default) (':' | SemiColon))+ innerStatementList + ; + +breakStatement + : Break expression? SemiColon + ; + +continueStatement + : Continue expression? SemiColon + ; + +returnStatement + : Return expression? SemiColon + ; + +expressionStatement + : expression SemiColon + ; + +unsetStatement + : Unset '(' chainList ')' SemiColon + ; + +foreachStatement + : Foreach ( + '(' expression As arrayDestructuring ')' + | '(' chain As '&'? assignable ('=>' '&'? chain)? ')' + | '(' expression As assignable ('=>' '&'? chain)? ')' + | '(' chain As List '(' assignmentList ')' ')' + ) (statement | ':' innerStatementList EndForeach SemiColon) + ; + +tryCatchFinally + : Try blockStatement (catchClause+ finallyStatement? | catchClause* finallyStatement) + ; + +catchClause + : Catch '(' qualifiedStaticTypeRef ('|' qualifiedStaticTypeRef)* VarName? ')' blockStatement + ; + +finallyStatement + : Finally blockStatement + ; + +throwStatement + : Throw expression SemiColon + ; + +gotoStatement + : Goto identifier SemiColon + ; + +declareStatement + : Declare '(' declareList ')' (statement | ':' innerStatementList EndDeclare SemiColon) + ; + +inlineHtmlStatement + : inlineHtml+ + ; + +declareList + : directive (',' directive)* + ; + +directive + : Ticks Eq (numericConstant | Real) + | Encoding Eq SingleQuoteString + | StrictTypes Eq numericConstant + ; + +formalParameterList + : formalParameter? (',' formalParameter)* ','? + ; + +formalParameter + : attributes? memberModifier* QuestionMark? typeHint? '&'? '...'? variableInitializer + ; + +typeHint + : qualifiedStaticTypeRef + | Callable + | primitiveType + | typeHint '|' typeHint + ; + +globalStatement + : Global globalVar (',' globalVar)* SemiColon + ; + +globalVar + : VarName + | Dollar chain + | Dollar OpenCurlyBracket expression CloseCurlyBracket + ; + +echoStatement + : Echo expressionList SemiColon + ; + +staticVariableStatement + : Static variableInitializer (',' variableInitializer)* SemiColon + ; + +classStatement + : attributes? ( + propertyModifiers typeHint? variableInitializer (',' variableInitializer)* SemiColon + | memberModifiers? ( + Const typeHint? identifierInitializer (',' identifierInitializer)* SemiColon + | Function_ '&'? identifier typeParameterListInBrackets? '(' formalParameterList ')' ( + baseCtorCall + | returnTypeDecl + )? methodBody + ) + ) + | Use qualifiedNamespaceNameList traitAdaptations + ; + +traitAdaptations + : SemiColon + | OpenCurlyBracket traitAdaptationStatement* CloseCurlyBracket + ; + +traitAdaptationStatement + : traitPrecedence + | traitAlias + ; + +traitPrecedence + : qualifiedNamespaceName '::' identifier InsteadOf qualifiedNamespaceNameList SemiColon + ; + +traitAlias + : traitMethodReference As (memberModifier | memberModifier? identifier) SemiColon + ; + +traitMethodReference + : (qualifiedNamespaceName '::')? identifier + ; + +baseCtorCall + : ':' identifier arguments? + ; + +returnTypeDecl + : ':' QuestionMark? typeHint + ; + +methodBody + : SemiColon + | blockStatement + ; + +propertyModifiers + : memberModifiers + | Var + ; + +memberModifiers + : memberModifier+ + ; + +variableInitializer + : VarName (Eq constantInitializer)? + ; + +identifierInitializer + : identifier Eq constantInitializer + ; + +globalConstantDeclaration + : attributes? Const identifierInitializer (',' identifierInitializer)* SemiColon + ; + +enumDeclaration + : Enum_ identifier (Colon (IntType | StringType))? (Implements interfaceList)? OpenCurlyBracket enumItem* CloseCurlyBracket + ; + +enumItem + : Case identifier (Eq expression)? SemiColon + | memberModifiers? functionDeclaration + | Use qualifiedNamespaceNameList traitAdaptations + ; + +expressionList + : expression (',' expression)* + ; + +parentheses + : '(' (expression | yieldExpression) ')' + ; + +// Expressions +// Grouped by priorities: http://php.net/manual/en/language.operators.precedence.php +expression + : Clone expression # CloneExpression + | newExpr # NewExpression + | stringConstant '[' expression ']' # IndexerExpression + | '(' castOperation ')' expression # CastExpression + | ('~' | '@') expression # UnaryOperatorExpression + | ('!' | '+' | '-') expression # UnaryOperatorExpression + | ('++' | '--') chain # PrefixIncDecExpression + | chain ('++' | '--') # PostfixIncDecExpression + | Print expression # PrintExpression + | arrayCreation # ArrayCreationExpression + | chain # ChainExpression + | constant # ScalarExpression + | string # ScalarExpression + | Label # ScalarExpression + | BackQuoteString # BackQuoteStringExpression + | parentheses # ParenthesisExpression + | Yield # SpecialWordExpression + | List '(' assignmentList ')' Eq expression # SpecialWordExpression + | IsSet '(' chainList ')' # SpecialWordExpression + | Empty '(' chain ')' # SpecialWordExpression + | Eval '(' expression ')' # SpecialWordExpression + | Exit ( '(' ')' | parentheses)? # SpecialWordExpression + | (Include | IncludeOnce) expression # SpecialWordExpression + | (Require | RequireOnce) expression # SpecialWordExpression + | lambdaFunctionExpr # LambdaFunctionExpression + | matchExpr # MatchExpression + | <assoc = right> expression op = '**' expression # ArithmeticExpression + | expression InstanceOf typeRef # InstanceOfExpression + | expression op = ('*' | Divide | '%') expression # ArithmeticExpression + | expression op = ('+' | '-' | '.') expression # ArithmeticExpression + | expression op = ('<<' | '>>') expression # ComparisonExpression + | expression op = (Less | '<=' | Greater | '>=') expression # ComparisonExpression + | expression op = ('===' | '!==' | '==' | IsNotEq) expression # ComparisonExpression + | expression op = '&' expression # BitwiseExpression + | expression op = '^' expression # BitwiseExpression + | expression op = '|' expression # BitwiseExpression + | expression op = '&&' expression # BitwiseExpression + | expression op = '||' expression # BitwiseExpression + | expression op = QuestionMark expression? ':' expression # ConditionalExpression + | expression op = '??' expression # NullCoalescingExpression + | expression op = '<=>' expression # SpaceshipExpression + | Throw expression # SpecialWordExpression + | arrayDestructuring Eq expression # ArrayDestructExpression + | assignable assignmentOperator attributes? expression # AssignmentExpression + | assignable Eq attributes? '&' (chain | newExpr) # AssignmentExpression + | expression op = LogicalAnd expression # LogicalExpression + | expression op = LogicalXor expression # LogicalExpression + | expression op = LogicalOr expression # LogicalExpression + ; + +assignable + : chain + | arrayCreation + ; + +arrayCreation + : (Array '(' arrayItemList? ')' | '[' arrayItemList? ']') ('[' expression ']')? + ; + +arrayDestructuring + : '[' ','* indexedDestructItem (','+ indexedDestructItem)* ','* ']' + | '[' keyedDestructItem (','+ keyedDestructItem)* ','? ']' + ; + +indexedDestructItem + : '&'? chain + ; + +keyedDestructItem + : (expression '=>')? '&'? chain + ; + +lambdaFunctionExpr + : Static? Function_ '&'? '(' formalParameterList ')' lambdaFunctionUseVars? (':' typeHint)? blockStatement + | LambdaFn '(' formalParameterList ')' '=>' expression + ; + +matchExpr + : Match_ '(' expression ')' OpenCurlyBracket matchItem (',' matchItem)* ','? CloseCurlyBracket + ; + +matchItem + : expression (',' expression)* '=>' expression + ; + +newExpr + : New typeRef arguments? + ; + +assignmentOperator + : Eq + | '+=' + | '-=' + | '*=' + | '**=' + | '/=' + | '.=' + | '%=' + | '&=' + | '|=' + | '^=' + | '<<=' + | '>>=' + | '??=' + ; + +yieldExpression + : Yield (expression ('=>' expression)? | From expression) + ; + +arrayItemList + : arrayItem (',' arrayItem)* ','? + ; + +arrayItem + : expression ('=>' expression)? + | (expression '=>')? '&' chain + ; + +lambdaFunctionUseVars + : Use '(' lambdaFunctionUseVar (',' lambdaFunctionUseVar)* ')' + ; + +lambdaFunctionUseVar + : '&'? VarName + ; + +qualifiedStaticTypeRef + : qualifiedNamespaceName genericDynamicArgs? + | Static + ; + +typeRef + : (qualifiedNamespaceName | indirectTypeRef) genericDynamicArgs? + | primitiveType + | Static + | anonymousClass + ; + +anonymousClass + : attributes? Private? modifier? Partial? ( + classEntryType typeParameterListInBrackets? (Extends qualifiedStaticTypeRef)? ( + Implements interfaceList + )? + | Interface identifier typeParameterListInBrackets? (Extends interfaceList)? + ) OpenCurlyBracket classStatement* CloseCurlyBracket + ; + +indirectTypeRef + : chainBase ('->' keyedFieldName)* + ; + +qualifiedNamespaceName + : Namespace? '\\'? namespaceNameList + ; + +namespaceNameList + : identifier + | identifier ('\\' identifier)* ('\\' namespaceNameTail)? + ; + +namespaceNameTail + : identifier (As identifier)? + | OpenCurlyBracket namespaceNameTail (',' namespaceNameTail)* ','? CloseCurlyBracket + ; + +qualifiedNamespaceNameList + : qualifiedNamespaceName (',' qualifiedNamespaceName)* + ; + +arguments + : '(' (actualArgument (',' actualArgument)* | yieldExpression)? ','? ')' + ; + +actualArgument + : argumentName? '...'? expression + | '&' chain + ; + +argumentName + : identifier ':' + ; + +constantInitializer + : constant + | string + | Array '(' (arrayItemList ','?)? ')' + | '[' (arrayItemList ','?)? ']' + | ('+' | '-') constantInitializer + | (string | constant) ('.' (string | constant))* + ; + +constant + : Null + | literalConstant + | magicConstant + | classConstant + | qualifiedNamespaceName + ; + +literalConstant + : Real + | BooleanConstant + | numericConstant + | stringConstant + ; + +numericConstant + : Octal + | Decimal + | Hex + | Binary + ; + +classConstant + : (Class | Parent_) '::' (identifier | Constructor | Get | Set) + | (qualifiedStaticTypeRef | keyedVariable | string) '::' ( + identifier + | keyedVariable + ) // 'foo'::$bar works in php7 + ; + +stringConstant + : Label + ; + +string + : StartHereDoc HereDocText+ + | StartNowDoc HereDocText+ + | SingleQuoteString + | DoubleQuote interpolatedStringPart* DoubleQuote + ; + +interpolatedStringPart + : StringPart + | UnicodeEscape + | chain + ; + +chainList + : chain (',' chain)* + ; + +chain + : chainOrigin memberAccess* + //| arrayCreation // [$a,$b]=$c + ; + +chainOrigin + : chainBase + | functionCall + | '(' newExpr ')' + ; + +memberAccess + : '->' keyedFieldName actualArguments? + ; + +functionCall + : functionCallName actualArguments + ; + +functionCallName + : qualifiedNamespaceName + | classConstant + | chainBase + | parentheses + ; + +actualArguments + : genericDynamicArgs? arguments+ squareCurlyExpression* + ; + +chainBase + : keyedVariable ('::' keyedVariable)? + | qualifiedStaticTypeRef '::' keyedVariable + ; + +keyedFieldName + : keyedSimpleFieldName + | keyedVariable + ; + +keyedSimpleFieldName + : (identifier | OpenCurlyBracket expression CloseCurlyBracket) squareCurlyExpression* + ; + +keyedVariable + : Dollar* (VarName | Dollar OpenCurlyBracket expression CloseCurlyBracket) squareCurlyExpression* + ; + +squareCurlyExpression + : '[' expression? ']' + | OpenCurlyBracket expression CloseCurlyBracket + ; + +assignmentList + : assignmentListElement? (',' assignmentListElement?)* + ; + +assignmentListElement + : chain + | List '(' assignmentList ')' + | arrayItem + ; + +modifier + : Abstract + | Final + ; + +identifier + : Label + | Abstract + | Array + | As + | BinaryCast + | BoolType + | BooleanConstant + | Break + | Callable + | Case + | Catch + | Class + | Clone + | Const + | Continue + | Declare + | Default + | Do + | DoubleCast + | DoubleType + | Echo + | Else + | ElseIf + | Empty + | EndDeclare + | EndFor + | EndForeach + | EndIf + | EndSwitch + | EndWhile + | Eval + | Exit + | Extends + | Final + | Finally + | FloatCast + | For + | Foreach + | Function_ + | Global + | Goto + | If + | Implements + | Import + | Include + | IncludeOnce + | InstanceOf + | InsteadOf + | Int16Cast + | Int64Type + | Int8Cast + | Interface + | IntType + | IsSet + | LambdaFn + | List + | LogicalAnd + | LogicalOr + | LogicalXor + | Namespace + | New + | Null + | ObjectType + | Parent_ + | Partial + | Print + | Private + | Protected + | Public + | Readonly + | Require + | RequireOnce + | Resource + | Return + | Static + | StringType + | Switch + | Throw + | Trait + | Try + | Typeof + | UintCast + | UnicodeCast + | Unset + | Use + | Var + | While + | Yield + | From + | Enum_ + | Match_ + | Ticks + | Encoding + | StrictTypes + | Get + | Set + | Call + | CallStatic + | Constructor + | Destruct + | Wakeup + | Sleep + | Autoload + | IsSet__ + | Unset__ + | ToString__ + | Invoke + | SetState + | Clone__ + | DebugInfo + | Namespace__ + | Class__ + | Traic__ + | Function__ + | Method__ + | Line__ + | File__ + | Dir__ + ; + +memberModifier + : Public + | Protected + | Private + | Static + | Abstract + | Final + | Readonly + ; + +magicConstant + : Namespace__ + | Class__ + | Traic__ + | Function__ + | Method__ + | Line__ + | File__ + | Dir__ + ; + +magicMethod + : Get + | Set + | Call + | CallStatic + | Constructor + | Destruct + | Wakeup + | Sleep + | Autoload + | IsSet__ + | Unset__ + | ToString__ + | Invoke + | SetState + | Clone__ + | DebugInfo + ; + +primitiveType + : BoolType + | IntType + | Int64Type + | DoubleType + | StringType + | Resource + | ObjectType + | Array + ; + +castOperation + : BoolType + | Int8Cast + | Int16Cast + | IntType + | Int64Type + | UintCast + | DoubleCast + | DoubleType + | FloatCast + | StringType + | BinaryCast + | UnicodeCast + | Array + | ObjectType + | Resource + | Unset + ; \ No newline at end of file diff --git a/app/src/main/java/antlr/PhpLexer.java b/app/src/main/java/antlr/PhpLexer.java new file mode 100644 index 0000000000000000000000000000000000000000..c47ccf0dddfbe65796031d44385a1b8063405f47 --- /dev/null +++ b/app/src/main/java/antlr/PhpLexer.java @@ -0,0 +1,1271 @@ +package antlr; + +// Generated from PhpLexer.g4 by ANTLR 4.5 +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class PhpLexer extends PhpLexerBase { + static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + SeaWhitespace=1, HtmlText=2, XmlStart=3, PHPStart=4, HtmlScriptOpen=5, + HtmlStyleOpen=6, HtmlComment=7, HtmlDtd=8, HtmlOpen=9, Shebang=10, Error=11, + XmlText=12, XmlClose=13, PHPStartInside=14, HtmlClose=15, HtmlSlashClose=16, + HtmlSlash=17, HtmlEquals=18, HtmlStartQuoteString=19, HtmlStartDoubleQuoteString=20, + HtmlHex=21, HtmlDecimal=22, HtmlSpace=23, HtmlName=24, ErrorInside=25, + PHPStartInsideQuoteString=26, HtmlEndQuoteString=27, HtmlQuoteString=28, + ErrorHtmlQuote=29, PHPStartDoubleQuoteString=30, HtmlEndDoubleQuoteString=31, + HtmlDoubleQuoteString=32, ErrorHtmlDoubleQuote=33, ScriptText=34, HtmlScriptClose=35, + PHPStartInsideScript=36, StyleBody=37, PHPEnd=38, Whitespace=39, MultiLineComment=40, + SingleLineComment=41, ShellStyleComment=42, AttributeStart=43, Abstract=44, + Array=45, As=46, BinaryCast=47, BoolType=48, BooleanConstant=49, Break=50, + Callable=51, Case=52, Catch=53, Class=54, Clone=55, Const=56, Continue=57, + Declare=58, Default=59, Do=60, DoubleCast=61, DoubleType=62, Echo=63, + Else=64, ElseIf=65, Empty=66, Enum_=67, EndDeclare=68, EndFor=69, EndForeach=70, + EndIf=71, EndSwitch=72, EndWhile=73, Eval=74, Exit=75, Extends=76, Final=77, + Finally=78, FloatCast=79, For=80, Foreach=81, Function_=82, Global=83, + Goto=84, If=85, Implements=86, Import=87, Include=88, IncludeOnce=89, + InstanceOf=90, InsteadOf=91, Int8Cast=92, Int16Cast=93, Int64Type=94, + IntType=95, Interface=96, IsSet=97, List=98, LogicalAnd=99, LogicalOr=100, + LogicalXor=101, Match_=102, Namespace=103, New=104, Null=105, ObjectType=106, + Parent_=107, Partial=108, Print=109, Private=110, Protected=111, Public=112, + Readonly=113, Require=114, RequireOnce=115, Resource=116, Return=117, + Static=118, StringType=119, Switch=120, Throw=121, Trait=122, Try=123, + Typeof=124, UintCast=125, UnicodeCast=126, Unset=127, Use=128, Var=129, + While=130, Yield=131, From=132, LambdaFn=133, Ticks=134, Encoding=135, + StrictTypes=136, Get=137, Set=138, Call=139, CallStatic=140, Constructor=141, + Destruct=142, Wakeup=143, Sleep=144, Autoload=145, IsSet__=146, Unset__=147, + ToString__=148, Invoke=149, SetState=150, Clone__=151, DebugInfo=152, + Namespace__=153, Class__=154, Traic__=155, Function__=156, Method__=157, + Line__=158, File__=159, Dir__=160, Spaceship=161, Lgeneric=162, Rgeneric=163, + DoubleArrow=164, Inc=165, Dec=166, IsIdentical=167, IsNoidentical=168, + IsEqual=169, IsNotEq=170, IsSmallerOrEqual=171, IsGreaterOrEqual=172, + PlusEqual=173, MinusEqual=174, MulEqual=175, Pow=176, PowEqual=177, DivEqual=178, + Concaequal=179, ModEqual=180, ShiftLeftEqual=181, ShiftRightEqual=182, + AndEqual=183, OrEqual=184, XorEqual=185, BooleanOr=186, BooleanAnd=187, + NullCoalescing=188, NullCoalescingEqual=189, ShiftLeft=190, ShiftRight=191, + DoubleColon=192, ObjectOperator=193, NamespaceSeparator=194, Ellipsis=195, + Less=196, Greater=197, Ampersand=198, Pipe=199, Bang=200, Caret=201, Plus=202, + Minus=203, Asterisk=204, Percent=205, Divide=206, Tilde=207, SuppressWarnings=208, + Dollar=209, Dot=210, QuestionMark=211, OpenRoundBracket=212, CloseRoundBracket=213, + OpenSquareBracket=214, CloseSquareBracket=215, OpenCurlyBracket=216, CloseCurlyBracket=217, + Comma=218, Colon=219, SemiColon=220, Eq=221, Quote=222, BackQuote=223, + VarName=224, Label=225, Octal=226, Decimal=227, Real=228, Hex=229, Binary=230, + BackQuoteString=231, SingleQuoteString=232, DoubleQuote=233, StartNowDoc=234, + StartHereDoc=235, ErrorPhp=236, CurlyDollar=237, UnicodeEscape=238, StringPart=239, + Comment=240, PHPEndSingleLineComment=241, CommentEnd=242, HereDocText=243, + XmlText2=244; + public static final int + PhpComments=2, ErrorLexem=3, SkipChannel=4; + public static final int XML = 1; + public static final int INSIDE = 2; + public static final int HtmlQuoteStringMode = 3; + public static final int HtmlDoubleQuoteStringMode = 4; + public static final int SCRIPT = 5; + public static final int STYLE = 6; + public static final int PHP = 7; + public static final int InterpolationString = 8; + public static final int SingleLineCommentMode = 9; + public static final int HereDoc = 10; + public static String[] modeNames = { + "DEFAULT_MODE", "XML", "INSIDE", "HtmlQuoteStringMode", "HtmlDoubleQuoteStringMode", + "SCRIPT", "STYLE", "PHP", "InterpolationString", "SingleLineCommentMode", + "HereDoc" + }; + + public static final String[] ruleNames = { + "SeaWhitespace", "HtmlText", "XmlStart", "PHPStartEcho", "PHPStart", "HtmlScriptOpen", + "HtmlStyleOpen", "HtmlComment", "HtmlDtd", "HtmlOpen", "Shebang", "NumberSign", + "Error", "XmlText", "XmlClose", "XmlText2", "PHPStartEchoInside", "PHPStartInside", + "HtmlClose", "HtmlSlashClose", "HtmlSlash", "HtmlEquals", "HtmlStartQuoteString", + "HtmlStartDoubleQuoteString", "HtmlHex", "HtmlDecimal", "HtmlSpace", "HtmlName", + "ErrorInside", "PHPStartEchoInsideQuoteString", "PHPStartInsideQuoteString", + "HtmlEndQuoteString", "HtmlQuoteString", "ErrorHtmlQuote", "PHPStartEchoDoubleQuoteString", + "PHPStartDoubleQuoteString", "HtmlEndDoubleQuoteString", "HtmlDoubleQuoteString", + "ErrorHtmlDoubleQuote", "ScriptText", "HtmlScriptClose", "PHPStartInsideScriptEcho", + "PHPStartInsideScript", "ScriptText2", "StyleBody", "PHPEnd", "Whitespace", + "MultiLineComment", "SingleLineComment", "ShellStyleComment", "AttributeStart", + "Abstract", "Array", "As", "BinaryCast", "BoolType", "BooleanConstant", + "Break", "Callable", "Case", "Catch", "Class", "Clone", "Const", "Continue", + "Declare", "Default", "Do", "DoubleCast", "DoubleType", "Echo", "Else", + "ElseIf", "Empty", "Enum_", "EndDeclare", "EndFor", "EndForeach", "EndIf", + "EndSwitch", "EndWhile", "Eval", "Exit", "Extends", "Final", "Finally", + "FloatCast", "For", "Foreach", "Function_", "Global", "Goto", "If", "Implements", + "Import", "Include", "IncludeOnce", "InstanceOf", "InsteadOf", "Int8Cast", + "Int16Cast", "Int64Type", "IntType", "Interface", "IsSet", "List", "LogicalAnd", + "LogicalOr", "LogicalXor", "Match_", "Namespace", "New", "Null", "ObjectType", + "Parent_", "Partial", "Print", "Private", "Protected", "Public", "Readonly", + "Require", "RequireOnce", "Resource", "Return", "Static", "StringType", + "Switch", "Throw", "Trait", "Try", "Typeof", "UintCast", "UnicodeCast", + "Unset", "Use", "Var", "While", "Yield", "From", "LambdaFn", "Ticks", + "Encoding", "StrictTypes", "Get", "Set", "Call", "CallStatic", "Constructor", + "Destruct", "Wakeup", "Sleep", "Autoload", "IsSet__", "Unset__", "ToString__", + "Invoke", "SetState", "Clone__", "DebugInfo", "Namespace__", "Class__", + "Traic__", "Function__", "Method__", "Line__", "File__", "Dir__", "Spaceship", + "Lgeneric", "Rgeneric", "DoubleArrow", "Inc", "Dec", "IsIdentical", "IsNoidentical", + "IsEqual", "IsNotEq", "IsSmallerOrEqual", "IsGreaterOrEqual", "PlusEqual", + "MinusEqual", "MulEqual", "Pow", "PowEqual", "DivEqual", "Concaequal", + "ModEqual", "ShiftLeftEqual", "ShiftRightEqual", "AndEqual", "OrEqual", + "XorEqual", "BooleanOr", "BooleanAnd", "NullCoalescing", "NullCoalescingEqual", + "ShiftLeft", "ShiftRight", "DoubleColon", "ObjectOperator", "NamespaceSeparator", + "Ellipsis", "Less", "Greater", "Ampersand", "Pipe", "Bang", "Caret", "Plus", + "Minus", "Asterisk", "Percent", "Divide", "Tilde", "SuppressWarnings", + "Dollar", "Dot", "QuestionMark", "OpenRoundBracket", "CloseRoundBracket", + "OpenSquareBracket", "CloseSquareBracket", "OpenCurlyBracket", "CloseCurlyBracket", + "Comma", "Colon", "SemiColon", "Eq", "Quote", "BackQuote", "VarName", + "Label", "Octal", "Decimal", "Real", "Hex", "Binary", "BackQuoteString", + "SingleQuoteString", "DoubleQuote", "StartNowDoc", "StartHereDoc", "ErrorPhp", + "VarNameInInterpolation", "DollarString", "CurlyDollar", "CurlyString", + "EscapedChar", "DoubleQuoteInInterpolation", "UnicodeEscape", "StringPart", + "Comment", "PHPEndSingleLineComment", "CommentQuestionMark", "CommentEnd", + "HereDocText", "PhpStartEchoFragment", "PhpStartFragment", "NameString", + "HtmlNameChar", "HtmlNameStartChar", "LNum", "ExponentPart", "NonZeroDigit", + "Digit", "OctalDigit", "HexDigit" + }; + + private static final String[] _LITERAL_NAMES = { + null, null, null, "'<?xml'", null, null, null, null, null, null, null, + null, null, "'?>'", null, null, "'/>'", null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, "'#['", "'abstract'", + "'array'", "'as'", "'binary'", null, null, "'break'", "'callable'", "'case'", + "'catch'", "'class'", "'clone'", "'const'", "'continue'", "'declare'", + "'default'", "'do'", "'real'", "'double'", "'echo'", "'else'", "'elseif'", + "'empty'", "'enum'", "'enddeclare'", "'endfor'", "'endforeach'", "'endif'", + "'endswitch'", "'endwhile'", "'eval'", "'die'", "'extends'", "'final'", + "'finally'", "'float'", "'for'", "'foreach'", "'function'", "'global'", + "'goto'", "'if'", "'implements'", "'import'", "'include'", "'include_once'", + "'instanceof'", "'insteadof'", "'int8'", "'int16'", "'int64'", null, "'interface'", + "'isset'", "'list'", "'and'", "'or'", "'xor'", "'match'", "'namespace'", + "'new'", "'null'", "'object'", "'parent'", "'partial'", "'print'", "'private'", + "'protected'", "'public'", "'readonly'", "'require'", "'require_once'", + "'resource'", "'return'", "'static'", "'string'", "'switch'", "'throw'", + "'trait'", "'try'", "'clrtypeof'", null, "'unicode'", "'unset'", "'use'", + "'var'", "'while'", "'yield'", "'from'", "'fn'", "'ticks'", "'encoding'", + "'strict_types'", "'__get'", "'__set'", "'__call'", "'__callstatic'", + "'__construct'", "'__destruct'", "'__wakeup'", "'__sleep'", "'__autoload'", + "'__isset'", "'__unset'", "'__tostring'", "'__invoke'", "'__set_state'", + "'__clone'", "'__debuginfo'", "'__namespace__'", "'__class__'", "'__trait__'", + "'__function__'", "'__method__'", "'__line__'", "'__file__'", "'__dir__'", + "'<=>'", "'<:'", "':>'", "'=>'", "'++'", "'--'", "'==='", "'!=='", "'=='", + null, "'<='", "'>='", "'+='", "'-='", "'*='", "'**'", "'**='", "'/='", + "'.='", "'%='", "'<<='", "'>>='", "'&='", "'|='", "'^='", "'||'", "'&&'", + "'??'", "'??='", "'<<'", "'>>'", "'::'", "'->'", "'\\'", "'...'", null, + null, "'&'", "'|'", "'!'", "'^'", "'+'", "'-'", "'*'", "'%'", null, "'~'", + "'@'", null, "'.'", null, "'('", "')'", "'['", "']'", null, "'}'", "','", + "':'", "';'", null, "'''", "'`'" + }; + private static final String[] _SYMBOLIC_NAMES = { + null, "SeaWhitespace", "HtmlText", "XmlStart", "PHPStart", "HtmlScriptOpen", + "HtmlStyleOpen", "HtmlComment", "HtmlDtd", "HtmlOpen", "Shebang", "Error", + "XmlText", "XmlClose", "PHPStartInside", "HtmlClose", "HtmlSlashClose", + "HtmlSlash", "HtmlEquals", "HtmlStartQuoteString", "HtmlStartDoubleQuoteString", + "HtmlHex", "HtmlDecimal", "HtmlSpace", "HtmlName", "ErrorInside", "PHPStartInsideQuoteString", + "HtmlEndQuoteString", "HtmlQuoteString", "ErrorHtmlQuote", "PHPStartDoubleQuoteString", + "HtmlEndDoubleQuoteString", "HtmlDoubleQuoteString", "ErrorHtmlDoubleQuote", + "ScriptText", "HtmlScriptClose", "PHPStartInsideScript", "StyleBody", + "PHPEnd", "Whitespace", "MultiLineComment", "SingleLineComment", "ShellStyleComment", + "AttributeStart", "Abstract", "Array", "As", "BinaryCast", "BoolType", + "BooleanConstant", "Break", "Callable", "Case", "Catch", "Class", "Clone", + "Const", "Continue", "Declare", "Default", "Do", "DoubleCast", "DoubleType", + "Echo", "Else", "ElseIf", "Empty", "Enum_", "EndDeclare", "EndFor", "EndForeach", + "EndIf", "EndSwitch", "EndWhile", "Eval", "Exit", "Extends", "Final", + "Finally", "FloatCast", "For", "Foreach", "Function_", "Global", "Goto", + "If", "Implements", "Import", "Include", "IncludeOnce", "InstanceOf", + "InsteadOf", "Int8Cast", "Int16Cast", "Int64Type", "IntType", "Interface", + "IsSet", "List", "LogicalAnd", "LogicalOr", "LogicalXor", "Match_", "Namespace", + "New", "Null", "ObjectType", "Parent_", "Partial", "Print", "Private", + "Protected", "Public", "Readonly", "Require", "RequireOnce", "Resource", + "Return", "Static", "StringType", "Switch", "Throw", "Trait", "Try", "Typeof", + "UintCast", "UnicodeCast", "Unset", "Use", "Var", "While", "Yield", "From", + "LambdaFn", "Ticks", "Encoding", "StrictTypes", "Get", "Set", "Call", + "CallStatic", "Constructor", "Destruct", "Wakeup", "Sleep", "Autoload", + "IsSet__", "Unset__", "ToString__", "Invoke", "SetState", "Clone__", "DebugInfo", + "Namespace__", "Class__", "Traic__", "Function__", "Method__", "Line__", + "File__", "Dir__", "Spaceship", "Lgeneric", "Rgeneric", "DoubleArrow", + "Inc", "Dec", "IsIdentical", "IsNoidentical", "IsEqual", "IsNotEq", "IsSmallerOrEqual", + "IsGreaterOrEqual", "PlusEqual", "MinusEqual", "MulEqual", "Pow", "PowEqual", + "DivEqual", "Concaequal", "ModEqual", "ShiftLeftEqual", "ShiftRightEqual", + "AndEqual", "OrEqual", "XorEqual", "BooleanOr", "BooleanAnd", "NullCoalescing", + "NullCoalescingEqual", "ShiftLeft", "ShiftRight", "DoubleColon", "ObjectOperator", + "NamespaceSeparator", "Ellipsis", "Less", "Greater", "Ampersand", "Pipe", + "Bang", "Caret", "Plus", "Minus", "Asterisk", "Percent", "Divide", "Tilde", + "SuppressWarnings", "Dollar", "Dot", "QuestionMark", "OpenRoundBracket", + "CloseRoundBracket", "OpenSquareBracket", "CloseSquareBracket", "OpenCurlyBracket", + "CloseCurlyBracket", "Comma", "Colon", "SemiColon", "Eq", "Quote", "BackQuote", + "VarName", "Label", "Octal", "Decimal", "Real", "Hex", "Binary", "BackQuoteString", + "SingleQuoteString", "DoubleQuote", "StartNowDoc", "StartHereDoc", "ErrorPhp", + "CurlyDollar", "UnicodeEscape", "StringPart", "Comment", "PHPEndSingleLineComment", + "CommentEnd", "HereDocText", "XmlText2" + }; + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = "<INVALID>"; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public PhpLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "PhpLexer.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + @Override + public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { + switch (ruleIndex) { + case 5: + HtmlScriptOpen_action((RuleContext)_localctx, actionIndex); + break; + case 6: + HtmlStyleOpen_action((RuleContext)_localctx, actionIndex); + break; + case 18: + HtmlClose_action((RuleContext)_localctx, actionIndex); + break; + case 224: + CloseCurlyBracket_action((RuleContext)_localctx, actionIndex); + break; + case 246: + CurlyDollar_action((RuleContext)_localctx, actionIndex); + break; + } + } + private void HtmlScriptOpen_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 0: + this._scriptTag = true; + break; + } + } + private void HtmlStyleOpen_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 1: + this._styleTag = true; + break; + } + } + private void HtmlClose_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 2: + this.PushModeOnHtmlClose(); + break; + } + } + private void CloseCurlyBracket_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 3: + this.PopModeOnCurlyBracketClose(); + break; + } + } + private void CurlyDollar_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 4: + this.SetInsideString(); + break; + } + } + @Override + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 10: + return Shebang_sempred((RuleContext)_localctx, predIndex); + case 45: + return PHPEnd_sempred((RuleContext)_localctx, predIndex); + case 241: + return StartNowDoc_sempred((RuleContext)_localctx, predIndex); + case 242: + return StartHereDoc_sempred((RuleContext)_localctx, predIndex); + case 246: + return CurlyDollar_sempred((RuleContext)_localctx, predIndex); + case 257: + return PhpStartEchoFragment_sempred((RuleContext)_localctx, predIndex); + case 258: + return PhpStartFragment_sempred((RuleContext)_localctx, predIndex); + } + return true; + } + private boolean Shebang_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return this.IsNewLineOrStart(-2) ; + } + return true; + } + private boolean PHPEnd_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return this.HasAspTags(); + case 2: + return this.HasPhpScriptTag(); + } + return true; + } + private boolean StartNowDoc_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 3: + return this.ShouldPushHereDocMode(1) ; + } + return true; + } + private boolean StartHereDoc_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 4: + return this.ShouldPushHereDocMode(1) ; + } + return true; + } + private boolean CurlyDollar_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 5: + return this.IsCurlyDollar(1) ; + } + return true; + } + private boolean PhpStartEchoFragment_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 6: + return this.HasAspTags() ; + } + return true; + } + private boolean PhpStartFragment_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 7: + return this.HasAspTags() ; + } + return true; + } + + public static final String _serializedATN = + "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\u00f6\u08e4\b\1\b"+ + "\1\b\1\b\1\b\1\b\1\b\1\b\1\b\1\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5"+ + "\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16"+ + "\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25"+ + "\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34"+ + "\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4"+ + "%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60"+ + "\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67"+ + "\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\t"+ + "B\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4"+ + "N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\t"+ + "Y\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td"+ + "\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p"+ + "\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{"+ + "\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080\4\u0081\t\u0081\4\u0082"+ + "\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086"+ + "\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b"+ + "\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e\4\u008f\t\u008f"+ + "\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094"+ + "\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098"+ + "\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c\4\u009d"+ + "\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0\t\u00a0\4\u00a1\t\u00a1"+ + "\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6"+ + "\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa"+ + "\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae\t\u00ae\4\u00af"+ + "\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2\t\u00b2\4\u00b3\t\u00b3"+ + "\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8"+ + "\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc\t\u00bc"+ + "\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf\4\u00c0\t\u00c0\4\u00c1"+ + "\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5"+ + "\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca"+ + "\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd\t\u00cd\4\u00ce\t\u00ce"+ + "\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3"+ + "\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7"+ + "\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db\t\u00db\4\u00dc"+ + "\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df\t\u00df\4\u00e0\t\u00e0"+ + "\4\u00e1\t\u00e1\4\u00e2\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5"+ + "\t\u00e5\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9\t\u00e9"+ + "\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec\4\u00ed\t\u00ed\4\u00ee"+ + "\t\u00ee\4\u00ef\t\u00ef\4\u00f0\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2"+ + "\4\u00f3\t\u00f3\4\u00f4\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7"+ + "\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa\4\u00fb\t\u00fb"+ + "\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe\t\u00fe\4\u00ff\t\u00ff\4\u0100"+ + "\t\u0100\4\u0101\t\u0101\4\u0102\t\u0102\4\u0103\t\u0103\4\u0104\t\u0104"+ + "\4\u0105\t\u0105\4\u0106\t\u0106\4\u0107\t\u0107\4\u0108\t\u0108\4\u0109"+ + "\t\u0109\4\u010a\t\u010a\4\u010b\t\u010b\4\u010c\t\u010c\4\u010d\t\u010d"+ + "\3\2\6\2\u0227\n\2\r\2\16\2\u0228\3\2\3\2\3\3\6\3\u022e\n\3\r\3\16\3\u022f"+ + "\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3"+ + "\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b"+ + "\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u0262\n\t\f\t"+ + "\16\t\u0265\13\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\7\n\u0271\n\n"+ + "\f\n\16\n\u0274\13\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\7\f\u0280"+ + "\n\f\f\f\16\f\u0283\13\f\3\r\3\r\7\r\u0287\n\r\f\r\16\r\u028a\13\r\3\r"+ + "\3\r\3\16\3\16\3\16\3\16\3\17\6\17\u0293\n\17\r\17\16\17\u0294\3\20\3"+ + "\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\23\3"+ + "\23\3\23\3\23\3\23\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3"+ + "\27\3\27\3\30\5\30\u02b7\n\30\3\30\3\30\3\30\3\30\3\31\5\31\u02be\n\31"+ + "\3\31\3\31\3\31\3\31\3\32\3\32\6\32\u02c6\n\32\r\32\16\32\u02c7\3\33\6"+ + "\33\u02cb\n\33\r\33\16\33\u02cc\3\34\6\34\u02d0\n\34\r\34\16\34\u02d1"+ + "\3\34\3\34\3\35\3\35\7\35\u02d8\n\35\f\35\16\35\u02db\13\35\3\36\3\36"+ + "\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \3!\3!\5!\u02ed\n!\3"+ + "!\3!\3\"\6\"\u02f2\n\"\r\"\16\"\u02f3\3#\3#\3#\3#\3$\3$\3$\3$\3$\3%\3"+ + "%\3%\3%\3%\3&\3&\5&\u0306\n&\3&\3&\3\'\6\'\u030b\n\'\r\'\16\'\u030c\3"+ + "(\3(\3(\3(\3)\6)\u0314\n)\r)\16)\u0315\3*\3*\3*\3*\3*\3*\3*\3*\3*\5*\u0321"+ + "\n*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3,\3,\3,\3,\3,\3-\3-\3-\3-\3.\7.\u0336"+ + "\n.\f.\16.\u0339\13.\3.\3.\3.\3.\3.\3.\3.\3.\5.\u0343\n.\3.\3.\3.\3.\3"+ + "/\3/\3/\5/\u034c\n/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u035a\n/\3"+ + "\60\6\60\u035d\n\60\r\60\16\60\u035e\3\60\3\60\3\61\3\61\3\61\3\61\7\61"+ + "\u0367\n\61\f\61\16\61\u036a\13\61\3\61\3\61\3\61\3\61\3\61\3\62\3\62"+ + "\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\65\3\65"+ + "\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3\66\3\66\3\67"+ + "\3\67\3\67\38\38\38\38\38\38\38\39\39\39\39\39\39\39\39\59\u03a0\n9\3"+ + ":\3:\3:\3:\3:\3:\3:\3:\3:\5:\u03ab\n:\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3"+ + "<\3<\3<\3<\3<\3=\3=\3=\3=\3=\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3@\3"+ + "@\3@\3@\3@\3@\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B\3C\3C\3C\3"+ + "C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3D\3E\3E\3E\3F\3F\3F\3F\3F\3G\3G\3"+ + "G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3J\3J\3J\3J\3J\3J\3J\3K\3"+ + "K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3N\3N\3"+ + "N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3Q\3"+ + "Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3"+ + "T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3"+ + "W\3W\3W\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3[\3[\3"+ + "[\3[\3[\3[\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3]\3]\3]\3]\3]\3^\3^\3"+ + "^\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3`\3`\3a\3a\3a\3a\3"+ + "a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3"+ + "c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3f\3f\3f\3"+ + "f\3f\3f\3g\3g\3g\3g\3g\3g\3h\3h\3h\3h\3h\3h\3h\3h\5h\u04f1\nh\3i\3i\3"+ + "i\3i\3i\3i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3k\3k\3k\3k\3k\3l\3l\3l\3l\3"+ + "m\3m\3m\3n\3n\3n\3n\3o\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3"+ + "q\3q\3q\3q\3r\3r\3r\3r\3r\3s\3s\3s\3s\3s\3s\3s\3t\3t\3t\3t\3t\3t\3t\3"+ + "u\3u\3u\3u\3u\3u\3u\3u\3v\3v\3v\3v\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3x\3"+ + "x\3x\3x\3x\3x\3x\3x\3x\3x\3y\3y\3y\3y\3y\3y\3y\3z\3z\3z\3z\3z\3z\3z\3"+ + "z\3z\3{\3{\3{\3{\3{\3{\3{\3{\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3"+ + "}\3}\3}\3}\3}\3}\3}\3}\3}\3~\3~\3~\3~\3~\3~\3~\3\177\3\177\3\177\3\177"+ + "\3\177\3\177\3\177\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080"+ + "\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0082\3\u0082"+ + "\3\u0082\3\u0082\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083"+ + "\3\u0083\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085"+ + "\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086"+ + "\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u05c8"+ + "\n\u0086\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087"+ + "\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089"+ + "\3\u0089\3\u008a\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008b"+ + "\3\u008b\3\u008b\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008d"+ + "\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f"+ + "\3\u008f\3\u008f\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090"+ + "\3\u0090\3\u0090\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091"+ + "\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0092"+ + "\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093\3\u0093"+ + "\3\u0093\3\u0093\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094"+ + "\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095"+ + "\3\u0095\3\u0095\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096"+ + "\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0097\3\u0097"+ + "\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097"+ + "\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098"+ + "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u009a"+ + "\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a"+ + "\3\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b"+ + "\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009d"+ + "\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d"+ + "\3\u009d\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e"+ + "\3\u009e\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f"+ + "\3\u009f\3\u009f\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0"+ + "\3\u00a0\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1"+ + "\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2"+ + "\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2"+ + "\3\u00a2\3\u00a2\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3"+ + "\3\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4"+ + "\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5"+ + "\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a6"+ + "\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6"+ + "\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7"+ + "\3\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8"+ + "\3\u00a8\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9"+ + "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac"+ + "\3\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00af\3\u00af"+ + "\3\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1\3\u00b1\3\u00b1\3\u00b1"+ + "\3\u00b2\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\5\u00b3\u071d"+ + "\n\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5\3\u00b5\3\u00b6\3\u00b6"+ + "\3\u00b6\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b9\3\u00b9"+ + "\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bc"+ + "\3\u00bc\3\u00bc\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be\3\u00be\3\u00be"+ + "\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1"+ + "\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c4\3\u00c4"+ + "\3\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c7"+ + "\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00ca"+ + "\3\u00ca\3\u00ca\3\u00cb\3\u00cb\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cd"+ + "\3\u00cd\3\u00ce\3\u00ce\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d1\3\u00d1"+ + "\3\u00d2\3\u00d2\3\u00d3\3\u00d3\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d6"+ + "\3\u00d6\3\u00d7\3\u00d7\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00da\3\u00da"+ + "\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dd\3\u00dd\3\u00de\3\u00de\3\u00df"+ + "\3\u00df\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e2\3\u00e2\3\u00e2\3\u00e3"+ + "\3\u00e3\3\u00e4\3\u00e4\3\u00e5\3\u00e5\3\u00e6\3\u00e6\3\u00e7\3\u00e7"+ + "\3\u00e8\3\u00e8\3\u00e9\3\u00e9\3\u00e9\3\u00ea\3\u00ea\7\u00ea\u07ac"+ + "\n\u00ea\f\u00ea\16\u00ea\u07af\13\u00ea\3\u00eb\3\u00eb\5\u00eb\u07b3"+ + "\n\u00eb\3\u00eb\6\u00eb\u07b6\n\u00eb\r\u00eb\16\u00eb\u07b7\3\u00eb"+ + "\3\u00eb\6\u00eb\u07bc\n\u00eb\r\u00eb\16\u00eb\u07bd\7\u00eb\u07c0\n"+ + "\u00eb\f\u00eb\16\u00eb\u07c3\13\u00eb\3\u00ec\3\u00ec\3\u00ec\7\u00ec"+ + "\u07c8\n\u00ec\f\u00ec\16\u00ec\u07cb\13\u00ec\3\u00ec\3\u00ec\6\u00ec"+ + "\u07cf\n\u00ec\r\u00ec\16\u00ec\u07d0\7\u00ec\u07d3\n\u00ec\f\u00ec\16"+ + "\u00ec\u07d6\13\u00ec\5\u00ec\u07d8\n\u00ec\3\u00ed\3\u00ed\3\u00ed\5"+ + "\u00ed\u07dd\n\u00ed\3\u00ed\5\u00ed\u07e0\n\u00ed\3\u00ed\3\u00ed\5\u00ed"+ + "\u07e4\n\u00ed\3\u00ed\5\u00ed\u07e7\n\u00ed\3\u00ed\6\u00ed\u07ea\n\u00ed"+ + "\r\u00ed\16\u00ed\u07eb\3\u00ed\3\u00ed\5\u00ed\u07f0\n\u00ed\3\u00ee"+ + "\3\u00ee\3\u00ee\3\u00ee\6\u00ee\u07f6\n\u00ee\r\u00ee\16\u00ee\u07f7"+ + "\3\u00ee\3\u00ee\6\u00ee\u07fc\n\u00ee\r\u00ee\16\u00ee\u07fd\7\u00ee"+ + "\u0800\n\u00ee\f\u00ee\16\u00ee\u0803\13\u00ee\3\u00ef\3\u00ef\3\u00ef"+ + "\3\u00ef\6\u00ef\u0809\n\u00ef\r\u00ef\16\u00ef\u080a\3\u00ef\3\u00ef"+ + "\6\u00ef\u080f\n\u00ef\r\u00ef\16\u00ef\u0810\7\u00ef\u0813\n\u00ef\f"+ + "\u00ef\16\u00ef\u0816\13\u00ef\3\u00f0\3\u00f0\7\u00f0\u081a\n\u00f0\f"+ + "\u00f0\16\u00f0\u081d\13\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1\3\u00f1"+ + "\3\u00f1\7\u00f1\u0825\n\u00f1\f\u00f1\16\u00f1\u0828\13\u00f1\3\u00f1"+ + "\3\u00f1\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3"+ + "\3\u00f3\7\u00f3\u0835\n\u00f3\f\u00f3\16\u00f3\u0838\13\u00f3\3\u00f3"+ + "\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f4"+ + "\3\u00f4\3\u00f4\7\u00f4\u0846\n\u00f4\f\u00f4\16\u00f4\u0849\13\u00f4"+ + "\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f5\3\u00f5\3\u00f5\3\u00f5"+ + "\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f7\3\u00f7\3\u00f7\3\u00f7"+ + "\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9"+ + "\3\u00f9\3\u00f9\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fb\3\u00fb"+ + "\3\u00fb\3\u00fb\3\u00fb\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fc"+ + "\6\u00fc\u0878\n\u00fc\r\u00fc\16\u00fc\u0879\3\u00fc\3\u00fc\3\u00fd"+ + "\6\u00fd\u087f\n\u00fd\r\u00fd\16\u00fd\u0880\3\u00fe\6\u00fe\u0884\n"+ + "\u00fe\r\u00fe\16\u00fe\u0885\3\u00fe\3\u00fe\3\u00ff\3\u00ff\3\u00ff"+ + "\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0101\3\u0101\3\u0101\3\u0101"+ + "\3\u0101\3\u0102\7\u0102\u0898\n\u0102\f\u0102\16\u0102\u089b\13\u0102"+ + "\3\u0102\5\u0102\u089e\n\u0102\3\u0102\3\u0102\5\u0102\u08a2\n\u0102\3"+ + "\u0103\3\u0103\3\u0103\3\u0103\3\u0103\3\u0103\5\u0103\u08aa\n\u0103\3"+ + "\u0104\3\u0104\3\u0104\3\u0104\3\u0104\5\u0104\u08b1\n\u0104\3\u0104\3"+ + "\u0104\5\u0104\u08b5\n\u0104\3\u0105\3\u0105\7\u0105\u08b9\n\u0105\f\u0105"+ + "\16\u0105\u08bc\13\u0105\3\u0106\3\u0106\3\u0106\3\u0106\5\u0106\u08c2"+ + "\n\u0106\3\u0107\5\u0107\u08c5\n\u0107\3\u0108\6\u0108\u08c8\n\u0108\r"+ + "\u0108\16\u0108\u08c9\3\u0108\3\u0108\6\u0108\u08ce\n\u0108\r\u0108\16"+ + "\u0108\u08cf\7\u0108\u08d2\n\u0108\f\u0108\16\u0108\u08d5\13\u0108\3\u0109"+ + "\3\u0109\5\u0109\u08d9\n\u0109\3\u0109\3\u0109\3\u010a\3\u010a\3\u010b"+ + "\3\u010b\3\u010c\3\u010c\3\u010d\3\u010d\7\u0263\u0272\u0337\u0368\u0899"+ + "\2\u010e\r\3\17\4\21\5\23\2\25\6\27\7\31\b\33\t\35\n\37\13!\f#\2%\r\'"+ + "\16)\17+\u00f6-\2/\20\61\21\63\22\65\23\67\249\25;\26=\27?\30A\31C\32"+ + "E\33G\2I\34K\35M\36O\37Q\2S U!W\"Y#[$]%_\2a&c\2e\'g(i)k*m+o,q-s.u/w\60"+ + "y\61{\62}\63\177\64\u0081\65\u0083\66\u0085\67\u00878\u00899\u008b:\u008d"+ + ";\u008f<\u0091=\u0093>\u0095?\u0097@\u0099A\u009bB\u009dC\u009fD\u00a1"+ + "E\u00a3F\u00a5G\u00a7H\u00a9I\u00abJ\u00adK\u00afL\u00b1M\u00b3N\u00b5"+ + "O\u00b7P\u00b9Q\u00bbR\u00bdS\u00bfT\u00c1U\u00c3V\u00c5W\u00c7X\u00c9"+ + "Y\u00cbZ\u00cd[\u00cf\\\u00d1]\u00d3^\u00d5_\u00d7`\u00d9a\u00dbb\u00dd"+ + "c\u00dfd\u00e1e\u00e3f\u00e5g\u00e7h\u00e9i\u00ebj\u00edk\u00efl\u00f1"+ + "m\u00f3n\u00f5o\u00f7p\u00f9q\u00fbr\u00fds\u00fft\u0101u\u0103v\u0105"+ + "w\u0107x\u0109y\u010bz\u010d{\u010f|\u0111}\u0113~\u0115\177\u0117\u0080"+ + "\u0119\u0081\u011b\u0082\u011d\u0083\u011f\u0084\u0121\u0085\u0123\u0086"+ + "\u0125\u0087\u0127\u0088\u0129\u0089\u012b\u008a\u012d\u008b\u012f\u008c"+ + "\u0131\u008d\u0133\u008e\u0135\u008f\u0137\u0090\u0139\u0091\u013b\u0092"+ + "\u013d\u0093\u013f\u0094\u0141\u0095\u0143\u0096\u0145\u0097\u0147\u0098"+ + "\u0149\u0099\u014b\u009a\u014d\u009b\u014f\u009c\u0151\u009d\u0153\u009e"+ + "\u0155\u009f\u0157\u00a0\u0159\u00a1\u015b\u00a2\u015d\u00a3\u015f\u00a4"+ + "\u0161\u00a5\u0163\u00a6\u0165\u00a7\u0167\u00a8\u0169\u00a9\u016b\u00aa"+ + "\u016d\u00ab\u016f\u00ac\u0171\u00ad\u0173\u00ae\u0175\u00af\u0177\u00b0"+ + "\u0179\u00b1\u017b\u00b2\u017d\u00b3\u017f\u00b4\u0181\u00b5\u0183\u00b6"+ + "\u0185\u00b7\u0187\u00b8\u0189\u00b9\u018b\u00ba\u018d\u00bb\u018f\u00bc"+ + "\u0191\u00bd\u0193\u00be\u0195\u00bf\u0197\u00c0\u0199\u00c1\u019b\u00c2"+ + "\u019d\u00c3\u019f\u00c4\u01a1\u00c5\u01a3\u00c6\u01a5\u00c7\u01a7\u00c8"+ + "\u01a9\u00c9\u01ab\u00ca\u01ad\u00cb\u01af\u00cc\u01b1\u00cd\u01b3\u00ce"+ + "\u01b5\u00cf\u01b7\u00d0\u01b9\u00d1\u01bb\u00d2\u01bd\u00d3\u01bf\u00d4"+ + "\u01c1\u00d5\u01c3\u00d6\u01c5\u00d7\u01c7\u00d8\u01c9\u00d9\u01cb\u00da"+ + "\u01cd\u00db\u01cf\u00dc\u01d1\u00dd\u01d3\u00de\u01d5\u00df\u01d7\u00e0"+ + "\u01d9\u00e1\u01db\u00e2\u01dd\u00e3\u01df\u00e4\u01e1\u00e5\u01e3\u00e6"+ + "\u01e5\u00e7\u01e7\u00e8\u01e9\u00e9\u01eb\u00ea\u01ed\u00eb\u01ef\u00ec"+ + "\u01f1\u00ed\u01f3\u00ee\u01f5\2\u01f7\2\u01f9\u00ef\u01fb\2\u01fd\2\u01ff"+ + "\2\u0201\u00f0\u0203\u00f1\u0205\u00f2\u0207\u00f3\u0209\2\u020b\u00f4"+ + "\u020d\u00f5\u020f\2\u0211\2\u0213\2\u0215\2\u0217\2\u0219\2\u021b\2\u021d"+ + "\2\u021f\2\u0221\2\u0223\2\r\2\3\4\5\6\7\b\t\n\13\f\34\5\2\13\f\17\17"+ + "\"\"\4\2%%>>\4\2\f\f\17\17\3\2>>\3\2AA\4\2))>>\4\2$$>>\4\2aac|\5\2\62"+ + ";aac|\3\2\62\63\3\2bb\4\2))^^\4\2\13\13\"\"\4\2\62;c|\6\2$$&&^^}}\5\2"+ + "\f\f\17\17AA\6\2C\\aac|\u0082\0\7\2\62;C\\aac|\u0082\0\4\2/\60aa\5\2\u00b9"+ + "\u00b9\u0302\u0371\u2041\u2042\n\2<<C\\c|\u2072\u2191\u2c02\u2ff1\u3003"+ + "\ud801\uf902\ufdd1\ufdf2\uffff\4\2--//\3\2\63;\3\2\62;\3\2\629\4\2\62"+ + ";ch\u0919\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2"+ + "\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2"+ + "\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\3\'\3\2\2\2\3)\3\2\2\2\3+\3\2\2\2\4"+ + "-\3\2\2\2\4/\3\2\2\2\4\61\3\2\2\2\4\63\3\2\2\2\4\65\3\2\2\2\4\67\3\2\2"+ + "\2\49\3\2\2\2\4;\3\2\2\2\4=\3\2\2\2\4?\3\2\2\2\4A\3\2\2\2\4C\3\2\2\2\4"+ + "E\3\2\2\2\5G\3\2\2\2\5I\3\2\2\2\5K\3\2\2\2\5M\3\2\2\2\5O\3\2\2\2\6Q\3"+ + "\2\2\2\6S\3\2\2\2\6U\3\2\2\2\6W\3\2\2\2\6Y\3\2\2\2\7[\3\2\2\2\7]\3\2\2"+ + "\2\7_\3\2\2\2\7a\3\2\2\2\7c\3\2\2\2\be\3\2\2\2\tg\3\2\2\2\ti\3\2\2\2\t"+ + "k\3\2\2\2\tm\3\2\2\2\to\3\2\2\2\tq\3\2\2\2\ts\3\2\2\2\tu\3\2\2\2\tw\3"+ + "\2\2\2\ty\3\2\2\2\t{\3\2\2\2\t}\3\2\2\2\t\177\3\2\2\2\t\u0081\3\2\2\2"+ + "\t\u0083\3\2\2\2\t\u0085\3\2\2\2\t\u0087\3\2\2\2\t\u0089\3\2\2\2\t\u008b"+ + "\3\2\2\2\t\u008d\3\2\2\2\t\u008f\3\2\2\2\t\u0091\3\2\2\2\t\u0093\3\2\2"+ + "\2\t\u0095\3\2\2\2\t\u0097\3\2\2\2\t\u0099\3\2\2\2\t\u009b\3\2\2\2\t\u009d"+ + "\3\2\2\2\t\u009f\3\2\2\2\t\u00a1\3\2\2\2\t\u00a3\3\2\2\2\t\u00a5\3\2\2"+ + "\2\t\u00a7\3\2\2\2\t\u00a9\3\2\2\2\t\u00ab\3\2\2\2\t\u00ad\3\2\2\2\t\u00af"+ + "\3\2\2\2\t\u00b1\3\2\2\2\t\u00b3\3\2\2\2\t\u00b5\3\2\2\2\t\u00b7\3\2\2"+ + "\2\t\u00b9\3\2\2\2\t\u00bb\3\2\2\2\t\u00bd\3\2\2\2\t\u00bf\3\2\2\2\t\u00c1"+ + "\3\2\2\2\t\u00c3\3\2\2\2\t\u00c5\3\2\2\2\t\u00c7\3\2\2\2\t\u00c9\3\2\2"+ + "\2\t\u00cb\3\2\2\2\t\u00cd\3\2\2\2\t\u00cf\3\2\2\2\t\u00d1\3\2\2\2\t\u00d3"+ + "\3\2\2\2\t\u00d5\3\2\2\2\t\u00d7\3\2\2\2\t\u00d9\3\2\2\2\t\u00db\3\2\2"+ + "\2\t\u00dd\3\2\2\2\t\u00df\3\2\2\2\t\u00e1\3\2\2\2\t\u00e3\3\2\2\2\t\u00e5"+ + "\3\2\2\2\t\u00e7\3\2\2\2\t\u00e9\3\2\2\2\t\u00eb\3\2\2\2\t\u00ed\3\2\2"+ + "\2\t\u00ef\3\2\2\2\t\u00f1\3\2\2\2\t\u00f3\3\2\2\2\t\u00f5\3\2\2\2\t\u00f7"+ + "\3\2\2\2\t\u00f9\3\2\2\2\t\u00fb\3\2\2\2\t\u00fd\3\2\2\2\t\u00ff\3\2\2"+ + "\2\t\u0101\3\2\2\2\t\u0103\3\2\2\2\t\u0105\3\2\2\2\t\u0107\3\2\2\2\t\u0109"+ + "\3\2\2\2\t\u010b\3\2\2\2\t\u010d\3\2\2\2\t\u010f\3\2\2\2\t\u0111\3\2\2"+ + "\2\t\u0113\3\2\2\2\t\u0115\3\2\2\2\t\u0117\3\2\2\2\t\u0119\3\2\2\2\t\u011b"+ + "\3\2\2\2\t\u011d\3\2\2\2\t\u011f\3\2\2\2\t\u0121\3\2\2\2\t\u0123\3\2\2"+ + "\2\t\u0125\3\2\2\2\t\u0127\3\2\2\2\t\u0129\3\2\2\2\t\u012b\3\2\2\2\t\u012d"+ + "\3\2\2\2\t\u012f\3\2\2\2\t\u0131\3\2\2\2\t\u0133\3\2\2\2\t\u0135\3\2\2"+ + "\2\t\u0137\3\2\2\2\t\u0139\3\2\2\2\t\u013b\3\2\2\2\t\u013d\3\2\2\2\t\u013f"+ + "\3\2\2\2\t\u0141\3\2\2\2\t\u0143\3\2\2\2\t\u0145\3\2\2\2\t\u0147\3\2\2"+ + "\2\t\u0149\3\2\2\2\t\u014b\3\2\2\2\t\u014d\3\2\2\2\t\u014f\3\2\2\2\t\u0151"+ + "\3\2\2\2\t\u0153\3\2\2\2\t\u0155\3\2\2\2\t\u0157\3\2\2\2\t\u0159\3\2\2"+ + "\2\t\u015b\3\2\2\2\t\u015d\3\2\2\2\t\u015f\3\2\2\2\t\u0161\3\2\2\2\t\u0163"+ + "\3\2\2\2\t\u0165\3\2\2\2\t\u0167\3\2\2\2\t\u0169\3\2\2\2\t\u016b\3\2\2"+ + "\2\t\u016d\3\2\2\2\t\u016f\3\2\2\2\t\u0171\3\2\2\2\t\u0173\3\2\2\2\t\u0175"+ + "\3\2\2\2\t\u0177\3\2\2\2\t\u0179\3\2\2\2\t\u017b\3\2\2\2\t\u017d\3\2\2"+ + "\2\t\u017f\3\2\2\2\t\u0181\3\2\2\2\t\u0183\3\2\2\2\t\u0185\3\2\2\2\t\u0187"+ + "\3\2\2\2\t\u0189\3\2\2\2\t\u018b\3\2\2\2\t\u018d\3\2\2\2\t\u018f\3\2\2"+ + "\2\t\u0191\3\2\2\2\t\u0193\3\2\2\2\t\u0195\3\2\2\2\t\u0197\3\2\2\2\t\u0199"+ + "\3\2\2\2\t\u019b\3\2\2\2\t\u019d\3\2\2\2\t\u019f\3\2\2\2\t\u01a1\3\2\2"+ + "\2\t\u01a3\3\2\2\2\t\u01a5\3\2\2\2\t\u01a7\3\2\2\2\t\u01a9\3\2\2\2\t\u01ab"+ + "\3\2\2\2\t\u01ad\3\2\2\2\t\u01af\3\2\2\2\t\u01b1\3\2\2\2\t\u01b3\3\2\2"+ + "\2\t\u01b5\3\2\2\2\t\u01b7\3\2\2\2\t\u01b9\3\2\2\2\t\u01bb\3\2\2\2\t\u01bd"+ + "\3\2\2\2\t\u01bf\3\2\2\2\t\u01c1\3\2\2\2\t\u01c3\3\2\2\2\t\u01c5\3\2\2"+ + "\2\t\u01c7\3\2\2\2\t\u01c9\3\2\2\2\t\u01cb\3\2\2\2\t\u01cd\3\2\2\2\t\u01cf"+ + "\3\2\2\2\t\u01d1\3\2\2\2\t\u01d3\3\2\2\2\t\u01d5\3\2\2\2\t\u01d7\3\2\2"+ + "\2\t\u01d9\3\2\2\2\t\u01db\3\2\2\2\t\u01dd\3\2\2\2\t\u01df\3\2\2\2\t\u01e1"+ + "\3\2\2\2\t\u01e3\3\2\2\2\t\u01e5\3\2\2\2\t\u01e7\3\2\2\2\t\u01e9\3\2\2"+ + "\2\t\u01eb\3\2\2\2\t\u01ed\3\2\2\2\t\u01ef\3\2\2\2\t\u01f1\3\2\2\2\t\u01f3"+ + "\3\2\2\2\n\u01f5\3\2\2\2\n\u01f7\3\2\2\2\n\u01f9\3\2\2\2\n\u01fb\3\2\2"+ + "\2\n\u01fd\3\2\2\2\n\u01ff\3\2\2\2\n\u0201\3\2\2\2\n\u0203\3\2\2\2\13"+ + "\u0205\3\2\2\2\13\u0207\3\2\2\2\13\u0209\3\2\2\2\13\u020b\3\2\2\2\f\u020d"+ + "\3\2\2\2\r\u0226\3\2\2\2\17\u022d\3\2\2\2\21\u0231\3\2\2\2\23\u0239\3"+ + "\2\2\2\25\u023e\3\2\2\2\27\u0243\3\2\2\2\31\u024f\3\2\2\2\33\u025a\3\2"+ + "\2\2\35\u026c\3\2\2\2\37\u0277\3\2\2\2!\u027b\3\2\2\2#\u0284\3\2\2\2%"+ + "\u028d\3\2\2\2\'\u0292\3\2\2\2)\u0296\3\2\2\2+\u029b\3\2\2\2-\u029f\3"+ + "\2\2\2/\u02a4\3\2\2\2\61\u02a9\3\2\2\2\63\u02ac\3\2\2\2\65\u02b1\3\2\2"+ + "\2\67\u02b3\3\2\2\29\u02b6\3\2\2\2;\u02bd\3\2\2\2=\u02c3\3\2\2\2?\u02ca"+ + "\3\2\2\2A\u02cf\3\2\2\2C\u02d5\3\2\2\2E\u02dc\3\2\2\2G\u02e0\3\2\2\2I"+ + "\u02e5\3\2\2\2K\u02ea\3\2\2\2M\u02f1\3\2\2\2O\u02f5\3\2\2\2Q\u02f9\3\2"+ + "\2\2S\u02fe\3\2\2\2U\u0303\3\2\2\2W\u030a\3\2\2\2Y\u030e\3\2\2\2[\u0313"+ + "\3\2\2\2]\u0317\3\2\2\2_\u0326\3\2\2\2a\u032b\3\2\2\2c\u0330\3\2\2\2e"+ + "\u0337\3\2\2\2g\u0359\3\2\2\2i\u035c\3\2\2\2k\u0362\3\2\2\2m\u0370\3\2"+ + "\2\2o\u0376\3\2\2\2q\u037b\3\2\2\2s\u037e\3\2\2\2u\u0387\3\2\2\2w\u038d"+ + "\3\2\2\2y\u0390\3\2\2\2{\u0397\3\2\2\2}\u03aa\3\2\2\2\177\u03ac\3\2\2"+ + "\2\u0081\u03b2\3\2\2\2\u0083\u03bb\3\2\2\2\u0085\u03c0\3\2\2\2\u0087\u03c6"+ + "\3\2\2\2\u0089\u03cc\3\2\2\2\u008b\u03d2\3\2\2\2\u008d\u03d8\3\2\2\2\u008f"+ + "\u03e1\3\2\2\2\u0091\u03e9\3\2\2\2\u0093\u03f1\3\2\2\2\u0095\u03f4\3\2"+ + "\2\2\u0097\u03f9\3\2\2\2\u0099\u0400\3\2\2\2\u009b\u0405\3\2\2\2\u009d"+ + "\u040a\3\2\2\2\u009f\u0411\3\2\2\2\u00a1\u0417\3\2\2\2\u00a3\u041c\3\2"+ + "\2\2\u00a5\u0427\3\2\2\2\u00a7\u042e\3\2\2\2\u00a9\u0439\3\2\2\2\u00ab"+ + "\u043f\3\2\2\2\u00ad\u0449\3\2\2\2\u00af\u0452\3\2\2\2\u00b1\u0457\3\2"+ + "\2\2\u00b3\u045b\3\2\2\2\u00b5\u0463\3\2\2\2\u00b7\u0469\3\2\2\2\u00b9"+ + "\u0471\3\2\2\2\u00bb\u0477\3\2\2\2\u00bd\u047b\3\2\2\2\u00bf\u0483\3\2"+ + "\2\2\u00c1\u048c\3\2\2\2\u00c3\u0493\3\2\2\2\u00c5\u0498\3\2\2\2\u00c7"+ + "\u049b\3\2\2\2\u00c9\u04a6\3\2\2\2\u00cb\u04ad\3\2\2\2\u00cd\u04b5\3\2"+ + "\2\2\u00cf\u04c2\3\2\2\2\u00d1\u04cd\3\2\2\2\u00d3\u04d7\3\2\2\2\u00d5"+ + "\u04dc\3\2\2\2\u00d7\u04e2\3\2\2\2\u00d9\u04e8\3\2\2\2\u00db\u04f2\3\2"+ + "\2\2\u00dd\u04fc\3\2\2\2\u00df\u0502\3\2\2\2\u00e1\u0507\3\2\2\2\u00e3"+ + "\u050b\3\2\2\2\u00e5\u050e\3\2\2\2\u00e7\u0512\3\2\2\2\u00e9\u0518\3\2"+ + "\2\2\u00eb\u0522\3\2\2\2\u00ed\u0526\3\2\2\2\u00ef\u052b\3\2\2\2\u00f1"+ + "\u0532\3\2\2\2\u00f3\u0539\3\2\2\2\u00f5\u0541\3\2\2\2\u00f7\u0547\3\2"+ + "\2\2\u00f9\u054f\3\2\2\2\u00fb\u0559\3\2\2\2\u00fd\u0560\3\2\2\2\u00ff"+ + "\u0569\3\2\2\2\u0101\u0571\3\2\2\2\u0103\u057e\3\2\2\2\u0105\u0587\3\2"+ + "\2\2\u0107\u058e\3\2\2\2\u0109\u0595\3\2\2\2\u010b\u059c\3\2\2\2\u010d"+ + "\u05a3\3\2\2\2\u010f\u05a9\3\2\2\2\u0111\u05af\3\2\2\2\u0113\u05b3\3\2"+ + "\2\2\u0115\u05bd\3\2\2\2\u0117\u05c9\3\2\2\2\u0119\u05d1\3\2\2\2\u011b"+ + "\u05d7\3\2\2\2\u011d\u05db\3\2\2\2\u011f\u05df\3\2\2\2\u0121\u05e5\3\2"+ + "\2\2\u0123\u05eb\3\2\2\2\u0125\u05f0\3\2\2\2\u0127\u05f3\3\2\2\2\u0129"+ + "\u05f9\3\2\2\2\u012b\u0602\3\2\2\2\u012d\u060f\3\2\2\2\u012f\u0615\3\2"+ + "\2\2\u0131\u061b\3\2\2\2\u0133\u0622\3\2\2\2\u0135\u062f\3\2\2\2\u0137"+ + "\u063b\3\2\2\2\u0139\u0646\3\2\2\2\u013b\u064f\3\2\2\2\u013d\u0657\3\2"+ + "\2\2\u013f\u0662\3\2\2\2\u0141\u066a\3\2\2\2\u0143\u0672\3\2\2\2\u0145"+ + "\u067d\3\2\2\2\u0147\u0686\3\2\2\2\u0149\u0692\3\2\2\2\u014b\u069a\3\2"+ + "\2\2\u014d\u06a6\3\2\2\2\u014f\u06b4\3\2\2\2\u0151\u06be\3\2\2\2\u0153"+ + "\u06c8\3\2\2\2\u0155\u06d5\3\2\2\2\u0157\u06e0\3\2\2\2\u0159\u06e9\3\2"+ + "\2\2\u015b\u06f2\3\2\2\2\u015d\u06fa\3\2\2\2\u015f\u06fe\3\2\2\2\u0161"+ + "\u0701\3\2\2\2\u0163\u0704\3\2\2\2\u0165\u0707\3\2\2\2\u0167\u070a\3\2"+ + "\2\2\u0169\u070d\3\2\2\2\u016b\u0711\3\2\2\2\u016d\u0715\3\2\2\2\u016f"+ + "\u071c\3\2\2\2\u0171\u071e\3\2\2\2\u0173\u0721\3\2\2\2\u0175\u0724\3\2"+ + "\2\2\u0177\u0727\3\2\2\2\u0179\u072a\3\2\2\2\u017b\u072d\3\2\2\2\u017d"+ + "\u0730\3\2\2\2\u017f\u0734\3\2\2\2\u0181\u0737\3\2\2\2\u0183\u073a\3\2"+ + "\2\2\u0185\u073d\3\2\2\2\u0187\u0741\3\2\2\2\u0189\u0745\3\2\2\2\u018b"+ + "\u0748\3\2\2\2\u018d\u074b\3\2\2\2\u018f\u074e\3\2\2\2\u0191\u0751\3\2"+ + "\2\2\u0193\u0754\3\2\2\2\u0195\u0757\3\2\2\2\u0197\u075b\3\2\2\2\u0199"+ + "\u075e\3\2\2\2\u019b\u0761\3\2\2\2\u019d\u0764\3\2\2\2\u019f\u0767\3\2"+ + "\2\2\u01a1\u0769\3\2\2\2\u01a3\u076d\3\2\2\2\u01a5\u076f\3\2\2\2\u01a7"+ + "\u0771\3\2\2\2\u01a9\u0773\3\2\2\2\u01ab\u0775\3\2\2\2\u01ad\u0777\3\2"+ + "\2\2\u01af\u0779\3\2\2\2\u01b1\u077b\3\2\2\2\u01b3\u077d\3\2\2\2\u01b5"+ + "\u077f\3\2\2\2\u01b7\u0781\3\2\2\2\u01b9\u0783\3\2\2\2\u01bb\u0785\3\2"+ + "\2\2\u01bd\u0787\3\2\2\2\u01bf\u0789\3\2\2\2\u01c1\u078b\3\2\2\2\u01c3"+ + "\u078d\3\2\2\2\u01c5\u078f\3\2\2\2\u01c7\u0791\3\2\2\2\u01c9\u0793\3\2"+ + "\2\2\u01cb\u0795\3\2\2\2\u01cd\u0797\3\2\2\2\u01cf\u079a\3\2\2\2\u01d1"+ + "\u079c\3\2\2\2\u01d3\u079e\3\2\2\2\u01d5\u07a0\3\2\2\2\u01d7\u07a2\3\2"+ + "\2\2\u01d9\u07a4\3\2\2\2\u01db\u07a6\3\2\2\2\u01dd\u07a9\3\2\2\2\u01df"+ + "\u07b0\3\2\2\2\u01e1\u07d7\3\2\2\2\u01e3\u07ef\3\2\2\2\u01e5\u07f1\3\2"+ + "\2\2\u01e7\u0804\3\2\2\2\u01e9\u0817\3\2\2\2\u01eb\u0820\3\2\2\2\u01ed"+ + "\u082b\3\2\2\2\u01ef\u082f\3\2\2\2\u01f1\u0840\3\2\2\2\u01f3\u084f\3\2"+ + "\2\2\u01f5\u0853\3\2\2\2\u01f7\u0858\3\2\2\2\u01f9\u085c\3\2\2\2\u01fb"+ + "\u0863\3\2\2\2\u01fd\u0867\3\2\2\2\u01ff\u086c\3\2\2\2\u0201\u0871\3\2"+ + "\2\2\u0203\u087e\3\2\2\2\u0205\u0883\3\2\2\2\u0207\u0889\3\2\2\2\u0209"+ + "\u088c\3\2\2\2\u020b\u0891\3\2\2\2\u020d\u0899\3\2\2\2\u020f\u08a3\3\2"+ + "\2\2\u0211\u08ab\3\2\2\2\u0213\u08b6\3\2\2\2\u0215\u08c1\3\2\2\2\u0217"+ + "\u08c4\3\2\2\2\u0219\u08c7\3\2\2\2\u021b\u08d6\3\2\2\2\u021d\u08dc\3\2"+ + "\2\2\u021f\u08de\3\2\2\2\u0221\u08e0\3\2\2\2\u0223\u08e2\3\2\2\2\u0225"+ + "\u0227\t\2\2\2\u0226\u0225\3\2\2\2\u0227\u0228\3\2\2\2\u0228\u0226\3\2"+ + "\2\2\u0228\u0229\3\2\2\2\u0229\u022a\3\2\2\2\u022a\u022b\b\2\2\2\u022b"+ + "\16\3\2\2\2\u022c\u022e\n\3\2\2\u022d\u022c\3\2\2\2\u022e\u022f\3\2\2"+ + "\2\u022f\u022d\3\2\2\2\u022f\u0230\3\2\2\2\u0230\20\3\2\2\2\u0231\u0232"+ + "\7>\2\2\u0232\u0233\7A\2\2\u0233\u0234\7z\2\2\u0234\u0235\7o\2\2\u0235"+ + "\u0236\7n\2\2\u0236\u0237\3\2\2\2\u0237\u0238\b\4\3\2\u0238\22\3\2\2\2"+ + "\u0239\u023a\5\u020f\u0103\2\u023a\u023b\3\2\2\2\u023b\u023c\b\5\4\2\u023c"+ + "\u023d\b\5\5\2\u023d\24\3\2\2\2\u023e\u023f\5\u0211\u0104\2\u023f\u0240"+ + "\3\2\2\2\u0240\u0241\b\6\6\2\u0241\u0242\b\6\5\2\u0242\26\3\2\2\2\u0243"+ + "\u0244\7>\2\2\u0244\u0245\7u\2\2\u0245\u0246\7e\2\2\u0246\u0247\7t\2\2"+ + "\u0247\u0248\7k\2\2\u0248\u0249\7r\2\2\u0249\u024a\7v\2\2\u024a\u024b"+ + "\3\2\2\2\u024b\u024c\b\7\7\2\u024c\u024d\3\2\2\2\u024d\u024e\b\7\b\2\u024e"+ + "\30\3\2\2\2\u024f\u0250\7>\2\2\u0250\u0251\7u\2\2\u0251\u0252\7v\2\2\u0252"+ + "\u0253\7{\2\2\u0253\u0254\7n\2\2\u0254\u0255\7g\2\2\u0255\u0256\3\2\2"+ + "\2\u0256\u0257\b\b\t\2\u0257\u0258\3\2\2\2\u0258\u0259\b\b\b\2\u0259\32"+ + "\3\2\2\2\u025a\u025b\7>\2\2\u025b\u025c\7#\2\2\u025c\u025d\3\2\2\2\u025d"+ + "\u025e\7/\2\2\u025e\u025f\7/\2\2\u025f\u0263\3\2\2\2\u0260\u0262\13\2"+ + "\2\2\u0261\u0260\3\2\2\2\u0262\u0265\3\2\2\2\u0263\u0264\3\2\2\2\u0263"+ + "\u0261\3\2\2\2\u0264\u0266\3\2\2\2\u0265\u0263\3\2\2\2\u0266\u0267\7/"+ + "\2\2\u0267\u0268\7/\2\2\u0268\u0269\7@\2\2\u0269\u026a\3\2\2\2\u026a\u026b"+ + "\b\t\2\2\u026b\34\3\2\2\2\u026c\u026d\7>\2\2\u026d\u026e\7#\2\2\u026e"+ + "\u0272\3\2\2\2\u026f\u0271\13\2\2\2\u0270\u026f\3\2\2\2\u0271\u0274\3"+ + "\2\2\2\u0272\u0273\3\2\2\2\u0272\u0270\3\2\2\2\u0273\u0275\3\2\2\2\u0274"+ + "\u0272\3\2\2\2\u0275\u0276\7@\2\2\u0276\36\3\2\2\2\u0277\u0278\7>\2\2"+ + "\u0278\u0279\3\2\2\2\u0279\u027a\b\13\b\2\u027a \3\2\2\2\u027b\u027c\7"+ + "%\2\2\u027c\u027d\6\f\2\2\u027d\u0281\7#\2\2\u027e\u0280\n\4\2\2\u027f"+ + "\u027e\3\2\2\2\u0280\u0283\3\2\2\2\u0281\u027f\3\2\2\2\u0281\u0282\3\2"+ + "\2\2\u0282\"\3\2\2\2\u0283\u0281\3\2\2\2\u0284\u0288\7%\2\2\u0285\u0287"+ + "\n\5\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+ + "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\b\r"+ + "\n\2\u028c$\3\2\2\2\u028d\u028e\13\2\2\2\u028e\u028f\3\2\2\2\u028f\u0290"+ + "\b\16\13\2\u0290&\3\2\2\2\u0291\u0293\n\6\2\2\u0292\u0291\3\2\2\2\u0293"+ + "\u0294\3\2\2\2\u0294\u0292\3\2\2\2\u0294\u0295\3\2\2\2\u0295(\3\2\2\2"+ + "\u0296\u0297\7A\2\2\u0297\u0298\7@\2\2\u0298\u0299\3\2\2\2\u0299\u029a"+ + "\b\20\f\2\u029a*\3\2\2\2\u029b\u029c\7A\2\2\u029c\u029d\3\2\2\2\u029d"+ + "\u029e\b\21\r\2\u029e,\3\2\2\2\u029f\u02a0\5\u020f\u0103\2\u02a0\u02a1"+ + "\3\2\2\2\u02a1\u02a2\b\22\4\2\u02a2\u02a3\b\22\5\2\u02a3.\3\2\2\2\u02a4"+ + "\u02a5\5\u0211\u0104\2\u02a5\u02a6\3\2\2\2\u02a6\u02a7\b\23\6\2\u02a7"+ + "\u02a8\b\23\5\2\u02a8\60\3\2\2\2\u02a9\u02aa\7@\2\2\u02aa\u02ab\b\24\16"+ + "\2\u02ab\62\3\2\2\2\u02ac\u02ad\7\61\2\2\u02ad\u02ae\7@\2\2\u02ae\u02af"+ + "\3\2\2\2\u02af\u02b0\b\25\f\2\u02b0\64\3\2\2\2\u02b1\u02b2\7\61\2\2\u02b2"+ + "\66\3\2\2\2\u02b3\u02b4\7?\2\2\u02b48\3\2\2\2\u02b5\u02b7\7^\2\2\u02b6"+ + "\u02b5\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7\u02b8\3\2\2\2\u02b8\u02b9\7)"+ + "\2\2\u02b9\u02ba\3\2\2\2\u02ba\u02bb\b\30\17\2\u02bb:\3\2\2\2\u02bc\u02be"+ + "\7^\2\2\u02bd\u02bc\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf"+ + "\u02c0\7$\2\2\u02c0\u02c1\3\2\2\2\u02c1\u02c2\b\31\20\2\u02c2<\3\2\2\2"+ + "\u02c3\u02c5\7%\2\2\u02c4\u02c6\5\u0223\u010d\2\u02c5\u02c4\3\2\2\2\u02c6"+ + "\u02c7\3\2\2\2\u02c7\u02c5\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8>\3\2\2\2"+ + "\u02c9\u02cb\5\u021f\u010b\2\u02ca\u02c9\3\2\2\2\u02cb\u02cc\3\2\2\2\u02cc"+ + "\u02ca\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd@\3\2\2\2\u02ce\u02d0\t\2\2\2"+ + "\u02cf\u02ce\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02cf\3\2\2\2\u02d1\u02d2"+ + "\3\2\2\2\u02d2\u02d3\3\2\2\2\u02d3\u02d4\b\34\2\2\u02d4B\3\2\2\2\u02d5"+ + "\u02d9\5\u0217\u0107\2\u02d6\u02d8\5\u0215\u0106\2\u02d7\u02d6\3\2\2\2"+ + "\u02d8\u02db\3\2\2\2\u02d9\u02d7\3\2\2\2\u02d9\u02da\3\2\2\2\u02daD\3"+ + "\2\2\2\u02db\u02d9\3\2\2\2\u02dc\u02dd\13\2\2\2\u02dd\u02de\3\2\2\2\u02de"+ + "\u02df\b\36\13\2\u02dfF\3\2\2\2\u02e0\u02e1\5\u020f\u0103\2\u02e1\u02e2"+ + "\3\2\2\2\u02e2\u02e3\b\37\4\2\u02e3\u02e4\b\37\5\2\u02e4H\3\2\2\2\u02e5"+ + "\u02e6\5\u0211\u0104\2\u02e6\u02e7\3\2\2\2\u02e7\u02e8\b \6\2\u02e8\u02e9"+ + "\b \5\2\u02e9J\3\2\2\2\u02ea\u02ec\7)\2\2\u02eb\u02ed\7)\2\2\u02ec\u02eb"+ + "\3\2\2\2\u02ec\u02ed\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02ef\b!\f\2\u02ef"+ + "L\3\2\2\2\u02f0\u02f2\n\7\2\2\u02f1\u02f0\3\2\2\2\u02f2\u02f3\3\2\2\2"+ + "\u02f3\u02f1\3\2\2\2\u02f3\u02f4\3\2\2\2\u02f4N\3\2\2\2\u02f5\u02f6\13"+ + "\2\2\2\u02f6\u02f7\3\2\2\2\u02f7\u02f8\b#\13\2\u02f8P\3\2\2\2\u02f9\u02fa"+ + "\5\u020f\u0103\2\u02fa\u02fb\3\2\2\2\u02fb\u02fc\b$\4\2\u02fc\u02fd\b"+ + "$\5\2\u02fdR\3\2\2\2\u02fe\u02ff\5\u0211\u0104\2\u02ff\u0300\3\2\2\2\u0300"+ + "\u0301\b%\6\2\u0301\u0302\b%\5\2\u0302T\3\2\2\2\u0303\u0305\7$\2\2\u0304"+ + "\u0306\7$\2\2\u0305\u0304\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u0307\3\2"+ + "\2\2\u0307\u0308\b&\f\2\u0308V\3\2\2\2\u0309\u030b\n\b\2\2\u030a\u0309"+ + "\3\2\2\2\u030b\u030c\3\2\2\2\u030c\u030a\3\2\2\2\u030c\u030d\3\2\2\2\u030d"+ + "X\3\2\2\2\u030e\u030f\13\2\2\2\u030f\u0310\3\2\2\2\u0310\u0311\b(\13\2"+ + "\u0311Z\3\2\2\2\u0312\u0314\n\5\2\2\u0313\u0312\3\2\2\2\u0314\u0315\3"+ + "\2\2\2\u0315\u0313\3\2\2\2\u0315\u0316\3\2\2\2\u0316\\\3\2\2\2\u0317\u0318"+ + "\7>\2\2\u0318\u0319\7\61\2\2\u0319\u0320\3\2\2\2\u031a\u031b\7u\2\2\u031b"+ + "\u031c\7e\2\2\u031c\u031d\7t\2\2\u031d\u031e\7k\2\2\u031e\u031f\7r\2\2"+ + "\u031f\u0321\7v\2\2\u0320\u031a\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u0322"+ + "\3\2\2\2\u0322\u0323\7@\2\2\u0323\u0324\3\2\2\2\u0324\u0325\b*\f\2\u0325"+ + "^\3\2\2\2\u0326\u0327\5\u020f\u0103\2\u0327\u0328\3\2\2\2\u0328\u0329"+ + "\b+\4\2\u0329\u032a\b+\5\2\u032a`\3\2\2\2\u032b\u032c\5\u0211\u0104\2"+ + "\u032c\u032d\3\2\2\2\u032d\u032e\b,\6\2\u032e\u032f\b,\5\2\u032fb\3\2"+ + "\2\2\u0330\u0331\7>\2\2\u0331\u0332\3\2\2\2\u0332\u0333\b-\21\2\u0333"+ + "d\3\2\2\2\u0334\u0336\13\2\2\2\u0335\u0334\3\2\2\2\u0336\u0339\3\2\2\2"+ + "\u0337\u0338\3\2\2\2\u0337\u0335\3\2\2\2\u0338\u033a\3\2\2\2\u0339\u0337"+ + "\3\2\2\2\u033a\u033b\7>\2\2\u033b\u033c\7\61\2\2\u033c\u0342\3\2\2\2\u033d"+ + "\u033e\7u\2\2\u033e\u033f\7v\2\2\u033f\u0340\7{\2\2\u0340\u0341\7n\2\2"+ + "\u0341\u0343\7g\2\2\u0342\u033d\3\2\2\2\u0342\u0343\3\2\2\2\u0343\u0344"+ + "\3\2\2\2\u0344\u0345\7@\2\2\u0345\u0346\3\2\2\2\u0346\u0347\b.\f\2\u0347"+ + "f\3\2\2\2\u0348\u034c\7A\2\2\u0349\u034a\7\'\2\2\u034a\u034c\6/\3\2\u034b"+ + "\u0348\3\2\2\2\u034b\u0349\3\2\2\2\u034c\u034d\3\2\2\2\u034d\u035a\7@"+ + "\2\2\u034e\u034f\7>\2\2\u034f\u0350\7\61\2\2\u0350\u0351\7u\2\2\u0351"+ + "\u0352\7e\2\2\u0352\u0353\7t\2\2\u0353\u0354\7k\2\2\u0354\u0355\7r\2\2"+ + "\u0355\u0356\7v\2\2\u0356\u0357\7@\2\2\u0357\u0358\3\2\2\2\u0358\u035a"+ + "\6/\4\2\u0359\u034b\3\2\2\2\u0359\u034e\3\2\2\2\u035ah\3\2\2\2\u035b\u035d"+ + "\t\2\2\2\u035c\u035b\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035c\3\2\2\2\u035e"+ + "\u035f\3\2\2\2\u035f\u0360\3\2\2\2\u0360\u0361\b\60\6\2\u0361j\3\2\2\2"+ + "\u0362\u0363\7\61\2\2\u0363\u0364\7,\2\2\u0364\u0368\3\2\2\2\u0365\u0367"+ + "\13\2\2\2\u0366\u0365\3\2\2\2\u0367\u036a\3\2\2\2\u0368\u0369\3\2\2\2"+ + "\u0368\u0366\3\2\2\2\u0369\u036b\3\2\2\2\u036a\u0368\3\2\2\2\u036b\u036c"+ + "\7,\2\2\u036c\u036d\7\61\2\2\u036d\u036e\3\2\2\2\u036e\u036f\b\61\22\2"+ + "\u036fl\3\2\2\2\u0370\u0371\7\61\2\2\u0371\u0372\7\61\2\2\u0372\u0373"+ + "\3\2\2\2\u0373\u0374\b\62\6\2\u0374\u0375\b\62\23\2\u0375n\3\2\2\2\u0376"+ + "\u0377\7%\2\2\u0377\u0378\3\2\2\2\u0378\u0379\b\63\6\2\u0379\u037a\b\63"+ + "\23\2\u037ap\3\2\2\2\u037b\u037c\7%\2\2\u037c\u037d\7]\2\2\u037dr\3\2"+ + "\2\2\u037e\u037f\7c\2\2\u037f\u0380\7d\2\2\u0380\u0381\7u\2\2\u0381\u0382"+ + "\7v\2\2\u0382\u0383\7t\2\2\u0383\u0384\7c\2\2\u0384\u0385\7e\2\2\u0385"+ + "\u0386\7v\2\2\u0386t\3\2\2\2\u0387\u0388\7c\2\2\u0388\u0389\7t\2\2\u0389"+ + "\u038a\7t\2\2\u038a\u038b\7c\2\2\u038b\u038c\7{\2\2\u038cv\3\2\2\2\u038d"+ + "\u038e\7c\2\2\u038e\u038f\7u\2\2\u038fx\3\2\2\2\u0390\u0391\7d\2\2\u0391"+ + "\u0392\7k\2\2\u0392\u0393\7p\2\2\u0393\u0394\7c\2\2\u0394\u0395\7t\2\2"+ + "\u0395\u0396\7{\2\2\u0396z\3\2\2\2\u0397\u0398\7d\2\2\u0398\u0399\7q\2"+ + "\2\u0399\u039a\7q\2\2\u039a\u039b\7n\2\2\u039b\u039f\3\2\2\2\u039c\u039d"+ + "\7g\2\2\u039d\u039e\7c\2\2\u039e\u03a0\7p\2\2\u039f\u039c\3\2\2\2\u039f"+ + "\u03a0\3\2\2\2\u03a0|\3\2\2\2\u03a1\u03a2\7v\2\2\u03a2\u03a3\7t\2\2\u03a3"+ + "\u03a4\7w\2\2\u03a4\u03ab\7g\2\2\u03a5\u03a6\7h\2\2\u03a6\u03a7\7c\2\2"+ + "\u03a7\u03a8\7n\2\2\u03a8\u03a9\7u\2\2\u03a9\u03ab\7g\2\2\u03aa\u03a1"+ + "\3\2\2\2\u03aa\u03a5\3\2\2\2\u03ab~\3\2\2\2\u03ac\u03ad\7d\2\2\u03ad\u03ae"+ + "\7t\2\2\u03ae\u03af\7g\2\2\u03af\u03b0\7c\2\2\u03b0\u03b1\7m\2\2\u03b1"+ + "\u0080\3\2\2\2\u03b2\u03b3\7e\2\2\u03b3\u03b4\7c\2\2\u03b4\u03b5\7n\2"+ + "\2\u03b5\u03b6\7n\2\2\u03b6\u03b7\7c\2\2\u03b7\u03b8\7d\2\2\u03b8\u03b9"+ + "\7n\2\2\u03b9\u03ba\7g\2\2\u03ba\u0082\3\2\2\2\u03bb\u03bc\7e\2\2\u03bc"+ + "\u03bd\7c\2\2\u03bd\u03be\7u\2\2\u03be\u03bf\7g\2\2\u03bf\u0084\3\2\2"+ + "\2\u03c0\u03c1\7e\2\2\u03c1\u03c2\7c\2\2\u03c2\u03c3\7v\2\2\u03c3\u03c4"+ + "\7e\2\2\u03c4\u03c5\7j\2\2\u03c5\u0086\3\2\2\2\u03c6\u03c7\7e\2\2\u03c7"+ + "\u03c8\7n\2\2\u03c8\u03c9\7c\2\2\u03c9\u03ca\7u\2\2\u03ca\u03cb\7u\2\2"+ + "\u03cb\u0088\3\2\2\2\u03cc\u03cd\7e\2\2\u03cd\u03ce\7n\2\2\u03ce\u03cf"+ + "\7q\2\2\u03cf\u03d0\7p\2\2\u03d0\u03d1\7g\2\2\u03d1\u008a\3\2\2\2\u03d2"+ + "\u03d3\7e\2\2\u03d3\u03d4\7q\2\2\u03d4\u03d5\7p\2\2\u03d5\u03d6\7u\2\2"+ + "\u03d6\u03d7\7v\2\2\u03d7\u008c\3\2\2\2\u03d8\u03d9\7e\2\2\u03d9\u03da"+ + "\7q\2\2\u03da\u03db\7p\2\2\u03db\u03dc\7v\2\2\u03dc\u03dd\7k\2\2\u03dd"+ + "\u03de\7p\2\2\u03de\u03df\7w\2\2\u03df\u03e0\7g\2\2\u03e0\u008e\3\2\2"+ + "\2\u03e1\u03e2\7f\2\2\u03e2\u03e3\7g\2\2\u03e3\u03e4\7e\2\2\u03e4\u03e5"+ + "\7n\2\2\u03e5\u03e6\7c\2\2\u03e6\u03e7\7t\2\2\u03e7\u03e8\7g\2\2\u03e8"+ + "\u0090\3\2\2\2\u03e9\u03ea\7f\2\2\u03ea\u03eb\7g\2\2\u03eb\u03ec\7h\2"+ + "\2\u03ec\u03ed\7c\2\2\u03ed\u03ee\7w\2\2\u03ee\u03ef\7n\2\2\u03ef\u03f0"+ + "\7v\2\2\u03f0\u0092\3\2\2\2\u03f1\u03f2\7f\2\2\u03f2\u03f3\7q\2\2\u03f3"+ + "\u0094\3\2\2\2\u03f4\u03f5\7t\2\2\u03f5\u03f6\7g\2\2\u03f6\u03f7\7c\2"+ + "\2\u03f7\u03f8\7n\2\2\u03f8\u0096\3\2\2\2\u03f9\u03fa\7f\2\2\u03fa\u03fb"+ + "\7q\2\2\u03fb\u03fc\7w\2\2\u03fc\u03fd\7d\2\2\u03fd\u03fe\7n\2\2\u03fe"+ + "\u03ff\7g\2\2\u03ff\u0098\3\2\2\2\u0400\u0401\7g\2\2\u0401\u0402\7e\2"+ + "\2\u0402\u0403\7j\2\2\u0403\u0404\7q\2\2\u0404\u009a\3\2\2\2\u0405\u0406"+ + "\7g\2\2\u0406\u0407\7n\2\2\u0407\u0408\7u\2\2\u0408\u0409\7g\2\2\u0409"+ + "\u009c\3\2\2\2\u040a\u040b\7g\2\2\u040b\u040c\7n\2\2\u040c\u040d\7u\2"+ + "\2\u040d\u040e\7g\2\2\u040e\u040f\7k\2\2\u040f\u0410\7h\2\2\u0410\u009e"+ + "\3\2\2\2\u0411\u0412\7g\2\2\u0412\u0413\7o\2\2\u0413\u0414\7r\2\2\u0414"+ + "\u0415\7v\2\2\u0415\u0416\7{\2\2\u0416\u00a0\3\2\2\2\u0417\u0418\7g\2"+ + "\2\u0418\u0419\7p\2\2\u0419\u041a\7w\2\2\u041a\u041b\7o\2\2\u041b\u00a2"+ + "\3\2\2\2\u041c\u041d\7g\2\2\u041d\u041e\7p\2\2\u041e\u041f\7f\2\2\u041f"+ + "\u0420\7f\2\2\u0420\u0421\7g\2\2\u0421\u0422\7e\2\2\u0422\u0423\7n\2\2"+ + "\u0423\u0424\7c\2\2\u0424\u0425\7t\2\2\u0425\u0426\7g\2\2\u0426\u00a4"+ + "\3\2\2\2\u0427\u0428\7g\2\2\u0428\u0429\7p\2\2\u0429\u042a\7f\2\2\u042a"+ + "\u042b\7h\2\2\u042b\u042c\7q\2\2\u042c\u042d\7t\2\2\u042d\u00a6\3\2\2"+ + "\2\u042e\u042f\7g\2\2\u042f\u0430\7p\2\2\u0430\u0431\7f\2\2\u0431\u0432"+ + "\7h\2\2\u0432\u0433\7q\2\2\u0433\u0434\7t\2\2\u0434\u0435\7g\2\2\u0435"+ + "\u0436\7c\2\2\u0436\u0437\7e\2\2\u0437\u0438\7j\2\2\u0438\u00a8\3\2\2"+ + "\2\u0439\u043a\7g\2\2\u043a\u043b\7p\2\2\u043b\u043c\7f\2\2\u043c\u043d"+ + "\7k\2\2\u043d\u043e\7h\2\2\u043e\u00aa\3\2\2\2\u043f\u0440\7g\2\2\u0440"+ + "\u0441\7p\2\2\u0441\u0442\7f\2\2\u0442\u0443\7u\2\2\u0443\u0444\7y\2\2"+ + "\u0444\u0445\7k\2\2\u0445\u0446\7v\2\2\u0446\u0447\7e\2\2\u0447\u0448"+ + "\7j\2\2\u0448\u00ac\3\2\2\2\u0449\u044a\7g\2\2\u044a\u044b\7p\2\2\u044b"+ + "\u044c\7f\2\2\u044c\u044d\7y\2\2\u044d\u044e\7j\2\2\u044e\u044f\7k\2\2"+ + "\u044f\u0450\7n\2\2\u0450\u0451\7g\2\2\u0451\u00ae\3\2\2\2\u0452\u0453"+ + "\7g\2\2\u0453\u0454\7x\2\2\u0454\u0455\7c\2\2\u0455\u0456\7n\2\2\u0456"+ + "\u00b0\3\2\2\2\u0457\u0458\7f\2\2\u0458\u0459\7k\2\2\u0459\u045a\7g\2"+ + "\2\u045a\u00b2\3\2\2\2\u045b\u045c\7g\2\2\u045c\u045d\7z\2\2\u045d\u045e"+ + "\7v\2\2\u045e\u045f\7g\2\2\u045f\u0460\7p\2\2\u0460\u0461\7f\2\2\u0461"+ + "\u0462\7u\2\2\u0462\u00b4\3\2\2\2\u0463\u0464\7h\2\2\u0464\u0465\7k\2"+ + "\2\u0465\u0466\7p\2\2\u0466\u0467\7c\2\2\u0467\u0468\7n\2\2\u0468\u00b6"+ + "\3\2\2\2\u0469\u046a\7h\2\2\u046a\u046b\7k\2\2\u046b\u046c\7p\2\2\u046c"+ + "\u046d\7c\2\2\u046d\u046e\7n\2\2\u046e\u046f\7n\2\2\u046f\u0470\7{\2\2"+ + "\u0470\u00b8\3\2\2\2\u0471\u0472\7h\2\2\u0472\u0473\7n\2\2\u0473\u0474"+ + "\7q\2\2\u0474\u0475\7c\2\2\u0475\u0476\7v\2\2\u0476\u00ba\3\2\2\2\u0477"+ + "\u0478\7h\2\2\u0478\u0479\7q\2\2\u0479\u047a\7t\2\2\u047a\u00bc\3\2\2"+ + "\2\u047b\u047c\7h\2\2\u047c\u047d\7q\2\2\u047d\u047e\7t\2\2\u047e\u047f"+ + "\7g\2\2\u047f\u0480\7c\2\2\u0480\u0481\7e\2\2\u0481\u0482\7j\2\2\u0482"+ + "\u00be\3\2\2\2\u0483\u0484\7h\2\2\u0484\u0485\7w\2\2\u0485\u0486\7p\2"+ + "\2\u0486\u0487\7e\2\2\u0487\u0488\7v\2\2\u0488\u0489\7k\2\2\u0489\u048a"+ + "\7q\2\2\u048a\u048b\7p\2\2\u048b\u00c0\3\2\2\2\u048c\u048d\7i\2\2\u048d"+ + "\u048e\7n\2\2\u048e\u048f\7q\2\2\u048f\u0490\7d\2\2\u0490\u0491\7c\2\2"+ + "\u0491\u0492\7n\2\2\u0492\u00c2\3\2\2\2\u0493\u0494\7i\2\2\u0494\u0495"+ + "\7q\2\2\u0495\u0496\7v\2\2\u0496\u0497\7q\2\2\u0497\u00c4\3\2\2\2\u0498"+ + "\u0499\7k\2\2\u0499\u049a\7h\2\2\u049a\u00c6\3\2\2\2\u049b\u049c\7k\2"+ + "\2\u049c\u049d\7o\2\2\u049d\u049e\7r\2\2\u049e\u049f\7n\2\2\u049f\u04a0"+ + "\7g\2\2\u04a0\u04a1\7o\2\2\u04a1\u04a2\7g\2\2\u04a2\u04a3\7p\2\2\u04a3"+ + "\u04a4\7v\2\2\u04a4\u04a5\7u\2\2\u04a5\u00c8\3\2\2\2\u04a6\u04a7\7k\2"+ + "\2\u04a7\u04a8\7o\2\2\u04a8\u04a9\7r\2\2\u04a9\u04aa\7q\2\2\u04aa\u04ab"+ + "\7t\2\2\u04ab\u04ac\7v\2\2\u04ac\u00ca\3\2\2\2\u04ad\u04ae\7k\2\2\u04ae"+ + "\u04af\7p\2\2\u04af\u04b0\7e\2\2\u04b0\u04b1\7n\2\2\u04b1\u04b2\7w\2\2"+ + "\u04b2\u04b3\7f\2\2\u04b3\u04b4\7g\2\2\u04b4\u00cc\3\2\2\2\u04b5\u04b6"+ + "\7k\2\2\u04b6\u04b7\7p\2\2\u04b7\u04b8\7e\2\2\u04b8\u04b9\7n\2\2\u04b9"+ + "\u04ba\7w\2\2\u04ba\u04bb\7f\2\2\u04bb\u04bc\7g\2\2\u04bc\u04bd\7a\2\2"+ + "\u04bd\u04be\7q\2\2\u04be\u04bf\7p\2\2\u04bf\u04c0\7e\2\2\u04c0\u04c1"+ + "\7g\2\2\u04c1\u00ce\3\2\2\2\u04c2\u04c3\7k\2\2\u04c3\u04c4\7p\2\2\u04c4"+ + "\u04c5\7u\2\2\u04c5\u04c6\7v\2\2\u04c6\u04c7\7c\2\2\u04c7\u04c8\7p\2\2"+ + "\u04c8\u04c9\7e\2\2\u04c9\u04ca\7g\2\2\u04ca\u04cb\7q\2\2\u04cb\u04cc"+ + "\7h\2\2\u04cc\u00d0\3\2\2\2\u04cd\u04ce\7k\2\2\u04ce\u04cf\7p\2\2\u04cf"+ + "\u04d0\7u\2\2\u04d0\u04d1\7v\2\2\u04d1\u04d2\7g\2\2\u04d2\u04d3\7c\2\2"+ + "\u04d3\u04d4\7f\2\2\u04d4\u04d5\7q\2\2\u04d5\u04d6\7h\2\2\u04d6\u00d2"+ + "\3\2\2\2\u04d7\u04d8\7k\2\2\u04d8\u04d9\7p\2\2\u04d9\u04da\7v\2\2\u04da"+ + "\u04db\7:\2\2\u04db\u00d4\3\2\2\2\u04dc\u04dd\7k\2\2\u04dd\u04de\7p\2"+ + "\2\u04de\u04df\7v\2\2\u04df\u04e0\7\63\2\2\u04e0\u04e1\78\2\2\u04e1\u00d6"+ + "\3\2\2\2\u04e2\u04e3\7k\2\2\u04e3\u04e4\7p\2\2\u04e4\u04e5\7v\2\2\u04e5"+ + "\u04e6\78\2\2\u04e6\u04e7\7\66\2\2\u04e7\u00d8\3\2\2\2\u04e8\u04e9\7k"+ + "\2\2\u04e9\u04ea\7p\2\2\u04ea\u04eb\7v\2\2\u04eb\u04f0\3\2\2\2\u04ec\u04ed"+ + "\7g\2\2\u04ed\u04ee\7i\2\2\u04ee\u04ef\7g\2\2\u04ef\u04f1\7t\2\2\u04f0"+ + "\u04ec\3\2\2\2\u04f0\u04f1\3\2\2\2\u04f1\u00da\3\2\2\2\u04f2\u04f3\7k"+ + "\2\2\u04f3\u04f4\7p\2\2\u04f4\u04f5\7v\2\2\u04f5\u04f6\7g\2\2\u04f6\u04f7"+ + "\7t\2\2\u04f7\u04f8\7h\2\2\u04f8\u04f9\7c\2\2\u04f9\u04fa\7e\2\2\u04fa"+ + "\u04fb\7g\2\2\u04fb\u00dc\3\2\2\2\u04fc\u04fd\7k\2\2\u04fd\u04fe\7u\2"+ + "\2\u04fe\u04ff\7u\2\2\u04ff\u0500\7g\2\2\u0500\u0501\7v\2\2\u0501\u00de"+ + "\3\2\2\2\u0502\u0503\7n\2\2\u0503\u0504\7k\2\2\u0504\u0505\7u\2\2\u0505"+ + "\u0506\7v\2\2\u0506\u00e0\3\2\2\2\u0507\u0508\7c\2\2\u0508\u0509\7p\2"+ + "\2\u0509\u050a\7f\2\2\u050a\u00e2\3\2\2\2\u050b\u050c\7q\2\2\u050c\u050d"+ + "\7t\2\2\u050d\u00e4\3\2\2\2\u050e\u050f\7z\2\2\u050f\u0510\7q\2\2\u0510"+ + "\u0511\7t\2\2\u0511\u00e6\3\2\2\2\u0512\u0513\7o\2\2\u0513\u0514\7c\2"+ + "\2\u0514\u0515\7v\2\2\u0515\u0516\7e\2\2\u0516\u0517\7j\2\2\u0517\u00e8"+ + "\3\2\2\2\u0518\u0519\7p\2\2\u0519\u051a\7c\2\2\u051a\u051b\7o\2\2\u051b"+ + "\u051c\7g\2\2\u051c\u051d\7u\2\2\u051d\u051e\7r\2\2\u051e\u051f\7c\2\2"+ + "\u051f\u0520\7e\2\2\u0520\u0521\7g\2\2\u0521\u00ea\3\2\2\2\u0522\u0523"+ + "\7p\2\2\u0523\u0524\7g\2\2\u0524\u0525\7y\2\2\u0525\u00ec\3\2\2\2\u0526"+ + "\u0527\7p\2\2\u0527\u0528\7w\2\2\u0528\u0529\7n\2\2\u0529\u052a\7n\2\2"+ + "\u052a\u00ee\3\2\2\2\u052b\u052c\7q\2\2\u052c\u052d\7d\2\2\u052d\u052e"+ + "\7l\2\2\u052e\u052f\7g\2\2\u052f\u0530\7e\2\2\u0530\u0531\7v\2\2\u0531"+ + "\u00f0\3\2\2\2\u0532\u0533\7r\2\2\u0533\u0534\7c\2\2\u0534\u0535\7t\2"+ + "\2\u0535\u0536\7g\2\2\u0536\u0537\7p\2\2\u0537\u0538\7v\2\2\u0538\u00f2"+ + "\3\2\2\2\u0539\u053a\7r\2\2\u053a\u053b\7c\2\2\u053b\u053c\7t\2\2\u053c"+ + "\u053d\7v\2\2\u053d\u053e\7k\2\2\u053e\u053f\7c\2\2\u053f\u0540\7n\2\2"+ + "\u0540\u00f4\3\2\2\2\u0541\u0542\7r\2\2\u0542\u0543\7t\2\2\u0543\u0544"+ + "\7k\2\2\u0544\u0545\7p\2\2\u0545\u0546\7v\2\2\u0546\u00f6\3\2\2\2\u0547"+ + "\u0548\7r\2\2\u0548\u0549\7t\2\2\u0549\u054a\7k\2\2\u054a\u054b\7x\2\2"+ + "\u054b\u054c\7c\2\2\u054c\u054d\7v\2\2\u054d\u054e\7g\2\2\u054e\u00f8"+ + "\3\2\2\2\u054f\u0550\7r\2\2\u0550\u0551\7t\2\2\u0551\u0552\7q\2\2\u0552"+ + "\u0553\7v\2\2\u0553\u0554\7g\2\2\u0554\u0555\7e\2\2\u0555\u0556\7v\2\2"+ + "\u0556\u0557\7g\2\2\u0557\u0558\7f\2\2\u0558\u00fa\3\2\2\2\u0559\u055a"+ + "\7r\2\2\u055a\u055b\7w\2\2\u055b\u055c\7d\2\2\u055c\u055d\7n\2\2\u055d"+ + "\u055e\7k\2\2\u055e\u055f\7e\2\2\u055f\u00fc\3\2\2\2\u0560\u0561\7t\2"+ + "\2\u0561\u0562\7g\2\2\u0562\u0563\7c\2\2\u0563\u0564\7f\2\2\u0564\u0565"+ + "\7q\2\2\u0565\u0566\7p\2\2\u0566\u0567\7n\2\2\u0567\u0568\7{\2\2\u0568"+ + "\u00fe\3\2\2\2\u0569\u056a\7t\2\2\u056a\u056b\7g\2\2\u056b\u056c\7s\2"+ + "\2\u056c\u056d\7w\2\2\u056d\u056e\7k\2\2\u056e\u056f\7t\2\2\u056f\u0570"+ + "\7g\2\2\u0570\u0100\3\2\2\2\u0571\u0572\7t\2\2\u0572\u0573\7g\2\2\u0573"+ + "\u0574\7s\2\2\u0574\u0575\7w\2\2\u0575\u0576\7k\2\2\u0576\u0577\7t\2\2"+ + "\u0577\u0578\7g\2\2\u0578\u0579\7a\2\2\u0579\u057a\7q\2\2\u057a\u057b"+ + "\7p\2\2\u057b\u057c\7e\2\2\u057c\u057d\7g\2\2\u057d\u0102\3\2\2\2\u057e"+ + "\u057f\7t\2\2\u057f\u0580\7g\2\2\u0580\u0581\7u\2\2\u0581\u0582\7q\2\2"+ + "\u0582\u0583\7w\2\2\u0583\u0584\7t\2\2\u0584\u0585\7e\2\2\u0585\u0586"+ + "\7g\2\2\u0586\u0104\3\2\2\2\u0587\u0588\7t\2\2\u0588\u0589\7g\2\2\u0589"+ + "\u058a\7v\2\2\u058a\u058b\7w\2\2\u058b\u058c\7t\2\2\u058c\u058d\7p\2\2"+ + "\u058d\u0106\3\2\2\2\u058e\u058f\7u\2\2\u058f\u0590\7v\2\2\u0590\u0591"+ + "\7c\2\2\u0591\u0592\7v\2\2\u0592\u0593\7k\2\2\u0593\u0594\7e\2\2\u0594"+ + "\u0108\3\2\2\2\u0595\u0596\7u\2\2\u0596\u0597\7v\2\2\u0597\u0598\7t\2"+ + "\2\u0598\u0599\7k\2\2\u0599\u059a\7p\2\2\u059a\u059b\7i\2\2\u059b\u010a"+ + "\3\2\2\2\u059c\u059d\7u\2\2\u059d\u059e\7y\2\2\u059e\u059f\7k\2\2\u059f"+ + "\u05a0\7v\2\2\u05a0\u05a1\7e\2\2\u05a1\u05a2\7j\2\2\u05a2\u010c\3\2\2"+ + "\2\u05a3\u05a4\7v\2\2\u05a4\u05a5\7j\2\2\u05a5\u05a6\7t\2\2\u05a6\u05a7"+ + "\7q\2\2\u05a7\u05a8\7y\2\2\u05a8\u010e\3\2\2\2\u05a9\u05aa\7v\2\2\u05aa"+ + "\u05ab\7t\2\2\u05ab\u05ac\7c\2\2\u05ac\u05ad\7k\2\2\u05ad\u05ae\7v\2\2"+ + "\u05ae\u0110\3\2\2\2\u05af\u05b0\7v\2\2\u05b0\u05b1\7t\2\2\u05b1\u05b2"+ + "\7{\2\2\u05b2\u0112\3\2\2\2\u05b3\u05b4\7e\2\2\u05b4\u05b5\7n\2\2\u05b5"+ + "\u05b6\7t\2\2\u05b6\u05b7\7v\2\2\u05b7\u05b8\7{\2\2\u05b8\u05b9\7r\2\2"+ + "\u05b9\u05ba\7g\2\2\u05ba\u05bb\7q\2\2\u05bb\u05bc\7h\2\2\u05bc\u0114"+ + "\3\2\2\2\u05bd\u05be\7w\2\2\u05be\u05bf\7k\2\2\u05bf\u05c0\7p\2\2\u05c0"+ + "\u05c1\7v\2\2\u05c1\u05c7\3\2\2\2\u05c2\u05c8\7:\2\2\u05c3\u05c4\7\63"+ + "\2\2\u05c4\u05c8\78\2\2\u05c5\u05c6\78\2\2\u05c6\u05c8\7\66\2\2\u05c7"+ + "\u05c2\3\2\2\2\u05c7\u05c3\3\2\2\2\u05c7\u05c5\3\2\2\2\u05c7\u05c8\3\2"+ + "\2\2\u05c8\u0116\3\2\2\2\u05c9\u05ca\7w\2\2\u05ca\u05cb\7p\2\2\u05cb\u05cc"+ + "\7k\2\2\u05cc\u05cd\7e\2\2\u05cd\u05ce\7q\2\2\u05ce\u05cf\7f\2\2\u05cf"+ + "\u05d0\7g\2\2\u05d0\u0118\3\2\2\2\u05d1\u05d2\7w\2\2\u05d2\u05d3\7p\2"+ + "\2\u05d3\u05d4\7u\2\2\u05d4\u05d5\7g\2\2\u05d5\u05d6\7v\2\2\u05d6\u011a"+ + "\3\2\2\2\u05d7\u05d8\7w\2\2\u05d8\u05d9\7u\2\2\u05d9\u05da\7g\2\2\u05da"+ + "\u011c\3\2\2\2\u05db\u05dc\7x\2\2\u05dc\u05dd\7c\2\2\u05dd\u05de\7t\2"+ + "\2\u05de\u011e\3\2\2\2\u05df\u05e0\7y\2\2\u05e0\u05e1\7j\2\2\u05e1\u05e2"+ + "\7k\2\2\u05e2\u05e3\7n\2\2\u05e3\u05e4\7g\2\2\u05e4\u0120\3\2\2\2\u05e5"+ + "\u05e6\7{\2\2\u05e6\u05e7\7k\2\2\u05e7\u05e8\7g\2\2\u05e8\u05e9\7n\2\2"+ + "\u05e9\u05ea\7f\2\2\u05ea\u0122\3\2\2\2\u05eb\u05ec\7h\2\2\u05ec\u05ed"+ + "\7t\2\2\u05ed\u05ee\7q\2\2\u05ee\u05ef\7o\2\2\u05ef\u0124\3\2\2\2\u05f0"+ + "\u05f1\7h\2\2\u05f1\u05f2\7p\2\2\u05f2\u0126\3\2\2\2\u05f3\u05f4\7v\2"+ + "\2\u05f4\u05f5\7k\2\2\u05f5\u05f6\7e\2\2\u05f6\u05f7\7m\2\2\u05f7\u05f8"+ + "\7u\2\2\u05f8\u0128\3\2\2\2\u05f9\u05fa\7g\2\2\u05fa\u05fb\7p\2\2\u05fb"+ + "\u05fc\7e\2\2\u05fc\u05fd\7q\2\2\u05fd\u05fe\7f\2\2\u05fe\u05ff\7k\2\2"+ + "\u05ff\u0600\7p\2\2\u0600\u0601\7i\2\2\u0601\u012a\3\2\2\2\u0602\u0603"+ + "\7u\2\2\u0603\u0604\7v\2\2\u0604\u0605\7t\2\2\u0605\u0606\7k\2\2\u0606"+ + "\u0607\7e\2\2\u0607\u0608\7v\2\2\u0608\u0609\7a\2\2\u0609\u060a\7v\2\2"+ + "\u060a\u060b\7{\2\2\u060b\u060c\7r\2\2\u060c\u060d\7g\2\2\u060d\u060e"+ + "\7u\2\2\u060e\u012c\3\2\2\2\u060f\u0610\7a\2\2\u0610\u0611\7a\2\2\u0611"+ + "\u0612\7i\2\2\u0612\u0613\7g\2\2\u0613\u0614\7v\2\2\u0614\u012e\3\2\2"+ + "\2\u0615\u0616\7a\2\2\u0616\u0617\7a\2\2\u0617\u0618\7u\2\2\u0618\u0619"+ + "\7g\2\2\u0619\u061a\7v\2\2\u061a\u0130\3\2\2\2\u061b\u061c\7a\2\2\u061c"+ + "\u061d\7a\2\2\u061d\u061e\7e\2\2\u061e\u061f\7c\2\2\u061f\u0620\7n\2\2"+ + "\u0620\u0621\7n\2\2\u0621\u0132\3\2\2\2\u0622\u0623\7a\2\2\u0623\u0624"+ + "\7a\2\2\u0624\u0625\7e\2\2\u0625\u0626\7c\2\2\u0626\u0627\7n\2\2\u0627"+ + "\u0628\7n\2\2\u0628\u0629\7u\2\2\u0629\u062a\7v\2\2\u062a\u062b\7c\2\2"+ + "\u062b\u062c\7v\2\2\u062c\u062d\7k\2\2\u062d\u062e\7e\2\2\u062e\u0134"+ + "\3\2\2\2\u062f\u0630\7a\2\2\u0630\u0631\7a\2\2\u0631\u0632\7e\2\2\u0632"+ + "\u0633\7q\2\2\u0633\u0634\7p\2\2\u0634\u0635\7u\2\2\u0635\u0636\7v\2\2"+ + "\u0636\u0637\7t\2\2\u0637\u0638\7w\2\2\u0638\u0639\7e\2\2\u0639\u063a"+ + "\7v\2\2\u063a\u0136\3\2\2\2\u063b\u063c\7a\2\2\u063c\u063d\7a\2\2\u063d"+ + "\u063e\7f\2\2\u063e\u063f\7g\2\2\u063f\u0640\7u\2\2\u0640\u0641\7v\2\2"+ + "\u0641\u0642\7t\2\2\u0642\u0643\7w\2\2\u0643\u0644\7e\2\2\u0644\u0645"+ + "\7v\2\2\u0645\u0138\3\2\2\2\u0646\u0647\7a\2\2\u0647\u0648\7a\2\2\u0648"+ + "\u0649\7y\2\2\u0649\u064a\7c\2\2\u064a\u064b\7m\2\2\u064b\u064c\7g\2\2"+ + "\u064c\u064d\7w\2\2\u064d\u064e\7r\2\2\u064e\u013a\3\2\2\2\u064f\u0650"+ + "\7a\2\2\u0650\u0651\7a\2\2\u0651\u0652\7u\2\2\u0652\u0653\7n\2\2\u0653"+ + "\u0654\7g\2\2\u0654\u0655\7g\2\2\u0655\u0656\7r\2\2\u0656\u013c\3\2\2"+ + "\2\u0657\u0658\7a\2\2\u0658\u0659\7a\2\2\u0659\u065a\7c\2\2\u065a\u065b"+ + "\7w\2\2\u065b\u065c\7v\2\2\u065c\u065d\7q\2\2\u065d\u065e\7n\2\2\u065e"+ + "\u065f\7q\2\2\u065f\u0660\7c\2\2\u0660\u0661\7f\2\2\u0661\u013e\3\2\2"+ + "\2\u0662\u0663\7a\2\2\u0663\u0664\7a\2\2\u0664\u0665\7k\2\2\u0665\u0666"+ + "\7u\2\2\u0666\u0667\7u\2\2\u0667\u0668\7g\2\2\u0668\u0669\7v\2\2\u0669"+ + "\u0140\3\2\2\2\u066a\u066b\7a\2\2\u066b\u066c\7a\2\2\u066c\u066d\7w\2"+ + "\2\u066d\u066e\7p\2\2\u066e\u066f\7u\2\2\u066f\u0670\7g\2\2\u0670\u0671"+ + "\7v\2\2\u0671\u0142\3\2\2\2\u0672\u0673\7a\2\2\u0673\u0674\7a\2\2\u0674"+ + "\u0675\7v\2\2\u0675\u0676\7q\2\2\u0676\u0677\7u\2\2\u0677\u0678\7v\2\2"+ + "\u0678\u0679\7t\2\2\u0679\u067a\7k\2\2\u067a\u067b\7p\2\2\u067b\u067c"+ + "\7i\2\2\u067c\u0144\3\2\2\2\u067d\u067e\7a\2\2\u067e\u067f\7a\2\2\u067f"+ + "\u0680\7k\2\2\u0680\u0681\7p\2\2\u0681\u0682\7x\2\2\u0682\u0683\7q\2\2"+ + "\u0683\u0684\7m\2\2\u0684\u0685\7g\2\2\u0685\u0146\3\2\2\2\u0686\u0687"+ + "\7a\2\2\u0687\u0688\7a\2\2\u0688\u0689\7u\2\2\u0689\u068a\7g\2\2\u068a"+ + "\u068b\7v\2\2\u068b\u068c\7a\2\2\u068c\u068d\7u\2\2\u068d\u068e\7v\2\2"+ + "\u068e\u068f\7c\2\2\u068f\u0690\7v\2\2\u0690\u0691\7g\2\2\u0691\u0148"+ + "\3\2\2\2\u0692\u0693\7a\2\2\u0693\u0694\7a\2\2\u0694\u0695\7e\2\2\u0695"+ + "\u0696\7n\2\2\u0696\u0697\7q\2\2\u0697\u0698\7p\2\2\u0698\u0699\7g\2\2"+ + "\u0699\u014a\3\2\2\2\u069a\u069b\7a\2\2\u069b\u069c\7a\2\2\u069c\u069d"+ + "\7f\2\2\u069d\u069e\7g\2\2\u069e\u069f\7d\2\2\u069f\u06a0\7w\2\2\u06a0"+ + "\u06a1\7i\2\2\u06a1\u06a2\7k\2\2\u06a2\u06a3\7p\2\2\u06a3\u06a4\7h\2\2"+ + "\u06a4\u06a5\7q\2\2\u06a5\u014c\3\2\2\2\u06a6\u06a7\7a\2\2\u06a7\u06a8"+ + "\7a\2\2\u06a8\u06a9\7p\2\2\u06a9\u06aa\7c\2\2\u06aa\u06ab\7o\2\2\u06ab"+ + "\u06ac\7g\2\2\u06ac\u06ad\7u\2\2\u06ad\u06ae\7r\2\2\u06ae\u06af\7c\2\2"+ + "\u06af\u06b0\7e\2\2\u06b0\u06b1\7g\2\2\u06b1\u06b2\7a\2\2\u06b2\u06b3"+ + "\7a\2\2\u06b3\u014e\3\2\2\2\u06b4\u06b5\7a\2\2\u06b5\u06b6\7a\2\2\u06b6"+ + "\u06b7\7e\2\2\u06b7\u06b8\7n\2\2\u06b8\u06b9\7c\2\2\u06b9\u06ba\7u\2\2"+ + "\u06ba\u06bb\7u\2\2\u06bb\u06bc\7a\2\2\u06bc\u06bd\7a\2\2\u06bd\u0150"+ + "\3\2\2\2\u06be\u06bf\7a\2\2\u06bf\u06c0\7a\2\2\u06c0\u06c1\7v\2\2\u06c1"+ + "\u06c2\7t\2\2\u06c2\u06c3\7c\2\2\u06c3\u06c4\7k\2\2\u06c4\u06c5\7v\2\2"+ + "\u06c5\u06c6\7a\2\2\u06c6\u06c7\7a\2\2\u06c7\u0152\3\2\2\2\u06c8\u06c9"+ + "\7a\2\2\u06c9\u06ca\7a\2\2\u06ca\u06cb\7h\2\2\u06cb\u06cc\7w\2\2\u06cc"+ + "\u06cd\7p\2\2\u06cd\u06ce\7e\2\2\u06ce\u06cf\7v\2\2\u06cf\u06d0\7k\2\2"+ + "\u06d0\u06d1\7q\2\2\u06d1\u06d2\7p\2\2\u06d2\u06d3\7a\2\2\u06d3\u06d4"+ + "\7a\2\2\u06d4\u0154\3\2\2\2\u06d5\u06d6\7a\2\2\u06d6\u06d7\7a\2\2\u06d7"+ + "\u06d8\7o\2\2\u06d8\u06d9\7g\2\2\u06d9\u06da\7v\2\2\u06da\u06db\7j\2\2"+ + "\u06db\u06dc\7q\2\2\u06dc\u06dd\7f\2\2\u06dd\u06de\7a\2\2\u06de\u06df"+ + "\7a\2\2\u06df\u0156\3\2\2\2\u06e0\u06e1\7a\2\2\u06e1\u06e2\7a\2\2\u06e2"+ + "\u06e3\7n\2\2\u06e3\u06e4\7k\2\2\u06e4\u06e5\7p\2\2\u06e5\u06e6\7g\2\2"+ + "\u06e6\u06e7\7a\2\2\u06e7\u06e8\7a\2\2\u06e8\u0158\3\2\2\2\u06e9\u06ea"+ + "\7a\2\2\u06ea\u06eb\7a\2\2\u06eb\u06ec\7h\2\2\u06ec\u06ed\7k\2\2\u06ed"+ + "\u06ee\7n\2\2\u06ee\u06ef\7g\2\2\u06ef\u06f0\7a\2\2\u06f0\u06f1\7a\2\2"+ + "\u06f1\u015a\3\2\2\2\u06f2\u06f3\7a\2\2\u06f3\u06f4\7a\2\2\u06f4\u06f5"+ + "\7f\2\2\u06f5\u06f6\7k\2\2\u06f6\u06f7\7t\2\2\u06f7\u06f8\7a\2\2\u06f8"+ + "\u06f9\7a\2\2\u06f9\u015c\3\2\2\2\u06fa\u06fb\7>\2\2\u06fb\u06fc\7?\2"+ + "\2\u06fc\u06fd\7@\2\2\u06fd\u015e\3\2\2\2\u06fe\u06ff\7>\2\2\u06ff\u0700"+ + "\7<\2\2\u0700\u0160\3\2\2\2\u0701\u0702\7<\2\2\u0702\u0703\7@\2\2\u0703"+ + "\u0162\3\2\2\2\u0704\u0705\7?\2\2\u0705\u0706\7@\2\2\u0706\u0164\3\2\2"+ + "\2\u0707\u0708\7-\2\2\u0708\u0709\7-\2\2\u0709\u0166\3\2\2\2\u070a\u070b"+ + "\7/\2\2\u070b\u070c\7/\2\2\u070c\u0168\3\2\2\2\u070d\u070e\7?\2\2\u070e"+ + "\u070f\7?\2\2\u070f\u0710\7?\2\2\u0710\u016a\3\2\2\2\u0711\u0712\7#\2"+ + "\2\u0712\u0713\7?\2\2\u0713\u0714\7?\2\2\u0714\u016c\3\2\2\2\u0715\u0716"+ + "\7?\2\2\u0716\u0717\7?\2\2\u0717\u016e\3\2\2\2\u0718\u0719\7>\2\2\u0719"+ + "\u071d\7@\2\2\u071a\u071b\7#\2\2\u071b\u071d\7?\2\2\u071c\u0718\3\2\2"+ + "\2\u071c\u071a\3\2\2\2\u071d\u0170\3\2\2\2\u071e\u071f\7>\2\2\u071f\u0720"+ + "\7?\2\2\u0720\u0172\3\2\2\2\u0721\u0722\7@\2\2\u0722\u0723\7?\2\2\u0723"+ + "\u0174\3\2\2\2\u0724\u0725\7-\2\2\u0725\u0726\7?\2\2\u0726\u0176\3\2\2"+ + "\2\u0727\u0728\7/\2\2\u0728\u0729\7?\2\2\u0729\u0178\3\2\2\2\u072a\u072b"+ + "\7,\2\2\u072b\u072c\7?\2\2\u072c\u017a\3\2\2\2\u072d\u072e\7,\2\2\u072e"+ + "\u072f\7,\2\2\u072f\u017c\3\2\2\2\u0730\u0731\7,\2\2\u0731\u0732\7,\2"+ + "\2\u0732\u0733\7?\2\2\u0733\u017e\3\2\2\2\u0734\u0735\7\61\2\2\u0735\u0736"+ + "\7?\2\2\u0736\u0180\3\2\2\2\u0737\u0738\7\60\2\2\u0738\u0739\7?\2\2\u0739"+ + "\u0182\3\2\2\2\u073a\u073b\7\'\2\2\u073b\u073c\7?\2\2\u073c\u0184\3\2"+ + "\2\2\u073d\u073e\7>\2\2\u073e\u073f\7>\2\2\u073f\u0740\7?\2\2\u0740\u0186"+ + "\3\2\2\2\u0741\u0742\7@\2\2\u0742\u0743\7@\2\2\u0743\u0744\7?\2\2\u0744"+ + "\u0188\3\2\2\2\u0745\u0746\7(\2\2\u0746\u0747\7?\2\2\u0747\u018a\3\2\2"+ + "\2\u0748\u0749\7~\2\2\u0749\u074a\7?\2\2\u074a\u018c\3\2\2\2\u074b\u074c"+ + "\7`\2\2\u074c\u074d\7?\2\2\u074d\u018e\3\2\2\2\u074e\u074f\7~\2\2\u074f"+ + "\u0750\7~\2\2\u0750\u0190\3\2\2\2\u0751\u0752\7(\2\2\u0752\u0753\7(\2"+ + "\2\u0753\u0192\3\2\2\2\u0754\u0755\7A\2\2\u0755\u0756\7A\2\2\u0756\u0194"+ + "\3\2\2\2\u0757\u0758\7A\2\2\u0758\u0759\7A\2\2\u0759\u075a\7?\2\2\u075a"+ + "\u0196\3\2\2\2\u075b\u075c\7>\2\2\u075c\u075d\7>\2\2\u075d\u0198\3\2\2"+ + "\2\u075e\u075f\7@\2\2\u075f\u0760\7@\2\2\u0760\u019a\3\2\2\2\u0761\u0762"+ + "\7<\2\2\u0762\u0763\7<\2\2\u0763\u019c\3\2\2\2\u0764\u0765\7/\2\2\u0765"+ + "\u0766\7@\2\2\u0766\u019e\3\2\2\2\u0767\u0768\7^\2\2\u0768\u01a0\3\2\2"+ + "\2\u0769\u076a\7\60\2\2\u076a\u076b\7\60\2\2\u076b\u076c\7\60\2\2\u076c"+ + "\u01a2\3\2\2\2\u076d\u076e\7>\2\2\u076e\u01a4\3\2\2\2\u076f\u0770\7@\2"+ + "\2\u0770\u01a6\3\2\2\2\u0771\u0772\7(\2\2\u0772\u01a8\3\2\2\2\u0773\u0774"+ + "\7~\2\2\u0774\u01aa\3\2\2\2\u0775\u0776\7#\2\2\u0776\u01ac\3\2\2\2\u0777"+ + "\u0778\7`\2\2\u0778\u01ae\3\2\2\2\u0779\u077a\7-\2\2\u077a\u01b0\3\2\2"+ + "\2\u077b\u077c\7/\2\2\u077c\u01b2\3\2\2\2\u077d\u077e\7,\2\2\u077e\u01b4"+ + "\3\2\2\2\u077f\u0780\7\'\2\2\u0780\u01b6\3\2\2\2\u0781\u0782\7\61\2\2"+ + "\u0782\u01b8\3\2\2\2\u0783\u0784\7\u0080\2\2\u0784\u01ba\3\2\2\2\u0785"+ + "\u0786\7B\2\2\u0786\u01bc\3\2\2\2\u0787\u0788\7&\2\2\u0788\u01be\3\2\2"+ + "\2\u0789\u078a\7\60\2\2\u078a\u01c0\3\2\2\2\u078b\u078c\7A\2\2\u078c\u01c2"+ + "\3\2\2\2\u078d\u078e\7*\2\2\u078e\u01c4\3\2\2\2\u078f\u0790\7+\2\2\u0790"+ + "\u01c6\3\2\2\2\u0791\u0792\7]\2\2\u0792\u01c8\3\2\2\2\u0793\u0794\7_\2"+ + "\2\u0794\u01ca\3\2\2\2\u0795\u0796\7}\2\2\u0796\u01cc\3\2\2\2\u0797\u0798"+ + "\7\177\2\2\u0798\u0799\b\u00e2\24\2\u0799\u01ce\3\2\2\2\u079a\u079b\7"+ + ".\2\2\u079b\u01d0\3\2\2\2\u079c\u079d\7<\2\2\u079d\u01d2\3\2\2\2\u079e"+ + "\u079f\7=\2\2\u079f\u01d4\3\2\2\2\u07a0\u07a1\7?\2\2\u07a1\u01d6\3\2\2"+ + "\2\u07a2\u07a3\7)\2\2\u07a3\u01d8\3\2\2\2\u07a4\u07a5\7b\2\2\u07a5\u01da"+ + "\3\2\2\2\u07a6\u07a7\7&\2\2\u07a7\u07a8\5\u0213\u0105\2\u07a8\u01dc\3"+ + "\2\2\2\u07a9\u07ad\t\t\2\2\u07aa\u07ac\t\n\2\2\u07ab\u07aa\3\2\2\2\u07ac"+ + "\u07af\3\2\2\2\u07ad\u07ab\3\2\2\2\u07ad\u07ae\3\2\2\2\u07ae\u01de\3\2"+ + "\2\2\u07af\u07ad\3\2\2\2\u07b0\u07b2\7\62\2\2\u07b1\u07b3\7q\2\2\u07b2"+ + "\u07b1\3\2\2\2\u07b2\u07b3\3\2\2\2\u07b3\u07b5\3\2\2\2\u07b4\u07b6\5\u0221"+ + "\u010c\2\u07b5\u07b4\3\2\2\2\u07b6\u07b7\3\2\2\2\u07b7\u07b5\3\2\2\2\u07b7"+ + "\u07b8\3\2\2\2\u07b8\u07c1\3\2\2\2\u07b9\u07bb\7a\2\2\u07ba\u07bc\5\u0221"+ + "\u010c\2\u07bb\u07ba\3\2\2\2\u07bc\u07bd\3\2\2\2\u07bd\u07bb\3\2\2\2\u07bd"+ + "\u07be\3\2\2\2\u07be\u07c0\3\2\2\2\u07bf\u07b9\3\2\2\2\u07c0\u07c3\3\2"+ + "\2\2\u07c1\u07bf\3\2\2\2\u07c1\u07c2\3\2\2\2\u07c2\u01e0\3\2\2\2\u07c3"+ + "\u07c1\3\2\2\2\u07c4\u07d8\7\62\2\2\u07c5\u07c9\5\u021d\u010a\2\u07c6"+ + "\u07c8\5\u021f\u010b\2\u07c7\u07c6\3\2\2\2\u07c8\u07cb\3\2\2\2\u07c9\u07c7"+ + "\3\2\2\2\u07c9\u07ca\3\2\2\2\u07ca\u07d4\3\2\2\2\u07cb\u07c9\3\2\2\2\u07cc"+ + "\u07ce\7a\2\2\u07cd\u07cf\5\u021f\u010b\2\u07ce\u07cd\3\2\2\2\u07cf\u07d0"+ + "\3\2\2\2\u07d0\u07ce\3\2\2\2\u07d0\u07d1\3\2\2\2\u07d1\u07d3\3\2\2\2\u07d2"+ + "\u07cc\3\2\2\2\u07d3\u07d6\3\2\2\2\u07d4\u07d2\3\2\2\2\u07d4\u07d5\3\2"+ + "\2\2\u07d5\u07d8\3\2\2\2\u07d6\u07d4\3\2\2\2\u07d7\u07c4\3\2\2\2\u07d7"+ + "\u07c5\3\2\2\2\u07d8\u01e2\3\2\2\2\u07d9\u07da\5\u0219\u0108\2\u07da\u07dc"+ + "\7\60\2\2\u07db\u07dd\5\u0219\u0108\2\u07dc\u07db\3\2\2\2\u07dc\u07dd"+ + "\3\2\2\2\u07dd\u07e4\3\2\2\2\u07de\u07e0\5\u0219\u0108\2\u07df\u07de\3"+ + "\2\2\2\u07df\u07e0\3\2\2\2\u07e0\u07e1\3\2\2\2\u07e1\u07e2\7\60\2\2\u07e2"+ + "\u07e4\5\u0219\u0108\2\u07e3\u07d9\3\2\2\2\u07e3\u07df\3\2\2\2\u07e4\u07e6"+ + "\3\2\2\2\u07e5\u07e7\5\u021b\u0109\2\u07e6\u07e5\3\2\2\2\u07e6\u07e7\3"+ + "\2\2\2\u07e7\u07f0\3\2\2\2\u07e8\u07ea\5\u0219\u0108\2\u07e9\u07e8\3\2"+ + "\2\2\u07ea\u07eb\3\2\2\2\u07eb\u07e9\3\2\2\2\u07eb\u07ec\3\2\2\2\u07ec"+ + "\u07ed\3\2\2\2\u07ed\u07ee\5\u021b\u0109\2\u07ee\u07f0\3\2\2\2\u07ef\u07e3"+ + "\3\2\2\2\u07ef\u07e9\3\2\2\2\u07f0\u01e4\3\2\2\2\u07f1\u07f2\7\62\2\2"+ + "\u07f2\u07f3\7z\2\2\u07f3\u07f5\3\2\2\2\u07f4\u07f6\5\u0223\u010d\2\u07f5"+ + "\u07f4\3\2\2\2\u07f6\u07f7\3\2\2\2\u07f7\u07f5\3\2\2\2\u07f7\u07f8\3\2"+ + "\2\2\u07f8\u0801\3\2\2\2\u07f9\u07fb\7a\2\2\u07fa\u07fc\5\u0223\u010d"+ + "\2\u07fb\u07fa\3\2\2\2\u07fc\u07fd\3\2\2\2\u07fd\u07fb\3\2\2\2\u07fd\u07fe"+ + "\3\2\2\2\u07fe\u0800\3\2\2\2\u07ff\u07f9\3\2\2\2\u0800\u0803\3\2\2\2\u0801"+ + "\u07ff\3\2\2\2\u0801\u0802\3\2\2\2\u0802\u01e6\3\2\2\2\u0803\u0801\3\2"+ + "\2\2\u0804\u0805\7\62\2\2\u0805\u0806\7d\2\2\u0806\u0808\3\2\2\2\u0807"+ + "\u0809\t\13\2\2\u0808\u0807\3\2\2\2\u0809\u080a\3\2\2\2\u080a\u0808\3"+ + "\2\2\2\u080a\u080b\3\2\2\2\u080b\u0814\3\2\2\2\u080c\u080e\7a\2\2\u080d"+ + "\u080f\t\13\2\2\u080e\u080d\3\2\2\2\u080f\u0810\3\2\2\2\u0810\u080e\3"+ + "\2\2\2\u0810\u0811\3\2\2\2\u0811\u0813\3\2\2\2\u0812\u080c\3\2\2\2\u0813"+ + "\u0816\3\2\2\2\u0814\u0812\3\2\2\2\u0814\u0815\3\2\2\2\u0815\u01e8\3\2"+ + "\2\2\u0816\u0814\3\2\2\2\u0817\u081b\7b\2\2\u0818\u081a\n\f\2\2\u0819"+ + "\u0818\3\2\2\2\u081a\u081d\3\2\2\2\u081b\u0819\3\2\2\2\u081b\u081c\3\2"+ + "\2\2\u081c\u081e\3\2\2\2\u081d\u081b\3\2\2\2\u081e\u081f\7b\2\2\u081f"+ + "\u01ea\3\2\2\2\u0820\u0826\7)\2\2\u0821\u0825\n\r\2\2\u0822\u0823\7^\2"+ + "\2\u0823\u0825\13\2\2\2\u0824\u0821\3\2\2\2\u0824\u0822\3\2\2\2\u0825"+ + "\u0828\3\2\2\2\u0826\u0824\3\2\2\2\u0826\u0827\3\2\2\2\u0827\u0829\3\2"+ + "\2\2\u0828\u0826\3\2\2\2\u0829\u082a\7)\2\2\u082a\u01ec\3\2\2\2\u082b"+ + "\u082c\7$\2\2\u082c\u082d\3\2\2\2\u082d\u082e\b\u00f2\25\2\u082e\u01ee"+ + "\3\2\2\2\u082f\u0830\7>\2\2\u0830\u0831\7>\2\2\u0831\u0832\7>\2\2\u0832"+ + "\u0836\3\2\2\2\u0833\u0835\t\16\2\2\u0834\u0833\3\2\2\2\u0835\u0838\3"+ + "\2\2\2\u0836\u0834\3\2\2\2\u0836\u0837\3\2\2\2\u0837\u0839\3\2\2\2\u0838"+ + "\u0836\3\2\2\2\u0839\u083a\7)\2\2\u083a\u083b\5\u0213\u0105\2\u083b\u083c"+ + "\7)\2\2\u083c\u083d\6\u00f3\5\2\u083d\u083e\3\2\2\2\u083e\u083f\b\u00f3"+ + "\26\2\u083f\u01f0\3\2\2\2\u0840\u0841\7>\2\2\u0841\u0842\7>\2\2\u0842"+ + "\u0843\7>\2\2\u0843\u0847\3\2\2\2\u0844\u0846\t\16\2\2\u0845\u0844\3\2"+ + "\2\2\u0846\u0849\3\2\2\2\u0847\u0845\3\2\2\2\u0847\u0848\3\2\2\2\u0848"+ + "\u084a\3\2\2\2\u0849\u0847\3\2\2\2\u084a\u084b\5\u0213\u0105\2\u084b\u084c"+ + "\6\u00f4\6\2\u084c\u084d\3\2\2\2\u084d\u084e\b\u00f4\26\2\u084e\u01f2"+ + "\3\2\2\2\u084f\u0850\13\2\2\2\u0850\u0851\3\2\2\2\u0851\u0852\b\u00f5"+ + "\13\2\u0852\u01f4\3\2\2\2\u0853\u0854\7&\2\2\u0854\u0855\5\u0213\u0105"+ + "\2\u0855\u0856\3\2\2\2\u0856\u0857\b\u00f6\27\2\u0857\u01f6\3\2\2\2\u0858"+ + "\u0859\7&\2\2\u0859\u085a\3\2\2\2\u085a\u085b\b\u00f7\30\2\u085b\u01f8"+ + "\3\2\2\2\u085c\u085d\7}\2\2\u085d\u085e\6\u00f8\7\2\u085e\u085f\b\u00f8"+ + "\31\2\u085f\u0860\3\2\2\2\u0860\u0861\b\u00f8\6\2\u0861\u0862\b\u00f8"+ + "\5\2\u0862\u01fa\3\2\2\2\u0863\u0864\7}\2\2\u0864\u0865\3\2\2\2\u0865"+ + "\u0866\b\u00f9\30\2\u0866\u01fc\3\2\2\2\u0867\u0868\7^\2\2\u0868\u0869"+ + "\13\2\2\2\u0869\u086a\3\2\2\2\u086a\u086b\b\u00fa\30\2\u086b\u01fe\3\2"+ + "\2\2\u086c\u086d\7$\2\2\u086d\u086e\3\2\2\2\u086e\u086f\b\u00fb\32\2\u086f"+ + "\u0870\b\u00fb\f\2\u0870\u0200\3\2\2\2\u0871\u0872\7^\2\2\u0872\u0873"+ + "\7w\2\2\u0873\u0874\7}\2\2\u0874\u0875\3\2\2\2\u0875\u0877\t\17\2\2\u0876"+ + "\u0878\t\17\2\2\u0877\u0876\3\2\2\2\u0878\u0879\3\2\2\2\u0879\u0877\3"+ + "\2\2\2\u0879\u087a\3\2\2\2\u087a\u087b\3\2\2\2\u087b\u087c\7\177\2\2\u087c"+ + "\u0202\3\2\2\2\u087d\u087f\n\20\2\2\u087e\u087d\3\2\2\2\u087f\u0880\3"+ + "\2\2\2\u0880\u087e\3\2\2\2\u0880\u0881\3\2\2\2\u0881\u0204\3\2\2\2\u0882"+ + "\u0884\n\21\2\2\u0883\u0882\3\2\2\2\u0884\u0885\3\2\2\2\u0885\u0883\3"+ + "\2\2\2\u0885\u0886\3\2\2\2\u0886\u0887\3\2\2\2\u0887\u0888\b\u00fe\22"+ + "\2\u0888\u0206\3\2\2\2\u0889\u088a\7A\2\2\u088a\u088b\7@\2\2\u088b\u0208"+ + "\3\2\2\2\u088c\u088d\7A\2\2\u088d\u088e\3\2\2\2\u088e\u088f\b\u0100\33"+ + "\2\u088f\u0890\b\u0100\22\2\u0890\u020a\3\2\2\2\u0891\u0892\t\4\2\2\u0892"+ + "\u0893\3\2\2\2\u0893\u0894\b\u0101\6\2\u0894\u0895\b\u0101\f\2\u0895\u020c"+ + "\3\2\2\2\u0896\u0898\n\4\2\2\u0897\u0896\3\2\2\2\u0898\u089b\3\2\2\2\u0899"+ + "\u089a\3\2\2\2\u0899\u0897\3\2\2\2\u089a\u08a1\3\2\2\2\u089b\u0899\3\2"+ + "\2\2\u089c\u089e\7\17\2\2\u089d\u089c\3\2\2\2\u089d\u089e\3\2\2\2\u089e"+ + "\u089f\3\2\2\2\u089f\u08a2\7\f\2\2\u08a0\u08a2\7\17\2\2\u08a1\u089d\3"+ + "\2\2\2\u08a1\u08a0\3\2\2\2\u08a2\u020e\3\2\2\2\u08a3\u08a9\7>\2\2\u08a4"+ + "\u08a5\7A\2\2\u08a5\u08aa\7?\2\2\u08a6\u08a7\6\u0103\b\2\u08a7\u08a8\7"+ + "\'\2\2\u08a8\u08aa\7?\2\2\u08a9\u08a4\3\2\2\2\u08a9\u08a6\3\2\2\2\u08aa"+ + "\u0210\3\2\2\2\u08ab\u08b4\7>\2\2\u08ac\u08b0\7A\2\2\u08ad\u08ae\7r\2"+ + "\2\u08ae\u08af\7j\2\2\u08af\u08b1\7r\2\2\u08b0\u08ad\3\2\2\2\u08b0\u08b1"+ + "\3\2\2\2\u08b1\u08b5\3\2\2\2\u08b2\u08b3\6\u0104\t\2\u08b3\u08b5\7\'\2"+ + "\2\u08b4\u08ac\3\2\2\2\u08b4\u08b2\3\2\2\2\u08b5\u0212\3\2\2\2\u08b6\u08ba"+ + "\t\22\2\2\u08b7\u08b9\t\23\2\2\u08b8\u08b7\3\2\2\2\u08b9\u08bc\3\2\2\2"+ + "\u08ba\u08b8\3\2\2\2\u08ba\u08bb\3\2\2\2\u08bb\u0214\3\2\2\2\u08bc\u08ba"+ + "\3\2\2\2\u08bd\u08c2\5\u0217\u0107\2\u08be\u08c2\t\24\2\2\u08bf\u08c2"+ + "\5\u021f\u010b\2\u08c0\u08c2\t\25\2\2\u08c1\u08bd\3\2\2\2\u08c1\u08be"+ + "\3\2\2\2\u08c1\u08bf\3\2\2\2\u08c1\u08c0\3\2\2\2\u08c2\u0216\3\2\2\2\u08c3"+ + "\u08c5\t\26\2\2\u08c4\u08c3\3\2\2\2\u08c5\u0218\3\2\2\2\u08c6\u08c8\5"+ + "\u021f\u010b\2\u08c7\u08c6\3\2\2\2\u08c8\u08c9\3\2\2\2\u08c9\u08c7\3\2"+ + "\2\2\u08c9\u08ca\3\2\2\2\u08ca\u08d3\3\2\2\2\u08cb\u08cd\7a\2\2\u08cc"+ + "\u08ce\5\u021f\u010b\2\u08cd\u08cc\3\2\2\2\u08ce\u08cf\3\2\2\2\u08cf\u08cd"+ + "\3\2\2\2\u08cf\u08d0\3\2\2\2\u08d0\u08d2\3\2\2\2\u08d1\u08cb\3\2\2\2\u08d2"+ + "\u08d5\3\2\2\2\u08d3\u08d1\3\2\2\2\u08d3\u08d4\3\2\2\2\u08d4\u021a\3\2"+ + "\2\2\u08d5\u08d3\3\2\2\2\u08d6\u08d8\7g\2\2\u08d7\u08d9\t\27\2\2\u08d8"+ + "\u08d7\3\2\2\2\u08d8\u08d9\3\2\2\2\u08d9\u08da\3\2\2\2\u08da\u08db\5\u0219"+ + "\u0108\2\u08db\u021c\3\2\2\2\u08dc\u08dd\t\30\2\2\u08dd\u021e\3\2\2\2"+ + "\u08de\u08df\t\31\2\2\u08df\u0220\3\2\2\2\u08e0\u08e1\t\32\2\2\u08e1\u0222"+ + "\3\2\2\2\u08e2\u08e3\t\33\2\2\u08e3\u0224\3\2\2\2U\2\3\4\5\6\7\b\t\n\13"+ + "\f\u0228\u022f\u0263\u0272\u0281\u0288\u0294\u02b6\u02bd\u02c7\u02cc\u02d1"+ + "\u02d9\u02ec\u02f3\u0305\u030c\u0315\u0320\u0337\u0342\u034b\u0359\u035e"+ + "\u0368\u039f\u03aa\u04f0\u05c7\u071c\u07ad\u07b2\u07b7\u07bd\u07c1\u07c9"+ + "\u07d0\u07d4\u07d7\u07dc\u07df\u07e3\u07e6\u07eb\u07ef\u07f7\u07fd\u0801"+ + "\u080a\u0810\u0814\u081b\u0824\u0826\u0836\u0847\u0879\u0880\u0885\u0899"+ + "\u089d\u08a1\u08a9\u08b0\u08b4\u08ba\u08c1\u08c4\u08c9\u08cf\u08d3\u08d8"+ + "\34\2\3\2\7\3\2\tA\2\7\t\2\2\6\2\3\7\2\7\4\2\3\b\3\5\2\2\2\5\2\6\2\2\t"+ + "\16\2\3\24\4\7\5\2\7\6\2\t$\2\2\4\2\7\13\2\3\u00e2\5\7\n\2\7\f\2\t\u00e2"+ + "\2\t\u00f1\2\3\u00f8\6\t\u00eb\2\t\u00f2\2"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/app/src/main/java/antlr/PhpLexer.tokens b/app/src/main/java/antlr/PhpLexer.tokens new file mode 100644 index 0000000000000000000000000000000000000000..67693cc29a5a6fd4e9d85800def2113c4253c5ab --- /dev/null +++ b/app/src/main/java/antlr/PhpLexer.tokens @@ -0,0 +1,416 @@ +SeaWhitespace=1 +HtmlText=2 +XmlStart=3 +PHPStart=4 +HtmlScriptOpen=5 +HtmlStyleOpen=6 +HtmlComment=7 +HtmlDtd=8 +HtmlOpen=9 +Shebang=10 +Error=11 +XmlText=12 +XmlClose=13 +PHPStartInside=14 +HtmlClose=15 +HtmlSlashClose=16 +HtmlSlash=17 +HtmlEquals=18 +HtmlStartQuoteString=19 +HtmlStartDoubleQuoteString=20 +HtmlHex=21 +HtmlDecimal=22 +HtmlSpace=23 +HtmlName=24 +ErrorInside=25 +PHPStartInsideQuoteString=26 +HtmlEndQuoteString=27 +HtmlQuoteString=28 +ErrorHtmlQuote=29 +PHPStartDoubleQuoteString=30 +HtmlEndDoubleQuoteString=31 +HtmlDoubleQuoteString=32 +ErrorHtmlDoubleQuote=33 +ScriptText=34 +HtmlScriptClose=35 +PHPStartInsideScript=36 +StyleBody=37 +PHPEnd=38 +Whitespace=39 +MultiLineComment=40 +SingleLineComment=41 +ShellStyleComment=42 +AttributeStart=43 +Abstract=44 +Array=45 +As=46 +BinaryCast=47 +BoolType=48 +BooleanConstant=49 +Break=50 +Callable=51 +Case=52 +Catch=53 +Class=54 +Clone=55 +Const=56 +Continue=57 +Declare=58 +Default=59 +Do=60 +DoubleCast=61 +DoubleType=62 +Echo=63 +Else=64 +ElseIf=65 +Empty=66 +Enum_=67 +EndDeclare=68 +EndFor=69 +EndForeach=70 +EndIf=71 +EndSwitch=72 +EndWhile=73 +Eval=74 +Exit=75 +Extends=76 +Final=77 +Finally=78 +FloatCast=79 +For=80 +Foreach=81 +Function_=82 +Global=83 +Goto=84 +If=85 +Implements=86 +Import=87 +Include=88 +IncludeOnce=89 +InstanceOf=90 +InsteadOf=91 +Int8Cast=92 +Int16Cast=93 +Int64Type=94 +IntType=95 +Interface=96 +IsSet=97 +List=98 +LogicalAnd=99 +LogicalOr=100 +LogicalXor=101 +Match_=102 +Namespace=103 +New=104 +Null=105 +ObjectType=106 +Parent_=107 +Partial=108 +Print=109 +Private=110 +Protected=111 +Public=112 +Readonly=113 +Require=114 +RequireOnce=115 +Resource=116 +Return=117 +Static=118 +StringType=119 +Switch=120 +Throw=121 +Trait=122 +Try=123 +Typeof=124 +UintCast=125 +UnicodeCast=126 +Unset=127 +Use=128 +Var=129 +While=130 +Yield=131 +From=132 +LambdaFn=133 +Ticks=134 +Encoding=135 +StrictTypes=136 +Get=137 +Set=138 +Call=139 +CallStatic=140 +Constructor=141 +Destruct=142 +Wakeup=143 +Sleep=144 +Autoload=145 +IsSet__=146 +Unset__=147 +ToString__=148 +Invoke=149 +SetState=150 +Clone__=151 +DebugInfo=152 +Namespace__=153 +Class__=154 +Traic__=155 +Function__=156 +Method__=157 +Line__=158 +File__=159 +Dir__=160 +Spaceship=161 +Lgeneric=162 +Rgeneric=163 +DoubleArrow=164 +Inc=165 +Dec=166 +IsIdentical=167 +IsNoidentical=168 +IsEqual=169 +IsNotEq=170 +IsSmallerOrEqual=171 +IsGreaterOrEqual=172 +PlusEqual=173 +MinusEqual=174 +MulEqual=175 +Pow=176 +PowEqual=177 +DivEqual=178 +Concaequal=179 +ModEqual=180 +ShiftLeftEqual=181 +ShiftRightEqual=182 +AndEqual=183 +OrEqual=184 +XorEqual=185 +BooleanOr=186 +BooleanAnd=187 +NullCoalescing=188 +NullCoalescingEqual=189 +ShiftLeft=190 +ShiftRight=191 +DoubleColon=192 +ObjectOperator=193 +NamespaceSeparator=194 +Ellipsis=195 +Less=196 +Greater=197 +Ampersand=198 +Pipe=199 +Bang=200 +Caret=201 +Plus=202 +Minus=203 +Asterisk=204 +Percent=205 +Divide=206 +Tilde=207 +SuppressWarnings=208 +Dollar=209 +Dot=210 +QuestionMark=211 +OpenRoundBracket=212 +CloseRoundBracket=213 +OpenSquareBracket=214 +CloseSquareBracket=215 +OpenCurlyBracket=216 +CloseCurlyBracket=217 +Comma=218 +Colon=219 +SemiColon=220 +Eq=221 +Quote=222 +BackQuote=223 +VarName=224 +Label=225 +Octal=226 +Decimal=227 +Real=228 +Hex=229 +Binary=230 +BackQuoteString=231 +SingleQuoteString=232 +DoubleQuote=233 +StartNowDoc=234 +StartHereDoc=235 +ErrorPhp=236 +CurlyDollar=237 +UnicodeEscape=238 +StringPart=239 +Comment=240 +PHPEndSingleLineComment=241 +CommentEnd=242 +HereDocText=243 +XmlText2=244 +'<?xml'=3 +'?>'=13 +'/>'=16 +'#['=43 +'abstract'=44 +'array'=45 +'as'=46 +'binary'=47 +'break'=50 +'callable'=51 +'case'=52 +'catch'=53 +'class'=54 +'clone'=55 +'const'=56 +'continue'=57 +'declare'=58 +'default'=59 +'do'=60 +'real'=61 +'double'=62 +'echo'=63 +'else'=64 +'elseif'=65 +'empty'=66 +'enum'=67 +'enddeclare'=68 +'endfor'=69 +'endforeach'=70 +'endif'=71 +'endswitch'=72 +'endwhile'=73 +'eval'=74 +'die'=75 +'extends'=76 +'final'=77 +'finally'=78 +'float'=79 +'for'=80 +'foreach'=81 +'function'=82 +'global'=83 +'goto'=84 +'if'=85 +'implements'=86 +'import'=87 +'include'=88 +'include_once'=89 +'instanceof'=90 +'insteadof'=91 +'int8'=92 +'int16'=93 +'int64'=94 +'interface'=96 +'isset'=97 +'list'=98 +'and'=99 +'or'=100 +'xor'=101 +'match'=102 +'namespace'=103 +'new'=104 +'null'=105 +'object'=106 +'parent'=107 +'partial'=108 +'print'=109 +'private'=110 +'protected'=111 +'public'=112 +'readonly'=113 +'require'=114 +'require_once'=115 +'resource'=116 +'return'=117 +'static'=118 +'string'=119 +'switch'=120 +'throw'=121 +'trait'=122 +'try'=123 +'clrtypeof'=124 +'unicode'=126 +'unset'=127 +'use'=128 +'var'=129 +'while'=130 +'yield'=131 +'from'=132 +'fn'=133 +'ticks'=134 +'encoding'=135 +'strict_types'=136 +'__get'=137 +'__set'=138 +'__call'=139 +'__callstatic'=140 +'__construct'=141 +'__destruct'=142 +'__wakeup'=143 +'__sleep'=144 +'__autoload'=145 +'__isset'=146 +'__unset'=147 +'__tostring'=148 +'__invoke'=149 +'__set_state'=150 +'__clone'=151 +'__debuginfo'=152 +'__namespace__'=153 +'__class__'=154 +'__trait__'=155 +'__function__'=156 +'__method__'=157 +'__line__'=158 +'__file__'=159 +'__dir__'=160 +'<=>'=161 +'<:'=162 +':>'=163 +'=>'=164 +'++'=165 +'--'=166 +'==='=167 +'!=='=168 +'=='=169 +'<='=171 +'>='=172 +'+='=173 +'-='=174 +'*='=175 +'**'=176 +'**='=177 +'/='=178 +'.='=179 +'%='=180 +'<<='=181 +'>>='=182 +'&='=183 +'|='=184 +'^='=185 +'||'=186 +'&&'=187 +'??'=188 +'??='=189 +'<<'=190 +'>>'=191 +'::'=192 +'->'=193 +'\\'=194 +'...'=195 +'&'=198 +'|'=199 +'!'=200 +'^'=201 +'+'=202 +'-'=203 +'*'=204 +'%'=205 +'~'=207 +'@'=208 +'.'=210 +'('=212 +')'=213 +'['=214 +']'=215 +'}'=217 +','=218 +':'=219 +';'=220 +'\''=222 +'`'=223 diff --git a/app/src/main/java/antlr/PhpLexerBase.java b/app/src/main/java/antlr/PhpLexerBase.java new file mode 100644 index 0000000000000000000000000000000000000000..ecb835d845bf146acd542acd125b12f785dc5ca0 --- /dev/null +++ b/app/src/main/java/antlr/PhpLexerBase.java @@ -0,0 +1,193 @@ +package antlr; + +/* +PHP grammar. +The MIT License (MIT). +Copyright (c) 2015-2019, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies. +Copyright (c) 2019, Thierry Marianne (thierry.marianne@weaving-the-web.org) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +import org.antlr.v4.runtime.*; + +public abstract class PhpLexerBase extends Lexer +{ + protected boolean AspTags = true; + protected boolean _scriptTag; + protected boolean _styleTag; + protected String _heredocIdentifier; + protected int _prevTokenType; + protected String _htmlNameText; + protected boolean _phpScript; + protected boolean _insideString; + + public PhpLexerBase(CharStream input) { + super(input); + } + + @Override + public Token nextToken() { + CommonToken token = (CommonToken)super.nextToken(); + + if (token.getType() == PhpLexer.PHPEnd || token.getType() == PhpLexer.PHPEndSingleLineComment) + { + if (_mode == PhpLexer.SingleLineCommentMode) + { + // SingleLineCommentMode for such allowed syntax: + // <?php echo "Hello world"; // comment ?> + popMode(); // exit from SingleLineComment mode. + } + popMode(); // exit from PHP mode. + + if ("</script>".equals(token.getText())) + { + _phpScript = false; + token.setType(PhpLexer.HtmlScriptClose); + } + else + { + // Add semicolon to the end of statement if it is absente. + // For example: <?php echo "Hello world" ?> + if (_prevTokenType == PhpLexer.SemiColon || _prevTokenType == PhpLexer.Colon + || _prevTokenType == PhpLexer.OpenCurlyBracket || _prevTokenType == PhpLexer.CloseCurlyBracket) + { + token.setChannel(PhpLexer.SkipChannel); + } + else + { + token.setType(PhpLexer.SemiColon); + } + } + } + else if (token.getType() == PhpLexer.HtmlName) + { + _htmlNameText = token.getText(); + } + else if (token.getType() == PhpLexer.HtmlDoubleQuoteString) + { + if ("php".equals(token.getText()) && "language".equals(_htmlNameText)) + { + _phpScript = true; + } + } + else if (_mode == PhpLexer.HereDoc) + { + // Heredoc and Nowdoc syntax support: http://php.net/manual/en/language.types.string.php#language.types.string.syntax.heredoc + switch (token.getType()) + { + case PhpLexer.StartHereDoc: + case PhpLexer.StartNowDoc: + _heredocIdentifier = token.getText().substring(3).trim().replace("'",""); + break; + + case PhpLexer.HereDocText: + if (CheckHeredocEnd(token.getText())) + { + popMode(); + + String heredocIdentifier = GetHeredocIdentifier(token.getText()); + if (token.getText().trim().endsWith(";")) + { + token = new CommonToken(PhpLexer.SemiColon, heredocIdentifier + ";\n"); + } + else + { + token = (CommonToken)super.nextToken(); + token.setText(heredocIdentifier + "\n;"); + } + } + break; + } + } + else if (_mode == PhpLexer.PHP) + { + if (_channel != PhpLexer.HIDDEN) + { + _prevTokenType = token.getType(); + } + } + + return token; + } + + private String GetHeredocIdentifier(String text) { + String trimmedText = text.trim(); + boolean semi = (trimmedText.length() > 0) ? (trimmedText.charAt(trimmedText.length() - 1) == ';') : false; + return semi ? trimmedText.substring(0, trimmedText.length() - 1) : trimmedText; + } + + private boolean CheckHeredocEnd(String text) { + return GetHeredocIdentifier(text).equals(_heredocIdentifier); + } + + protected boolean IsNewLineOrStart(int pos) { + return this._input.LA(pos) <= 0 || this._input.LA(pos) == '\r' || this._input.LA(pos) == '\n'; + } + + protected void PushModeOnHtmlClose() { + popMode(); + if (_scriptTag) + { + if (!_phpScript) + { + pushMode(PhpLexer.SCRIPT); + } + else + { + pushMode(PhpLexer.PHP); + } + _scriptTag = false; + } + else if (_styleTag) + { + pushMode(PhpLexer.STYLE); + _styleTag = false; + } + } + + protected boolean HasAspTags() { + return this.AspTags; + } + + protected boolean HasPhpScriptTag() { + return this._phpScript; + } + + protected void PopModeOnCurlyBracketClose() { + if (_insideString) + { + _insideString = false; + setChannel(PhpLexer.SkipChannel); + popMode(); + } + } + + protected boolean ShouldPushHereDocMode(int pos) { + return _input.LA(pos) == '\r' || _input.LA(pos) == '\n'; + } + + protected boolean IsCurlyDollar(int pos) { + return _input.LA(pos) == '$'; + } + + protected void SetInsideString() { + _insideString = true; + } +} diff --git a/app/src/main/java/antlr/PhpParser.java b/app/src/main/java/antlr/PhpParser.java new file mode 100644 index 0000000000000000000000000000000000000000..c3c73534248cd71364e1a78cae817aeece0d5c38 --- /dev/null +++ b/app/src/main/java/antlr/PhpParser.java @@ -0,0 +1,14675 @@ +package antlr; + +// Generated from PhpParser.g4 by ANTLR 4.5 +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class PhpParser extends Parser { + static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + SeaWhitespace=1, HtmlText=2, XmlStart=3, PHPStart=4, HtmlScriptOpen=5, + HtmlStyleOpen=6, HtmlComment=7, HtmlDtd=8, HtmlOpen=9, Shebang=10, Error=11, + XmlText=12, XmlClose=13, PHPStartInside=14, HtmlClose=15, HtmlSlashClose=16, + HtmlSlash=17, HtmlEquals=18, HtmlStartQuoteString=19, HtmlStartDoubleQuoteString=20, + HtmlHex=21, HtmlDecimal=22, HtmlSpace=23, HtmlName=24, ErrorInside=25, + PHPStartInsideQuoteString=26, HtmlEndQuoteString=27, HtmlQuoteString=28, + ErrorHtmlQuote=29, PHPStartDoubleQuoteString=30, HtmlEndDoubleQuoteString=31, + HtmlDoubleQuoteString=32, ErrorHtmlDoubleQuote=33, ScriptText=34, HtmlScriptClose=35, + PHPStartInsideScript=36, StyleBody=37, PHPEnd=38, Whitespace=39, MultiLineComment=40, + SingleLineComment=41, ShellStyleComment=42, AttributeStart=43, Abstract=44, + Array=45, As=46, BinaryCast=47, BoolType=48, BooleanConstant=49, Break=50, + Callable=51, Case=52, Catch=53, Class=54, Clone=55, Const=56, Continue=57, + Declare=58, Default=59, Do=60, DoubleCast=61, DoubleType=62, Echo=63, + Else=64, ElseIf=65, Empty=66, Enum_=67, EndDeclare=68, EndFor=69, EndForeach=70, + EndIf=71, EndSwitch=72, EndWhile=73, Eval=74, Exit=75, Extends=76, Final=77, + Finally=78, FloatCast=79, For=80, Foreach=81, Function_=82, Global=83, + Goto=84, If=85, Implements=86, Import=87, Include=88, IncludeOnce=89, + InstanceOf=90, InsteadOf=91, Int8Cast=92, Int16Cast=93, Int64Type=94, + IntType=95, Interface=96, IsSet=97, List=98, LogicalAnd=99, LogicalOr=100, + LogicalXor=101, Match_=102, Namespace=103, New=104, Null=105, ObjectType=106, + Parent_=107, Partial=108, Print=109, Private=110, Protected=111, Public=112, + Readonly=113, Require=114, RequireOnce=115, Resource=116, Return=117, + Static=118, StringType=119, Switch=120, Throw=121, Trait=122, Try=123, + Typeof=124, UintCast=125, UnicodeCast=126, Unset=127, Use=128, Var=129, + While=130, Yield=131, From=132, LambdaFn=133, Ticks=134, Encoding=135, + StrictTypes=136, Get=137, Set=138, Call=139, CallStatic=140, Constructor=141, + Destruct=142, Wakeup=143, Sleep=144, Autoload=145, IsSet__=146, Unset__=147, + ToString__=148, Invoke=149, SetState=150, Clone__=151, DebugInfo=152, + Namespace__=153, Class__=154, Traic__=155, Function__=156, Method__=157, + Line__=158, File__=159, Dir__=160, Spaceship=161, Lgeneric=162, Rgeneric=163, + DoubleArrow=164, Inc=165, Dec=166, IsIdentical=167, IsNoidentical=168, + IsEqual=169, IsNotEq=170, IsSmallerOrEqual=171, IsGreaterOrEqual=172, + PlusEqual=173, MinusEqual=174, MulEqual=175, Pow=176, PowEqual=177, DivEqual=178, + Concaequal=179, ModEqual=180, ShiftLeftEqual=181, ShiftRightEqual=182, + AndEqual=183, OrEqual=184, XorEqual=185, BooleanOr=186, BooleanAnd=187, + NullCoalescing=188, NullCoalescingEqual=189, ShiftLeft=190, ShiftRight=191, + DoubleColon=192, ObjectOperator=193, NamespaceSeparator=194, Ellipsis=195, + Less=196, Greater=197, Ampersand=198, Pipe=199, Bang=200, Caret=201, Plus=202, + Minus=203, Asterisk=204, Percent=205, Divide=206, Tilde=207, SuppressWarnings=208, + Dollar=209, Dot=210, QuestionMark=211, OpenRoundBracket=212, CloseRoundBracket=213, + OpenSquareBracket=214, CloseSquareBracket=215, OpenCurlyBracket=216, CloseCurlyBracket=217, + Comma=218, Colon=219, SemiColon=220, Eq=221, Quote=222, BackQuote=223, + VarName=224, Label=225, Octal=226, Decimal=227, Real=228, Hex=229, Binary=230, + BackQuoteString=231, SingleQuoteString=232, DoubleQuote=233, StartNowDoc=234, + StartHereDoc=235, ErrorPhp=236, CurlyDollar=237, UnicodeEscape=238, StringPart=239, + Comment=240, PHPEndSingleLineComment=241, CommentEnd=242, HereDocText=243, + XmlText2=244; + public static final int + RULE_htmlDocument = 0, RULE_inlineHtml = 1, RULE_htmlElement = 2, RULE_scriptText = 3, + RULE_phpBlock = 4, RULE_importStatement = 5, RULE_topStatement = 6, RULE_useDeclaration = 7, + RULE_useDeclarationContentList = 8, RULE_useDeclarationContent = 9, RULE_namespaceDeclaration = 10, + RULE_namespaceStatement = 11, RULE_functionDeclaration = 12, RULE_classDeclaration = 13, + RULE_classEntryType = 14, RULE_interfaceList = 15, RULE_typeParameterListInBrackets = 16, + RULE_typeParameterList = 17, RULE_typeParameterWithDefaultsList = 18, + RULE_typeParameterDecl = 19, RULE_typeParameterWithDefaultDecl = 20, RULE_genericDynamicArgs = 21, + RULE_attributes = 22, RULE_attributeGroup = 23, RULE_attribute = 24, RULE_innerStatementList = 25, + RULE_innerStatement = 26, RULE_statement = 27, RULE_emptyStatement_ = 28, + RULE_blockStatement = 29, RULE_ifStatement = 30, RULE_elseIfStatement = 31, + RULE_elseIfColonStatement = 32, RULE_elseStatement = 33, RULE_elseColonStatement = 34, + RULE_whileStatement = 35, RULE_doWhileStatement = 36, RULE_forStatement = 37, + RULE_forInit = 38, RULE_forUpdate = 39, RULE_switchStatement = 40, RULE_switchBlock = 41, + RULE_breakStatement = 42, RULE_continueStatement = 43, RULE_returnStatement = 44, + RULE_expressionStatement = 45, RULE_unsetStatement = 46, RULE_foreachStatement = 47, + RULE_tryCatchFinally = 48, RULE_catchClause = 49, RULE_finallyStatement = 50, + RULE_throwStatement = 51, RULE_gotoStatement = 52, RULE_declareStatement = 53, + RULE_inlineHtmlStatement = 54, RULE_declareList = 55, RULE_directive = 56, + RULE_formalParameterList = 57, RULE_formalParameter = 58, RULE_typeHint = 59, + RULE_globalStatement = 60, RULE_globalVar = 61, RULE_echoStatement = 62, + RULE_staticVariableStatement = 63, RULE_classStatement = 64, RULE_traitAdaptations = 65, + RULE_traitAdaptationStatement = 66, RULE_traitPrecedence = 67, RULE_traitAlias = 68, + RULE_traitMethodReference = 69, RULE_baseCtorCall = 70, RULE_returnTypeDecl = 71, + RULE_methodBody = 72, RULE_propertyModifiers = 73, RULE_memberModifiers = 74, + RULE_variableInitializer = 75, RULE_identifierInitializer = 76, RULE_globalConstantDeclaration = 77, + RULE_enumDeclaration = 78, RULE_enumItem = 79, RULE_expressionList = 80, + RULE_parentheses = 81, RULE_expression = 82, RULE_assignable = 83, RULE_arrayCreation = 84, + RULE_arrayDestructuring = 85, RULE_indexedDestructItem = 86, RULE_keyedDestructItem = 87, + RULE_lambdaFunctionExpr = 88, RULE_matchExpr = 89, RULE_matchItem = 90, + RULE_newExpr = 91, RULE_assignmentOperator = 92, RULE_yieldExpression = 93, + RULE_arrayItemList = 94, RULE_arrayItem = 95, RULE_lambdaFunctionUseVars = 96, + RULE_lambdaFunctionUseVar = 97, RULE_qualifiedStaticTypeRef = 98, RULE_typeRef = 99, + RULE_anonymousClass = 100, RULE_indirectTypeRef = 101, RULE_qualifiedNamespaceName = 102, + RULE_namespaceNameList = 103, RULE_namespaceNameTail = 104, RULE_qualifiedNamespaceNameList = 105, + RULE_arguments = 106, RULE_actualArgument = 107, RULE_argumentName = 108, + RULE_constantInitializer = 109, RULE_constant = 110, RULE_literalConstant = 111, + RULE_numericConstant = 112, RULE_classConstant = 113, RULE_stringConstant = 114, + RULE_string = 115, RULE_interpolatedStringPart = 116, RULE_chainList = 117, + RULE_chain = 118, RULE_chainOrigin = 119, RULE_memberAccess = 120, RULE_functionCall = 121, + RULE_functionCallName = 122, RULE_actualArguments = 123, RULE_chainBase = 124, + RULE_keyedFieldName = 125, RULE_keyedSimpleFieldName = 126, RULE_keyedVariable = 127, + RULE_squareCurlyExpression = 128, RULE_assignmentList = 129, RULE_assignmentListElement = 130, + RULE_modifier = 131, RULE_identifier = 132, RULE_memberModifier = 133, + RULE_magicConstant = 134, RULE_magicMethod = 135, RULE_primitiveType = 136, + RULE_castOperation = 137; + public static final String[] ruleNames = { + "htmlDocument", "inlineHtml", "htmlElement", "scriptText", "phpBlock", + "importStatement", "topStatement", "useDeclaration", "useDeclarationContentList", + "useDeclarationContent", "namespaceDeclaration", "namespaceStatement", + "functionDeclaration", "classDeclaration", "classEntryType", "interfaceList", + "typeParameterListInBrackets", "typeParameterList", "typeParameterWithDefaultsList", + "typeParameterDecl", "typeParameterWithDefaultDecl", "genericDynamicArgs", + "attributes", "attributeGroup", "attribute", "innerStatementList", "innerStatement", + "statement", "emptyStatement_", "blockStatement", "ifStatement", "elseIfStatement", + "elseIfColonStatement", "elseStatement", "elseColonStatement", "whileStatement", + "doWhileStatement", "forStatement", "forInit", "forUpdate", "switchStatement", + "switchBlock", "breakStatement", "continueStatement", "returnStatement", + "expressionStatement", "unsetStatement", "foreachStatement", "tryCatchFinally", + "catchClause", "finallyStatement", "throwStatement", "gotoStatement", + "declareStatement", "inlineHtmlStatement", "declareList", "directive", + "formalParameterList", "formalParameter", "typeHint", "globalStatement", + "globalVar", "echoStatement", "staticVariableStatement", "classStatement", + "traitAdaptations", "traitAdaptationStatement", "traitPrecedence", "traitAlias", + "traitMethodReference", "baseCtorCall", "returnTypeDecl", "methodBody", + "propertyModifiers", "memberModifiers", "variableInitializer", "identifierInitializer", + "globalConstantDeclaration", "enumDeclaration", "enumItem", "expressionList", + "parentheses", "expression", "assignable", "arrayCreation", "arrayDestructuring", + "indexedDestructItem", "keyedDestructItem", "lambdaFunctionExpr", "matchExpr", + "matchItem", "newExpr", "assignmentOperator", "yieldExpression", "arrayItemList", + "arrayItem", "lambdaFunctionUseVars", "lambdaFunctionUseVar", "qualifiedStaticTypeRef", + "typeRef", "anonymousClass", "indirectTypeRef", "qualifiedNamespaceName", + "namespaceNameList", "namespaceNameTail", "qualifiedNamespaceNameList", + "arguments", "actualArgument", "argumentName", "constantInitializer", + "constant", "literalConstant", "numericConstant", "classConstant", "stringConstant", + "string", "interpolatedStringPart", "chainList", "chain", "chainOrigin", + "memberAccess", "functionCall", "functionCallName", "actualArguments", + "chainBase", "keyedFieldName", "keyedSimpleFieldName", "keyedVariable", + "squareCurlyExpression", "assignmentList", "assignmentListElement", "modifier", + "identifier", "memberModifier", "magicConstant", "magicMethod", "primitiveType", + "castOperation" + }; + + private static final String[] _LITERAL_NAMES = { + null, null, null, "'<?xml'", null, null, null, null, null, null, null, + null, null, "'?>'", null, null, "'/>'", null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, "'#['", "'abstract'", + "'array'", "'as'", "'binary'", null, null, "'break'", "'callable'", "'case'", + "'catch'", "'class'", "'clone'", "'const'", "'continue'", "'declare'", + "'default'", "'do'", "'real'", "'double'", "'echo'", "'else'", "'elseif'", + "'empty'", "'enum'", "'enddeclare'", "'endfor'", "'endforeach'", "'endif'", + "'endswitch'", "'endwhile'", "'eval'", "'die'", "'extends'", "'final'", + "'finally'", "'float'", "'for'", "'foreach'", "'function'", "'global'", + "'goto'", "'if'", "'implements'", "'import'", "'include'", "'include_once'", + "'instanceof'", "'insteadof'", "'int8'", "'int16'", "'int64'", null, "'interface'", + "'isset'", "'list'", "'and'", "'or'", "'xor'", "'match'", "'namespace'", + "'new'", "'null'", "'object'", "'parent'", "'partial'", "'print'", "'private'", + "'protected'", "'public'", "'readonly'", "'require'", "'require_once'", + "'resource'", "'return'", "'static'", "'string'", "'switch'", "'throw'", + "'trait'", "'try'", "'clrtypeof'", null, "'unicode'", "'unset'", "'use'", + "'var'", "'while'", "'yield'", "'from'", "'fn'", "'ticks'", "'encoding'", + "'strict_types'", "'__get'", "'__set'", "'__call'", "'__callstatic'", + "'__construct'", "'__destruct'", "'__wakeup'", "'__sleep'", "'__autoload'", + "'__isset'", "'__unset'", "'__tostring'", "'__invoke'", "'__set_state'", + "'__clone'", "'__debuginfo'", "'__namespace__'", "'__class__'", "'__trait__'", + "'__function__'", "'__method__'", "'__line__'", "'__file__'", "'__dir__'", + "'<=>'", "'<:'", "':>'", "'=>'", "'++'", "'--'", "'==='", "'!=='", "'=='", + null, "'<='", "'>='", "'+='", "'-='", "'*='", "'**'", "'**='", "'/='", + "'.='", "'%='", "'<<='", "'>>='", "'&='", "'|='", "'^='", "'||'", "'&&'", + "'??'", "'??='", "'<<'", "'>>'", "'::'", "'->'", "'\\'", "'...'", null, + null, "'&'", "'|'", "'!'", "'^'", "'+'", "'-'", "'*'", "'%'", null, "'~'", + "'@'", null, "'.'", null, "'('", "')'", "'['", "']'", null, "'}'", "','", + "':'", "';'", null, "'''", "'`'" + }; + private static final String[] _SYMBOLIC_NAMES = { + null, "SeaWhitespace", "HtmlText", "XmlStart", "PHPStart", "HtmlScriptOpen", + "HtmlStyleOpen", "HtmlComment", "HtmlDtd", "HtmlOpen", "Shebang", "Error", + "XmlText", "XmlClose", "PHPStartInside", "HtmlClose", "HtmlSlashClose", + "HtmlSlash", "HtmlEquals", "HtmlStartQuoteString", "HtmlStartDoubleQuoteString", + "HtmlHex", "HtmlDecimal", "HtmlSpace", "HtmlName", "ErrorInside", "PHPStartInsideQuoteString", + "HtmlEndQuoteString", "HtmlQuoteString", "ErrorHtmlQuote", "PHPStartDoubleQuoteString", + "HtmlEndDoubleQuoteString", "HtmlDoubleQuoteString", "ErrorHtmlDoubleQuote", + "ScriptText", "HtmlScriptClose", "PHPStartInsideScript", "StyleBody", + "PHPEnd", "Whitespace", "MultiLineComment", "SingleLineComment", "ShellStyleComment", + "AttributeStart", "Abstract", "Array", "As", "BinaryCast", "BoolType", + "BooleanConstant", "Break", "Callable", "Case", "Catch", "Class", "Clone", + "Const", "Continue", "Declare", "Default", "Do", "DoubleCast", "DoubleType", + "Echo", "Else", "ElseIf", "Empty", "Enum_", "EndDeclare", "EndFor", "EndForeach", + "EndIf", "EndSwitch", "EndWhile", "Eval", "Exit", "Extends", "Final", + "Finally", "FloatCast", "For", "Foreach", "Function_", "Global", "Goto", + "If", "Implements", "Import", "Include", "IncludeOnce", "InstanceOf", + "InsteadOf", "Int8Cast", "Int16Cast", "Int64Type", "IntType", "Interface", + "IsSet", "List", "LogicalAnd", "LogicalOr", "LogicalXor", "Match_", "Namespace", + "New", "Null", "ObjectType", "Parent_", "Partial", "Print", "Private", + "Protected", "Public", "Readonly", "Require", "RequireOnce", "Resource", + "Return", "Static", "StringType", "Switch", "Throw", "Trait", "Try", "Typeof", + "UintCast", "UnicodeCast", "Unset", "Use", "Var", "While", "Yield", "From", + "LambdaFn", "Ticks", "Encoding", "StrictTypes", "Get", "Set", "Call", + "CallStatic", "Constructor", "Destruct", "Wakeup", "Sleep", "Autoload", + "IsSet__", "Unset__", "ToString__", "Invoke", "SetState", "Clone__", "DebugInfo", + "Namespace__", "Class__", "Traic__", "Function__", "Method__", "Line__", + "File__", "Dir__", "Spaceship", "Lgeneric", "Rgeneric", "DoubleArrow", + "Inc", "Dec", "IsIdentical", "IsNoidentical", "IsEqual", "IsNotEq", "IsSmallerOrEqual", + "IsGreaterOrEqual", "PlusEqual", "MinusEqual", "MulEqual", "Pow", "PowEqual", + "DivEqual", "Concaequal", "ModEqual", "ShiftLeftEqual", "ShiftRightEqual", + "AndEqual", "OrEqual", "XorEqual", "BooleanOr", "BooleanAnd", "NullCoalescing", + "NullCoalescingEqual", "ShiftLeft", "ShiftRight", "DoubleColon", "ObjectOperator", + "NamespaceSeparator", "Ellipsis", "Less", "Greater", "Ampersand", "Pipe", + "Bang", "Caret", "Plus", "Minus", "Asterisk", "Percent", "Divide", "Tilde", + "SuppressWarnings", "Dollar", "Dot", "QuestionMark", "OpenRoundBracket", + "CloseRoundBracket", "OpenSquareBracket", "CloseSquareBracket", "OpenCurlyBracket", + "CloseCurlyBracket", "Comma", "Colon", "SemiColon", "Eq", "Quote", "BackQuote", + "VarName", "Label", "Octal", "Decimal", "Real", "Hex", "Binary", "BackQuoteString", + "SingleQuoteString", "DoubleQuote", "StartNowDoc", "StartHereDoc", "ErrorPhp", + "CurlyDollar", "UnicodeEscape", "StringPart", "Comment", "PHPEndSingleLineComment", + "CommentEnd", "HereDocText", "XmlText2" + }; + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = "<INVALID>"; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "PhpParser.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public PhpParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + public static class HtmlDocumentContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(PhpParser.EOF, 0); } + public TerminalNode Shebang() { return getToken(PhpParser.Shebang, 0); } + public List<InlineHtmlContext> inlineHtml() { + return getRuleContexts(InlineHtmlContext.class); + } + public InlineHtmlContext inlineHtml(int i) { + return getRuleContext(InlineHtmlContext.class,i); + } + public List<PhpBlockContext> phpBlock() { + return getRuleContexts(PhpBlockContext.class); + } + public PhpBlockContext phpBlock(int i) { + return getRuleContext(PhpBlockContext.class,i); + } + public HtmlDocumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_htmlDocument; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterHtmlDocument(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitHtmlDocument(this); + } + } + + public final HtmlDocumentContext htmlDocument() throws RecognitionException { + HtmlDocumentContext _localctx = new HtmlDocumentContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_htmlDocument); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(277); + _la = _input.LA(1); + if (_la==Shebang) { + { + setState(276); + match(Shebang); + } + } + + setState(283); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << HtmlText) | (1L << XmlStart) | (1L << HtmlScriptOpen) | (1L << HtmlStyleOpen) | (1L << HtmlDtd) | (1L << HtmlOpen) | (1L << HtmlClose) | (1L << HtmlSlashClose) | (1L << HtmlSlash) | (1L << HtmlEquals) | (1L << HtmlStartQuoteString) | (1L << HtmlStartDoubleQuoteString) | (1L << HtmlHex) | (1L << HtmlDecimal) | (1L << HtmlName) | (1L << HtmlEndQuoteString) | (1L << HtmlQuoteString) | (1L << HtmlEndDoubleQuoteString) | (1L << HtmlDoubleQuoteString) | (1L << ScriptText) | (1L << HtmlScriptClose) | (1L << StyleBody) | (1L << AttributeStart) | (1L << Abstract) | (1L << Array) | (1L << As) | (1L << BinaryCast) | (1L << BoolType) | (1L << BooleanConstant) | (1L << Break) | (1L << Callable) | (1L << Case) | (1L << Catch) | (1L << Class) | (1L << Clone) | (1L << Const) | (1L << Continue) | (1L << Declare) | (1L << Default) | (1L << Do) | (1L << DoubleCast) | (1L << DoubleType) | (1L << Echo))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Else - 64)) | (1L << (ElseIf - 64)) | (1L << (Empty - 64)) | (1L << (Enum_ - 64)) | (1L << (EndDeclare - 64)) | (1L << (EndFor - 64)) | (1L << (EndForeach - 64)) | (1L << (EndIf - 64)) | (1L << (EndSwitch - 64)) | (1L << (EndWhile - 64)) | (1L << (Eval - 64)) | (1L << (Exit - 64)) | (1L << (Extends - 64)) | (1L << (Final - 64)) | (1L << (Finally - 64)) | (1L << (FloatCast - 64)) | (1L << (For - 64)) | (1L << (Foreach - 64)) | (1L << (Function_ - 64)) | (1L << (Global - 64)) | (1L << (Goto - 64)) | (1L << (If - 64)) | (1L << (Implements - 64)) | (1L << (Import - 64)) | (1L << (Include - 64)) | (1L << (IncludeOnce - 64)) | (1L << (InstanceOf - 64)) | (1L << (InsteadOf - 64)) | (1L << (Int8Cast - 64)) | (1L << (Int16Cast - 64)) | (1L << (Int64Type - 64)) | (1L << (IntType - 64)) | (1L << (Interface - 64)) | (1L << (IsSet - 64)) | (1L << (List - 64)) | (1L << (LogicalAnd - 64)) | (1L << (LogicalOr - 64)) | (1L << (LogicalXor - 64)) | (1L << (Match_ - 64)) | (1L << (Namespace - 64)) | (1L << (New - 64)) | (1L << (Null - 64)) | (1L << (ObjectType - 64)) | (1L << (Parent_ - 64)) | (1L << (Partial - 64)) | (1L << (Print - 64)) | (1L << (Private - 64)) | (1L << (Protected - 64)) | (1L << (Public - 64)) | (1L << (Readonly - 64)) | (1L << (Require - 64)) | (1L << (RequireOnce - 64)) | (1L << (Resource - 64)) | (1L << (Return - 64)) | (1L << (Static - 64)) | (1L << (StringType - 64)) | (1L << (Switch - 64)) | (1L << (Throw - 64)) | (1L << (Trait - 64)) | (1L << (Try - 64)) | (1L << (Typeof - 64)) | (1L << (UintCast - 64)) | (1L << (UnicodeCast - 64)) | (1L << (Unset - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Use - 128)) | (1L << (Var - 128)) | (1L << (While - 128)) | (1L << (Yield - 128)) | (1L << (From - 128)) | (1L << (LambdaFn - 128)) | (1L << (Ticks - 128)) | (1L << (Encoding - 128)) | (1L << (StrictTypes - 128)) | (1L << (Get - 128)) | (1L << (Set - 128)) | (1L << (Call - 128)) | (1L << (CallStatic - 128)) | (1L << (Constructor - 128)) | (1L << (Destruct - 128)) | (1L << (Wakeup - 128)) | (1L << (Sleep - 128)) | (1L << (Autoload - 128)) | (1L << (IsSet__ - 128)) | (1L << (Unset__ - 128)) | (1L << (ToString__ - 128)) | (1L << (Invoke - 128)) | (1L << (SetState - 128)) | (1L << (Clone__ - 128)) | (1L << (DebugInfo - 128)) | (1L << (Namespace__ - 128)) | (1L << (Class__ - 128)) | (1L << (Traic__ - 128)) | (1L << (Function__ - 128)) | (1L << (Method__ - 128)) | (1L << (Line__ - 128)) | (1L << (File__ - 128)) | (1L << (Dir__ - 128)) | (1L << (Inc - 128)) | (1L << (Dec - 128)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (OpenCurlyBracket - 194)) | (1L << (SemiColon - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(281); + switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) { + case 1: + { + setState(279); + inlineHtml(); + } + break; + case 2: + { + setState(280); + phpBlock(); + } + break; + } + } + setState(285); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(286); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InlineHtmlContext extends ParserRuleContext { + public List<HtmlElementContext> htmlElement() { + return getRuleContexts(HtmlElementContext.class); + } + public HtmlElementContext htmlElement(int i) { + return getRuleContext(HtmlElementContext.class,i); + } + public ScriptTextContext scriptText() { + return getRuleContext(ScriptTextContext.class,0); + } + public InlineHtmlContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inlineHtml; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInlineHtml(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInlineHtml(this); + } + } + + public final InlineHtmlContext inlineHtml() throws RecognitionException { + InlineHtmlContext _localctx = new InlineHtmlContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_inlineHtml); + try { + int _alt; + setState(294); + switch (_input.LA(1)) { + case HtmlText: + case XmlStart: + case HtmlScriptOpen: + case HtmlStyleOpen: + case HtmlDtd: + case HtmlOpen: + case HtmlClose: + case HtmlSlashClose: + case HtmlSlash: + case HtmlEquals: + case HtmlStartQuoteString: + case HtmlStartDoubleQuoteString: + case HtmlHex: + case HtmlDecimal: + case HtmlName: + case HtmlEndQuoteString: + case HtmlQuoteString: + case HtmlEndDoubleQuoteString: + case HtmlDoubleQuoteString: + case HtmlScriptClose: + case StyleBody: + enterOuterAlt(_localctx, 1); + { + setState(289); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(288); + htmlElement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(291); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,3,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + break; + case ScriptText: + enterOuterAlt(_localctx, 2); + { + setState(293); + scriptText(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class HtmlElementContext extends ParserRuleContext { + public TerminalNode HtmlDtd() { return getToken(PhpParser.HtmlDtd, 0); } + public TerminalNode HtmlClose() { return getToken(PhpParser.HtmlClose, 0); } + public TerminalNode HtmlStyleOpen() { return getToken(PhpParser.HtmlStyleOpen, 0); } + public TerminalNode HtmlOpen() { return getToken(PhpParser.HtmlOpen, 0); } + public TerminalNode HtmlName() { return getToken(PhpParser.HtmlName, 0); } + public TerminalNode HtmlSlashClose() { return getToken(PhpParser.HtmlSlashClose, 0); } + public TerminalNode HtmlSlash() { return getToken(PhpParser.HtmlSlash, 0); } + public TerminalNode HtmlText() { return getToken(PhpParser.HtmlText, 0); } + public TerminalNode HtmlEquals() { return getToken(PhpParser.HtmlEquals, 0); } + public TerminalNode HtmlStartQuoteString() { return getToken(PhpParser.HtmlStartQuoteString, 0); } + public TerminalNode HtmlEndQuoteString() { return getToken(PhpParser.HtmlEndQuoteString, 0); } + public TerminalNode HtmlStartDoubleQuoteString() { return getToken(PhpParser.HtmlStartDoubleQuoteString, 0); } + public TerminalNode HtmlEndDoubleQuoteString() { return getToken(PhpParser.HtmlEndDoubleQuoteString, 0); } + public TerminalNode HtmlHex() { return getToken(PhpParser.HtmlHex, 0); } + public TerminalNode HtmlDecimal() { return getToken(PhpParser.HtmlDecimal, 0); } + public TerminalNode HtmlQuoteString() { return getToken(PhpParser.HtmlQuoteString, 0); } + public TerminalNode HtmlDoubleQuoteString() { return getToken(PhpParser.HtmlDoubleQuoteString, 0); } + public TerminalNode StyleBody() { return getToken(PhpParser.StyleBody, 0); } + public TerminalNode HtmlScriptOpen() { return getToken(PhpParser.HtmlScriptOpen, 0); } + public TerminalNode HtmlScriptClose() { return getToken(PhpParser.HtmlScriptClose, 0); } + public TerminalNode XmlStart() { return getToken(PhpParser.XmlStart, 0); } + public TerminalNode XmlClose() { return getToken(PhpParser.XmlClose, 0); } + public List<TerminalNode> XmlText() { return getTokens(PhpParser.XmlText); } + public TerminalNode XmlText(int i) { + return getToken(PhpParser.XmlText, i); + } + public HtmlElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_htmlElement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterHtmlElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitHtmlElement(this); + } + } + + public final HtmlElementContext htmlElement() throws RecognitionException { + HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_htmlElement); + int _la; + try { + setState(324); + switch (_input.LA(1)) { + case HtmlDtd: + enterOuterAlt(_localctx, 1); + { + setState(296); + match(HtmlDtd); + } + break; + case HtmlClose: + enterOuterAlt(_localctx, 2); + { + setState(297); + match(HtmlClose); + } + break; + case HtmlStyleOpen: + enterOuterAlt(_localctx, 3); + { + setState(298); + match(HtmlStyleOpen); + } + break; + case HtmlOpen: + enterOuterAlt(_localctx, 4); + { + setState(299); + match(HtmlOpen); + } + break; + case HtmlName: + enterOuterAlt(_localctx, 5); + { + setState(300); + match(HtmlName); + } + break; + case HtmlSlashClose: + enterOuterAlt(_localctx, 6); + { + setState(301); + match(HtmlSlashClose); + } + break; + case HtmlSlash: + enterOuterAlt(_localctx, 7); + { + setState(302); + match(HtmlSlash); + } + break; + case HtmlText: + enterOuterAlt(_localctx, 8); + { + setState(303); + match(HtmlText); + } + break; + case HtmlEquals: + enterOuterAlt(_localctx, 9); + { + setState(304); + match(HtmlEquals); + } + break; + case HtmlStartQuoteString: + enterOuterAlt(_localctx, 10); + { + setState(305); + match(HtmlStartQuoteString); + } + break; + case HtmlEndQuoteString: + enterOuterAlt(_localctx, 11); + { + setState(306); + match(HtmlEndQuoteString); + } + break; + case HtmlStartDoubleQuoteString: + enterOuterAlt(_localctx, 12); + { + setState(307); + match(HtmlStartDoubleQuoteString); + } + break; + case HtmlEndDoubleQuoteString: + enterOuterAlt(_localctx, 13); + { + setState(308); + match(HtmlEndDoubleQuoteString); + } + break; + case HtmlHex: + enterOuterAlt(_localctx, 14); + { + setState(309); + match(HtmlHex); + } + break; + case HtmlDecimal: + enterOuterAlt(_localctx, 15); + { + setState(310); + match(HtmlDecimal); + } + break; + case HtmlQuoteString: + enterOuterAlt(_localctx, 16); + { + setState(311); + match(HtmlQuoteString); + } + break; + case HtmlDoubleQuoteString: + enterOuterAlt(_localctx, 17); + { + setState(312); + match(HtmlDoubleQuoteString); + } + break; + case StyleBody: + enterOuterAlt(_localctx, 18); + { + setState(313); + match(StyleBody); + } + break; + case HtmlScriptOpen: + enterOuterAlt(_localctx, 19); + { + setState(314); + match(HtmlScriptOpen); + } + break; + case HtmlScriptClose: + enterOuterAlt(_localctx, 20); + { + setState(315); + match(HtmlScriptClose); + } + break; + case XmlStart: + enterOuterAlt(_localctx, 21); + { + setState(316); + match(XmlStart); + setState(320); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==XmlText) { + { + { + setState(317); + match(XmlText); + } + } + setState(322); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(323); + match(XmlClose); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ScriptTextContext extends ParserRuleContext { + public List<TerminalNode> ScriptText() { return getTokens(PhpParser.ScriptText); } + public TerminalNode ScriptText(int i) { + return getToken(PhpParser.ScriptText, i); + } + public ScriptTextContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_scriptText; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterScriptText(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitScriptText(this); + } + } + + public final ScriptTextContext scriptText() throws RecognitionException { + ScriptTextContext _localctx = new ScriptTextContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_scriptText); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(327); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(326); + match(ScriptText); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(329); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,7,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PhpBlockContext extends ParserRuleContext { + public List<ImportStatementContext> importStatement() { + return getRuleContexts(ImportStatementContext.class); + } + public ImportStatementContext importStatement(int i) { + return getRuleContext(ImportStatementContext.class,i); + } + public List<TopStatementContext> topStatement() { + return getRuleContexts(TopStatementContext.class); + } + public TopStatementContext topStatement(int i) { + return getRuleContext(TopStatementContext.class,i); + } + public PhpBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_phpBlock; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPhpBlock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPhpBlock(this); + } + } + + public final PhpBlockContext phpBlock() throws RecognitionException { + PhpBlockContext _localctx = new PhpBlockContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_phpBlock); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(334); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,8,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(331); + importStatement(); + } + } + } + setState(336); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,8,_ctx); + } + setState(338); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(337); + topStatement(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(340); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,9,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ImportStatementContext extends ParserRuleContext { + public TerminalNode Import() { return getToken(PhpParser.Import, 0); } + public TerminalNode Namespace() { return getToken(PhpParser.Namespace, 0); } + public NamespaceNameListContext namespaceNameList() { + return getRuleContext(NamespaceNameListContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public ImportStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_importStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterImportStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitImportStatement(this); + } + } + + public final ImportStatementContext importStatement() throws RecognitionException { + ImportStatementContext _localctx = new ImportStatementContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_importStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(342); + match(Import); + setState(343); + match(Namespace); + setState(344); + namespaceNameList(); + setState(345); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TopStatementContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public UseDeclarationContext useDeclaration() { + return getRuleContext(UseDeclarationContext.class,0); + } + public NamespaceDeclarationContext namespaceDeclaration() { + return getRuleContext(NamespaceDeclarationContext.class,0); + } + public FunctionDeclarationContext functionDeclaration() { + return getRuleContext(FunctionDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public GlobalConstantDeclarationContext globalConstantDeclaration() { + return getRuleContext(GlobalConstantDeclarationContext.class,0); + } + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public TopStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_topStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTopStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTopStatement(this); + } + } + + public final TopStatementContext topStatement() throws RecognitionException { + TopStatementContext _localctx = new TopStatementContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_topStatement); + try { + setState(354); + switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(347); + statement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(348); + useDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(349); + namespaceDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(350); + functionDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(351); + classDeclaration(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(352); + globalConstantDeclaration(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(353); + enumDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UseDeclarationContext extends ParserRuleContext { + public TerminalNode Use() { return getToken(PhpParser.Use, 0); } + public UseDeclarationContentListContext useDeclarationContentList() { + return getRuleContext(UseDeclarationContentListContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public TerminalNode Function_() { return getToken(PhpParser.Function_, 0); } + public TerminalNode Const() { return getToken(PhpParser.Const, 0); } + public UseDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_useDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterUseDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitUseDeclaration(this); + } + } + + public final UseDeclarationContext useDeclaration() throws RecognitionException { + UseDeclarationContext _localctx = new UseDeclarationContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_useDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(356); + match(Use); + setState(358); + switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) { + case 1: + { + setState(357); + _la = _input.LA(1); + if ( !(_la==Const || _la==Function_) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + break; + } + setState(360); + useDeclarationContentList(); + setState(361); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UseDeclarationContentListContext extends ParserRuleContext { + public List<UseDeclarationContentContext> useDeclarationContent() { + return getRuleContexts(UseDeclarationContentContext.class); + } + public UseDeclarationContentContext useDeclarationContent(int i) { + return getRuleContext(UseDeclarationContentContext.class,i); + } + public UseDeclarationContentListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_useDeclarationContentList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterUseDeclarationContentList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitUseDeclarationContentList(this); + } + } + + public final UseDeclarationContentListContext useDeclarationContentList() throws RecognitionException { + UseDeclarationContentListContext _localctx = new UseDeclarationContentListContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_useDeclarationContentList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(364); + _la = _input.LA(1); + if (_la==NamespaceSeparator) { + { + setState(363); + match(NamespaceSeparator); + } + } + + setState(366); + useDeclarationContent(); + setState(374); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(367); + match(Comma); + setState(369); + _la = _input.LA(1); + if (_la==NamespaceSeparator) { + { + setState(368); + match(NamespaceSeparator); + } + } + + setState(371); + useDeclarationContent(); + } + } + setState(376); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UseDeclarationContentContext extends ParserRuleContext { + public NamespaceNameListContext namespaceNameList() { + return getRuleContext(NamespaceNameListContext.class,0); + } + public UseDeclarationContentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_useDeclarationContent; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterUseDeclarationContent(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitUseDeclarationContent(this); + } + } + + public final UseDeclarationContentContext useDeclarationContent() throws RecognitionException { + UseDeclarationContentContext _localctx = new UseDeclarationContentContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_useDeclarationContent); + try { + enterOuterAlt(_localctx, 1); + { + setState(377); + namespaceNameList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NamespaceDeclarationContext extends ParserRuleContext { + public TerminalNode Namespace() { return getToken(PhpParser.Namespace, 0); } + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public NamespaceNameListContext namespaceNameList() { + return getRuleContext(NamespaceNameListContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public List<NamespaceStatementContext> namespaceStatement() { + return getRuleContexts(NamespaceStatementContext.class); + } + public NamespaceStatementContext namespaceStatement(int i) { + return getRuleContext(NamespaceStatementContext.class,i); + } + public NamespaceDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespaceDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNamespaceDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNamespaceDeclaration(this); + } + } + + public final NamespaceDeclarationContext namespaceDeclaration() throws RecognitionException { + NamespaceDeclarationContext _localctx = new NamespaceDeclarationContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_namespaceDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(379); + match(Namespace); + setState(394); + switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { + case 1: + { + setState(381); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)))) != 0) || _la==Label) { + { + setState(380); + namespaceNameList(); + } + } + + setState(383); + match(OpenCurlyBracket); + setState(387); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << HtmlText) | (1L << XmlStart) | (1L << HtmlScriptOpen) | (1L << HtmlStyleOpen) | (1L << HtmlDtd) | (1L << HtmlOpen) | (1L << HtmlClose) | (1L << HtmlSlashClose) | (1L << HtmlSlash) | (1L << HtmlEquals) | (1L << HtmlStartQuoteString) | (1L << HtmlStartDoubleQuoteString) | (1L << HtmlHex) | (1L << HtmlDecimal) | (1L << HtmlName) | (1L << HtmlEndQuoteString) | (1L << HtmlQuoteString) | (1L << HtmlEndDoubleQuoteString) | (1L << HtmlDoubleQuoteString) | (1L << ScriptText) | (1L << HtmlScriptClose) | (1L << StyleBody) | (1L << AttributeStart) | (1L << Abstract) | (1L << Array) | (1L << As) | (1L << BinaryCast) | (1L << BoolType) | (1L << BooleanConstant) | (1L << Break) | (1L << Callable) | (1L << Case) | (1L << Catch) | (1L << Class) | (1L << Clone) | (1L << Const) | (1L << Continue) | (1L << Declare) | (1L << Default) | (1L << Do) | (1L << DoubleCast) | (1L << DoubleType) | (1L << Echo))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Else - 64)) | (1L << (ElseIf - 64)) | (1L << (Empty - 64)) | (1L << (Enum_ - 64)) | (1L << (EndDeclare - 64)) | (1L << (EndFor - 64)) | (1L << (EndForeach - 64)) | (1L << (EndIf - 64)) | (1L << (EndSwitch - 64)) | (1L << (EndWhile - 64)) | (1L << (Eval - 64)) | (1L << (Exit - 64)) | (1L << (Extends - 64)) | (1L << (Final - 64)) | (1L << (Finally - 64)) | (1L << (FloatCast - 64)) | (1L << (For - 64)) | (1L << (Foreach - 64)) | (1L << (Function_ - 64)) | (1L << (Global - 64)) | (1L << (Goto - 64)) | (1L << (If - 64)) | (1L << (Implements - 64)) | (1L << (Import - 64)) | (1L << (Include - 64)) | (1L << (IncludeOnce - 64)) | (1L << (InstanceOf - 64)) | (1L << (InsteadOf - 64)) | (1L << (Int8Cast - 64)) | (1L << (Int16Cast - 64)) | (1L << (Int64Type - 64)) | (1L << (IntType - 64)) | (1L << (Interface - 64)) | (1L << (IsSet - 64)) | (1L << (List - 64)) | (1L << (LogicalAnd - 64)) | (1L << (LogicalOr - 64)) | (1L << (LogicalXor - 64)) | (1L << (Match_ - 64)) | (1L << (Namespace - 64)) | (1L << (New - 64)) | (1L << (Null - 64)) | (1L << (ObjectType - 64)) | (1L << (Parent_ - 64)) | (1L << (Partial - 64)) | (1L << (Print - 64)) | (1L << (Private - 64)) | (1L << (Protected - 64)) | (1L << (Public - 64)) | (1L << (Readonly - 64)) | (1L << (Require - 64)) | (1L << (RequireOnce - 64)) | (1L << (Resource - 64)) | (1L << (Return - 64)) | (1L << (Static - 64)) | (1L << (StringType - 64)) | (1L << (Switch - 64)) | (1L << (Throw - 64)) | (1L << (Trait - 64)) | (1L << (Try - 64)) | (1L << (Typeof - 64)) | (1L << (UintCast - 64)) | (1L << (UnicodeCast - 64)) | (1L << (Unset - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Use - 128)) | (1L << (Var - 128)) | (1L << (While - 128)) | (1L << (Yield - 128)) | (1L << (From - 128)) | (1L << (LambdaFn - 128)) | (1L << (Ticks - 128)) | (1L << (Encoding - 128)) | (1L << (StrictTypes - 128)) | (1L << (Get - 128)) | (1L << (Set - 128)) | (1L << (Call - 128)) | (1L << (CallStatic - 128)) | (1L << (Constructor - 128)) | (1L << (Destruct - 128)) | (1L << (Wakeup - 128)) | (1L << (Sleep - 128)) | (1L << (Autoload - 128)) | (1L << (IsSet__ - 128)) | (1L << (Unset__ - 128)) | (1L << (ToString__ - 128)) | (1L << (Invoke - 128)) | (1L << (SetState - 128)) | (1L << (Clone__ - 128)) | (1L << (DebugInfo - 128)) | (1L << (Namespace__ - 128)) | (1L << (Class__ - 128)) | (1L << (Traic__ - 128)) | (1L << (Function__ - 128)) | (1L << (Method__ - 128)) | (1L << (Line__ - 128)) | (1L << (File__ - 128)) | (1L << (Dir__ - 128)) | (1L << (Inc - 128)) | (1L << (Dec - 128)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (OpenCurlyBracket - 194)) | (1L << (SemiColon - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + { + setState(384); + namespaceStatement(); + } + } + setState(389); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(390); + match(CloseCurlyBracket); + } + break; + case 2: + { + setState(391); + namespaceNameList(); + setState(392); + match(SemiColon); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NamespaceStatementContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public UseDeclarationContext useDeclaration() { + return getRuleContext(UseDeclarationContext.class,0); + } + public FunctionDeclarationContext functionDeclaration() { + return getRuleContext(FunctionDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public GlobalConstantDeclarationContext globalConstantDeclaration() { + return getRuleContext(GlobalConstantDeclarationContext.class,0); + } + public NamespaceStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespaceStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNamespaceStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNamespaceStatement(this); + } + } + + public final NamespaceStatementContext namespaceStatement() throws RecognitionException { + NamespaceStatementContext _localctx = new NamespaceStatementContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_namespaceStatement); + try { + setState(401); + switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(396); + statement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(397); + useDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(398); + functionDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(399); + classDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(400); + globalConstantDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FunctionDeclarationContext extends ParserRuleContext { + public TerminalNode Function_() { return getToken(PhpParser.Function_, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public BlockStatementContext blockStatement() { + return getRuleContext(BlockStatementContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public TypeParameterListInBracketsContext typeParameterListInBrackets() { + return getRuleContext(TypeParameterListInBracketsContext.class,0); + } + public TypeHintContext typeHint() { + return getRuleContext(TypeHintContext.class,0); + } + public TerminalNode QuestionMark() { return getToken(PhpParser.QuestionMark, 0); } + public FunctionDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFunctionDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFunctionDeclaration(this); + } + } + + public final FunctionDeclarationContext functionDeclaration() throws RecognitionException { + FunctionDeclarationContext _localctx = new FunctionDeclarationContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_functionDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(404); + _la = _input.LA(1); + if (_la==AttributeStart) { + { + setState(403); + attributes(); + } + } + + setState(406); + match(Function_); + setState(408); + _la = _input.LA(1); + if (_la==Ampersand) { + { + setState(407); + match(Ampersand); + } + } + + setState(410); + identifier(); + setState(412); + _la = _input.LA(1); + if (_la==Lgeneric) { + { + setState(411); + typeParameterListInBrackets(); + } + } + + setState(414); + match(OpenRoundBracket); + setState(415); + formalParameterList(); + setState(416); + match(CloseRoundBracket); + setState(422); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(417); + match(Colon); + setState(419); + _la = _input.LA(1); + if (_la==QuestionMark) { + { + setState(418); + match(QuestionMark); + } + } + + setState(421); + typeHint(0); + } + } + + setState(424); + blockStatement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassDeclarationContext extends ParserRuleContext { + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public ClassEntryTypeContext classEntryType() { + return getRuleContext(ClassEntryTypeContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode Interface() { return getToken(PhpParser.Interface, 0); } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public TerminalNode Private() { return getToken(PhpParser.Private, 0); } + public ModifierContext modifier() { + return getRuleContext(ModifierContext.class,0); + } + public TerminalNode Partial() { return getToken(PhpParser.Partial, 0); } + public List<ClassStatementContext> classStatement() { + return getRuleContexts(ClassStatementContext.class); + } + public ClassStatementContext classStatement(int i) { + return getRuleContext(ClassStatementContext.class,i); + } + public TypeParameterListInBracketsContext typeParameterListInBrackets() { + return getRuleContext(TypeParameterListInBracketsContext.class,0); + } + public TerminalNode Extends() { return getToken(PhpParser.Extends, 0); } + public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() { + return getRuleContext(QualifiedStaticTypeRefContext.class,0); + } + public TerminalNode Implements() { return getToken(PhpParser.Implements, 0); } + public InterfaceListContext interfaceList() { + return getRuleContext(InterfaceListContext.class,0); + } + public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterClassDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitClassDeclaration(this); + } + } + + public final ClassDeclarationContext classDeclaration() throws RecognitionException { + ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_classDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(427); + _la = _input.LA(1); + if (_la==AttributeStart) { + { + setState(426); + attributes(); + } + } + + setState(430); + _la = _input.LA(1); + if (_la==Private) { + { + setState(429); + match(Private); + } + } + + setState(433); + _la = _input.LA(1); + if (_la==Abstract || _la==Final) { + { + setState(432); + modifier(); + } + } + + setState(436); + _la = _input.LA(1); + if (_la==Partial) { + { + setState(435); + match(Partial); + } + } + + setState(460); + switch (_input.LA(1)) { + case Class: + case Trait: + { + setState(438); + classEntryType(); + setState(439); + identifier(); + setState(441); + _la = _input.LA(1); + if (_la==Lgeneric) { + { + setState(440); + typeParameterListInBrackets(); + } + } + + setState(445); + _la = _input.LA(1); + if (_la==Extends) { + { + setState(443); + match(Extends); + setState(444); + qualifiedStaticTypeRef(); + } + } + + setState(449); + _la = _input.LA(1); + if (_la==Implements) { + { + setState(447); + match(Implements); + setState(448); + interfaceList(); + } + } + + } + break; + case Interface: + { + setState(451); + match(Interface); + setState(452); + identifier(); + setState(454); + _la = _input.LA(1); + if (_la==Lgeneric) { + { + setState(453); + typeParameterListInBrackets(); + } + } + + setState(458); + _la = _input.LA(1); + if (_la==Extends) { + { + setState(456); + match(Extends); + setState(457); + interfaceList(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + setState(462); + match(OpenCurlyBracket); + setState(466); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AttributeStart) | (1L << Abstract) | (1L << Const))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Function_ - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)) | (1L << (Use - 77)) | (1L << (Var - 77)))) != 0)) { + { + { + setState(463); + classStatement(); + } + } + setState(468); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(469); + match(CloseCurlyBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassEntryTypeContext extends ParserRuleContext { + public TerminalNode Class() { return getToken(PhpParser.Class, 0); } + public TerminalNode Trait() { return getToken(PhpParser.Trait, 0); } + public ClassEntryTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classEntryType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterClassEntryType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitClassEntryType(this); + } + } + + public final ClassEntryTypeContext classEntryType() throws RecognitionException { + ClassEntryTypeContext _localctx = new ClassEntryTypeContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_classEntryType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(471); + _la = _input.LA(1); + if ( !(_la==Class || _la==Trait) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceListContext extends ParserRuleContext { + public List<QualifiedStaticTypeRefContext> qualifiedStaticTypeRef() { + return getRuleContexts(QualifiedStaticTypeRefContext.class); + } + public QualifiedStaticTypeRefContext qualifiedStaticTypeRef(int i) { + return getRuleContext(QualifiedStaticTypeRefContext.class,i); + } + public InterfaceListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInterfaceList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInterfaceList(this); + } + } + + public final InterfaceListContext interfaceList() throws RecognitionException { + InterfaceListContext _localctx = new InterfaceListContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_interfaceList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(473); + qualifiedStaticTypeRef(); + setState(478); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(474); + match(Comma); + setState(475); + qualifiedStaticTypeRef(); + } + } + setState(480); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterListInBracketsContext extends ParserRuleContext { + public TypeParameterListContext typeParameterList() { + return getRuleContext(TypeParameterListContext.class,0); + } + public TypeParameterWithDefaultsListContext typeParameterWithDefaultsList() { + return getRuleContext(TypeParameterWithDefaultsListContext.class,0); + } + public TypeParameterListInBracketsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameterListInBrackets; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeParameterListInBrackets(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeParameterListInBrackets(this); + } + } + + public final TypeParameterListInBracketsContext typeParameterListInBrackets() throws RecognitionException { + TypeParameterListInBracketsContext _localctx = new TypeParameterListInBracketsContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_typeParameterListInBrackets); + try { + setState(495); + switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(481); + match(Lgeneric); + setState(482); + typeParameterList(); + setState(483); + match(Rgeneric); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(485); + match(Lgeneric); + setState(486); + typeParameterWithDefaultsList(); + setState(487); + match(Rgeneric); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(489); + match(Lgeneric); + setState(490); + typeParameterList(); + setState(491); + match(Comma); + setState(492); + typeParameterWithDefaultsList(); + setState(493); + match(Rgeneric); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterListContext extends ParserRuleContext { + public List<TypeParameterDeclContext> typeParameterDecl() { + return getRuleContexts(TypeParameterDeclContext.class); + } + public TypeParameterDeclContext typeParameterDecl(int i) { + return getRuleContext(TypeParameterDeclContext.class,i); + } + public TypeParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameterList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeParameterList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeParameterList(this); + } + } + + public final TypeParameterListContext typeParameterList() throws RecognitionException { + TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_typeParameterList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(497); + typeParameterDecl(); + setState(502); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,37,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(498); + match(Comma); + setState(499); + typeParameterDecl(); + } + } + } + setState(504); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,37,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterWithDefaultsListContext extends ParserRuleContext { + public List<TypeParameterWithDefaultDeclContext> typeParameterWithDefaultDecl() { + return getRuleContexts(TypeParameterWithDefaultDeclContext.class); + } + public TypeParameterWithDefaultDeclContext typeParameterWithDefaultDecl(int i) { + return getRuleContext(TypeParameterWithDefaultDeclContext.class,i); + } + public TypeParameterWithDefaultsListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameterWithDefaultsList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeParameterWithDefaultsList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeParameterWithDefaultsList(this); + } + } + + public final TypeParameterWithDefaultsListContext typeParameterWithDefaultsList() throws RecognitionException { + TypeParameterWithDefaultsListContext _localctx = new TypeParameterWithDefaultsListContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_typeParameterWithDefaultsList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(505); + typeParameterWithDefaultDecl(); + setState(510); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(506); + match(Comma); + setState(507); + typeParameterWithDefaultDecl(); + } + } + setState(512); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterDeclContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public TypeParameterDeclContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameterDecl; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeParameterDecl(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeParameterDecl(this); + } + } + + public final TypeParameterDeclContext typeParameterDecl() throws RecognitionException { + TypeParameterDeclContext _localctx = new TypeParameterDeclContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_typeParameterDecl); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(514); + _la = _input.LA(1); + if (_la==AttributeStart) { + { + setState(513); + attributes(); + } + } + + setState(516); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterWithDefaultDeclContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); } + public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() { + return getRuleContext(QualifiedStaticTypeRefContext.class,0); + } + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public TypeParameterWithDefaultDeclContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameterWithDefaultDecl; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeParameterWithDefaultDecl(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeParameterWithDefaultDecl(this); + } + } + + public final TypeParameterWithDefaultDeclContext typeParameterWithDefaultDecl() throws RecognitionException { + TypeParameterWithDefaultDeclContext _localctx = new TypeParameterWithDefaultDeclContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_typeParameterWithDefaultDecl); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(519); + _la = _input.LA(1); + if (_la==AttributeStart) { + { + setState(518); + attributes(); + } + } + + setState(521); + identifier(); + setState(522); + match(Eq); + setState(525); + switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { + case 1: + { + setState(523); + qualifiedStaticTypeRef(); + } + break; + case 2: + { + setState(524); + primitiveType(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class GenericDynamicArgsContext extends ParserRuleContext { + public List<TypeRefContext> typeRef() { + return getRuleContexts(TypeRefContext.class); + } + public TypeRefContext typeRef(int i) { + return getRuleContext(TypeRefContext.class,i); + } + public GenericDynamicArgsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_genericDynamicArgs; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterGenericDynamicArgs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitGenericDynamicArgs(this); + } + } + + public final GenericDynamicArgsContext genericDynamicArgs() throws RecognitionException { + GenericDynamicArgsContext _localctx = new GenericDynamicArgsContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_genericDynamicArgs); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(527); + match(Lgeneric); + setState(528); + typeRef(); + setState(533); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(529); + match(Comma); + setState(530); + typeRef(); + } + } + setState(535); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(536); + match(Rgeneric); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributesContext extends ParserRuleContext { + public List<AttributeGroupContext> attributeGroup() { + return getRuleContexts(AttributeGroupContext.class); + } + public AttributeGroupContext attributeGroup(int i) { + return getRuleContext(AttributeGroupContext.class,i); + } + public AttributesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attributes; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAttributes(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAttributes(this); + } + } + + public final AttributesContext attributes() throws RecognitionException { + AttributesContext _localctx = new AttributesContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_attributes); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(539); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(538); + attributeGroup(); + } + } + setState(541); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==AttributeStart ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributeGroupContext extends ParserRuleContext { + public TerminalNode AttributeStart() { return getToken(PhpParser.AttributeStart, 0); } + public List<AttributeContext> attribute() { + return getRuleContexts(AttributeContext.class); + } + public AttributeContext attribute(int i) { + return getRuleContext(AttributeContext.class,i); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AttributeGroupContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attributeGroup; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAttributeGroup(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAttributeGroup(this); + } + } + + public final AttributeGroupContext attributeGroup() throws RecognitionException { + AttributeGroupContext _localctx = new AttributeGroupContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_attributeGroup); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(543); + match(AttributeStart); + setState(547); + switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) { + case 1: + { + setState(544); + identifier(); + setState(545); + match(Colon); + } + break; + } + setState(549); + attribute(); + setState(554); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(550); + match(Comma); + setState(551); + attribute(); + } + } + setState(556); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(557); + match(CloseSquareBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributeContext extends ParserRuleContext { + public QualifiedNamespaceNameContext qualifiedNamespaceName() { + return getRuleContext(QualifiedNamespaceNameContext.class,0); + } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public AttributeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attribute; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAttribute(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAttribute(this); + } + } + + public final AttributeContext attribute() throws RecognitionException { + AttributeContext _localctx = new AttributeContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_attribute); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(559); + qualifiedNamespaceName(); + setState(561); + _la = _input.LA(1); + if (_la==OpenRoundBracket) { + { + setState(560); + arguments(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InnerStatementListContext extends ParserRuleContext { + public List<InnerStatementContext> innerStatement() { + return getRuleContexts(InnerStatementContext.class); + } + public InnerStatementContext innerStatement(int i) { + return getRuleContext(InnerStatementContext.class,i); + } + public InnerStatementListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_innerStatementList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInnerStatementList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInnerStatementList(this); + } + } + + public final InnerStatementListContext innerStatementList() throws RecognitionException { + InnerStatementListContext _localctx = new InnerStatementListContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_innerStatementList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(566); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,47,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(563); + innerStatement(); + } + } + } + setState(568); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,47,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InnerStatementContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public FunctionDeclarationContext functionDeclaration() { + return getRuleContext(FunctionDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InnerStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_innerStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInnerStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInnerStatement(this); + } + } + + public final InnerStatementContext innerStatement() throws RecognitionException { + InnerStatementContext _localctx = new InnerStatementContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_innerStatement); + try { + setState(572); + switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(569); + statement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(570); + functionDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(571); + classDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public BlockStatementContext blockStatement() { + return getRuleContext(BlockStatementContext.class,0); + } + public IfStatementContext ifStatement() { + return getRuleContext(IfStatementContext.class,0); + } + public WhileStatementContext whileStatement() { + return getRuleContext(WhileStatementContext.class,0); + } + public DoWhileStatementContext doWhileStatement() { + return getRuleContext(DoWhileStatementContext.class,0); + } + public ForStatementContext forStatement() { + return getRuleContext(ForStatementContext.class,0); + } + public SwitchStatementContext switchStatement() { + return getRuleContext(SwitchStatementContext.class,0); + } + public BreakStatementContext breakStatement() { + return getRuleContext(BreakStatementContext.class,0); + } + public ContinueStatementContext continueStatement() { + return getRuleContext(ContinueStatementContext.class,0); + } + public ReturnStatementContext returnStatement() { + return getRuleContext(ReturnStatementContext.class,0); + } + public YieldExpressionContext yieldExpression() { + return getRuleContext(YieldExpressionContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public GlobalStatementContext globalStatement() { + return getRuleContext(GlobalStatementContext.class,0); + } + public StaticVariableStatementContext staticVariableStatement() { + return getRuleContext(StaticVariableStatementContext.class,0); + } + public EchoStatementContext echoStatement() { + return getRuleContext(EchoStatementContext.class,0); + } + public ExpressionStatementContext expressionStatement() { + return getRuleContext(ExpressionStatementContext.class,0); + } + public UnsetStatementContext unsetStatement() { + return getRuleContext(UnsetStatementContext.class,0); + } + public ForeachStatementContext foreachStatement() { + return getRuleContext(ForeachStatementContext.class,0); + } + public TryCatchFinallyContext tryCatchFinally() { + return getRuleContext(TryCatchFinallyContext.class,0); + } + public ThrowStatementContext throwStatement() { + return getRuleContext(ThrowStatementContext.class,0); + } + public GotoStatementContext gotoStatement() { + return getRuleContext(GotoStatementContext.class,0); + } + public DeclareStatementContext declareStatement() { + return getRuleContext(DeclareStatementContext.class,0); + } + public EmptyStatement_Context emptyStatement_() { + return getRuleContext(EmptyStatement_Context.class,0); + } + public InlineHtmlStatementContext inlineHtmlStatement() { + return getRuleContext(InlineHtmlStatementContext.class,0); + } + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitStatement(this); + } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_statement); + try { + setState(601); + switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(574); + identifier(); + setState(575); + match(Colon); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(577); + blockStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(578); + ifStatement(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(579); + whileStatement(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(580); + doWhileStatement(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(581); + forStatement(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(582); + switchStatement(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(583); + breakStatement(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(584); + continueStatement(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(585); + returnStatement(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(586); + yieldExpression(); + setState(587); + match(SemiColon); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(589); + globalStatement(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(590); + staticVariableStatement(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(591); + echoStatement(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(592); + expressionStatement(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(593); + unsetStatement(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(594); + foreachStatement(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(595); + tryCatchFinally(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(596); + throwStatement(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(597); + gotoStatement(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(598); + declareStatement(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(599); + emptyStatement_(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(600); + inlineHtmlStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EmptyStatement_Context extends ParserRuleContext { + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public EmptyStatement_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_emptyStatement_; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterEmptyStatement_(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitEmptyStatement_(this); + } + } + + public final EmptyStatement_Context emptyStatement_() throws RecognitionException { + EmptyStatement_Context _localctx = new EmptyStatement_Context(_ctx, getState()); + enterRule(_localctx, 56, RULE_emptyStatement_); + try { + enterOuterAlt(_localctx, 1); + { + setState(603); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockStatementContext extends ParserRuleContext { + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public InnerStatementListContext innerStatementList() { + return getRuleContext(InnerStatementListContext.class,0); + } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public BlockStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_blockStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterBlockStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitBlockStatement(this); + } + } + + public final BlockStatementContext blockStatement() throws RecognitionException { + BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_blockStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(605); + match(OpenCurlyBracket); + setState(606); + innerStatementList(); + setState(607); + match(CloseCurlyBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IfStatementContext extends ParserRuleContext { + public TerminalNode If() { return getToken(PhpParser.If, 0); } + public ParenthesesContext parentheses() { + return getRuleContext(ParenthesesContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public List<ElseIfStatementContext> elseIfStatement() { + return getRuleContexts(ElseIfStatementContext.class); + } + public ElseIfStatementContext elseIfStatement(int i) { + return getRuleContext(ElseIfStatementContext.class,i); + } + public ElseStatementContext elseStatement() { + return getRuleContext(ElseStatementContext.class,0); + } + public InnerStatementListContext innerStatementList() { + return getRuleContext(InnerStatementListContext.class,0); + } + public TerminalNode EndIf() { return getToken(PhpParser.EndIf, 0); } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public List<ElseIfColonStatementContext> elseIfColonStatement() { + return getRuleContexts(ElseIfColonStatementContext.class); + } + public ElseIfColonStatementContext elseIfColonStatement(int i) { + return getRuleContext(ElseIfColonStatementContext.class,i); + } + public ElseColonStatementContext elseColonStatement() { + return getRuleContext(ElseColonStatementContext.class,0); + } + public IfStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIfStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIfStatement(this); + } + } + + public final IfStatementContext ifStatement() throws RecognitionException { + IfStatementContext _localctx = new IfStatementContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_ifStatement); + int _la; + try { + int _alt; + setState(637); + switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(609); + match(If); + setState(610); + parentheses(); + setState(611); + statement(); + setState(615); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,50,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(612); + elseIfStatement(); + } + } + } + setState(617); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,50,_ctx); + } + setState(619); + switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) { + case 1: + { + setState(618); + elseStatement(); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(621); + match(If); + setState(622); + parentheses(); + setState(623); + match(Colon); + setState(624); + innerStatementList(); + setState(628); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ElseIf) { + { + { + setState(625); + elseIfColonStatement(); + } + } + setState(630); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(632); + _la = _input.LA(1); + if (_la==Else) { + { + setState(631); + elseColonStatement(); + } + } + + setState(634); + match(EndIf); + setState(635); + match(SemiColon); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElseIfStatementContext extends ParserRuleContext { + public TerminalNode ElseIf() { return getToken(PhpParser.ElseIf, 0); } + public ParenthesesContext parentheses() { + return getRuleContext(ParenthesesContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public ElseIfStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elseIfStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterElseIfStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitElseIfStatement(this); + } + } + + public final ElseIfStatementContext elseIfStatement() throws RecognitionException { + ElseIfStatementContext _localctx = new ElseIfStatementContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_elseIfStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(639); + match(ElseIf); + setState(640); + parentheses(); + setState(641); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElseIfColonStatementContext extends ParserRuleContext { + public TerminalNode ElseIf() { return getToken(PhpParser.ElseIf, 0); } + public ParenthesesContext parentheses() { + return getRuleContext(ParenthesesContext.class,0); + } + public InnerStatementListContext innerStatementList() { + return getRuleContext(InnerStatementListContext.class,0); + } + public ElseIfColonStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elseIfColonStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterElseIfColonStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitElseIfColonStatement(this); + } + } + + public final ElseIfColonStatementContext elseIfColonStatement() throws RecognitionException { + ElseIfColonStatementContext _localctx = new ElseIfColonStatementContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_elseIfColonStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(643); + match(ElseIf); + setState(644); + parentheses(); + setState(645); + match(Colon); + setState(646); + innerStatementList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElseStatementContext extends ParserRuleContext { + public TerminalNode Else() { return getToken(PhpParser.Else, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public ElseStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elseStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterElseStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitElseStatement(this); + } + } + + public final ElseStatementContext elseStatement() throws RecognitionException { + ElseStatementContext _localctx = new ElseStatementContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_elseStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(648); + match(Else); + setState(649); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElseColonStatementContext extends ParserRuleContext { + public TerminalNode Else() { return getToken(PhpParser.Else, 0); } + public InnerStatementListContext innerStatementList() { + return getRuleContext(InnerStatementListContext.class,0); + } + public ElseColonStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elseColonStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterElseColonStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitElseColonStatement(this); + } + } + + public final ElseColonStatementContext elseColonStatement() throws RecognitionException { + ElseColonStatementContext _localctx = new ElseColonStatementContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_elseColonStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(651); + match(Else); + setState(652); + match(Colon); + setState(653); + innerStatementList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WhileStatementContext extends ParserRuleContext { + public TerminalNode While() { return getToken(PhpParser.While, 0); } + public ParenthesesContext parentheses() { + return getRuleContext(ParenthesesContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public InnerStatementListContext innerStatementList() { + return getRuleContext(InnerStatementListContext.class,0); + } + public TerminalNode EndWhile() { return getToken(PhpParser.EndWhile, 0); } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public WhileStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_whileStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterWhileStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitWhileStatement(this); + } + } + + public final WhileStatementContext whileStatement() throws RecognitionException { + WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_whileStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(655); + match(While); + setState(656); + parentheses(); + setState(663); + switch (_input.LA(1)) { + case HtmlText: + case XmlStart: + case HtmlScriptOpen: + case HtmlStyleOpen: + case HtmlDtd: + case HtmlOpen: + case HtmlClose: + case HtmlSlashClose: + case HtmlSlash: + case HtmlEquals: + case HtmlStartQuoteString: + case HtmlStartDoubleQuoteString: + case HtmlHex: + case HtmlDecimal: + case HtmlName: + case HtmlEndQuoteString: + case HtmlQuoteString: + case HtmlEndDoubleQuoteString: + case HtmlDoubleQuoteString: + case ScriptText: + case HtmlScriptClose: + case StyleBody: + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case Inc: + case Dec: + case NamespaceSeparator: + case Bang: + case Plus: + case Minus: + case Tilde: + case SuppressWarnings: + case Dollar: + case OpenRoundBracket: + case OpenSquareBracket: + case OpenCurlyBracket: + case SemiColon: + case VarName: + case Label: + case Octal: + case Decimal: + case Real: + case Hex: + case Binary: + case BackQuoteString: + case SingleQuoteString: + case DoubleQuote: + case StartNowDoc: + case StartHereDoc: + { + setState(657); + statement(); + } + break; + case Colon: + { + setState(658); + match(Colon); + setState(659); + innerStatementList(); + setState(660); + match(EndWhile); + setState(661); + match(SemiColon); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DoWhileStatementContext extends ParserRuleContext { + public TerminalNode Do() { return getToken(PhpParser.Do, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public TerminalNode While() { return getToken(PhpParser.While, 0); } + public ParenthesesContext parentheses() { + return getRuleContext(ParenthesesContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public DoWhileStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_doWhileStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterDoWhileStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitDoWhileStatement(this); + } + } + + public final DoWhileStatementContext doWhileStatement() throws RecognitionException { + DoWhileStatementContext _localctx = new DoWhileStatementContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_doWhileStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(665); + match(Do); + setState(666); + statement(); + setState(667); + match(While); + setState(668); + parentheses(); + setState(669); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForStatementContext extends ParserRuleContext { + public TerminalNode For() { return getToken(PhpParser.For, 0); } + public List<TerminalNode> SemiColon() { return getTokens(PhpParser.SemiColon); } + public TerminalNode SemiColon(int i) { + return getToken(PhpParser.SemiColon, i); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public InnerStatementListContext innerStatementList() { + return getRuleContext(InnerStatementListContext.class,0); + } + public TerminalNode EndFor() { return getToken(PhpParser.EndFor, 0); } + public ForInitContext forInit() { + return getRuleContext(ForInitContext.class,0); + } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public ForUpdateContext forUpdate() { + return getRuleContext(ForUpdateContext.class,0); + } + public ForStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterForStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitForStatement(this); + } + } + + public final ForStatementContext forStatement() throws RecognitionException { + ForStatementContext _localctx = new ForStatementContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_forStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(671); + match(For); + setState(672); + match(OpenRoundBracket); + setState(674); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(673); + forInit(); + } + } + + setState(676); + match(SemiColon); + setState(678); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(677); + expressionList(); + } + } + + setState(680); + match(SemiColon); + setState(682); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(681); + forUpdate(); + } + } + + setState(684); + match(CloseRoundBracket); + setState(691); + switch (_input.LA(1)) { + case HtmlText: + case XmlStart: + case HtmlScriptOpen: + case HtmlStyleOpen: + case HtmlDtd: + case HtmlOpen: + case HtmlClose: + case HtmlSlashClose: + case HtmlSlash: + case HtmlEquals: + case HtmlStartQuoteString: + case HtmlStartDoubleQuoteString: + case HtmlHex: + case HtmlDecimal: + case HtmlName: + case HtmlEndQuoteString: + case HtmlQuoteString: + case HtmlEndDoubleQuoteString: + case HtmlDoubleQuoteString: + case ScriptText: + case HtmlScriptClose: + case StyleBody: + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case Inc: + case Dec: + case NamespaceSeparator: + case Bang: + case Plus: + case Minus: + case Tilde: + case SuppressWarnings: + case Dollar: + case OpenRoundBracket: + case OpenSquareBracket: + case OpenCurlyBracket: + case SemiColon: + case VarName: + case Label: + case Octal: + case Decimal: + case Real: + case Hex: + case Binary: + case BackQuoteString: + case SingleQuoteString: + case DoubleQuote: + case StartNowDoc: + case StartHereDoc: + { + setState(685); + statement(); + } + break; + case Colon: + { + setState(686); + match(Colon); + setState(687); + innerStatementList(); + setState(688); + match(EndFor); + setState(689); + match(SemiColon); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForInitContext extends ParserRuleContext { + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public ForInitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forInit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterForInit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitForInit(this); + } + } + + public final ForInitContext forInit() throws RecognitionException { + ForInitContext _localctx = new ForInitContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_forInit); + try { + enterOuterAlt(_localctx, 1); + { + setState(693); + expressionList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForUpdateContext extends ParserRuleContext { + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public ForUpdateContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forUpdate; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterForUpdate(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitForUpdate(this); + } + } + + public final ForUpdateContext forUpdate() throws RecognitionException { + ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_forUpdate); + try { + enterOuterAlt(_localctx, 1); + { + setState(695); + expressionList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchStatementContext extends ParserRuleContext { + public TerminalNode Switch() { return getToken(PhpParser.Switch, 0); } + public ParenthesesContext parentheses() { + return getRuleContext(ParenthesesContext.class,0); + } + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public TerminalNode EndSwitch() { return getToken(PhpParser.EndSwitch, 0); } + public List<TerminalNode> SemiColon() { return getTokens(PhpParser.SemiColon); } + public TerminalNode SemiColon(int i) { + return getToken(PhpParser.SemiColon, i); + } + public List<SwitchBlockContext> switchBlock() { + return getRuleContexts(SwitchBlockContext.class); + } + public SwitchBlockContext switchBlock(int i) { + return getRuleContext(SwitchBlockContext.class,i); + } + public SwitchStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterSwitchStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitSwitchStatement(this); + } + } + + public final SwitchStatementContext switchStatement() throws RecognitionException { + SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_switchStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(697); + match(Switch); + setState(698); + parentheses(); + setState(722); + switch (_input.LA(1)) { + case OpenCurlyBracket: + { + setState(699); + match(OpenCurlyBracket); + setState(701); + _la = _input.LA(1); + if (_la==SemiColon) { + { + setState(700); + match(SemiColon); + } + } + + setState(706); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Case || _la==Default) { + { + { + setState(703); + switchBlock(); + } + } + setState(708); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(709); + match(CloseCurlyBracket); + } + break; + case Colon: + { + setState(710); + match(Colon); + setState(712); + _la = _input.LA(1); + if (_la==SemiColon) { + { + setState(711); + match(SemiColon); + } + } + + setState(717); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Case || _la==Default) { + { + { + setState(714); + switchBlock(); + } + } + setState(719); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(720); + match(EndSwitch); + setState(721); + match(SemiColon); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchBlockContext extends ParserRuleContext { + public InnerStatementListContext innerStatementList() { + return getRuleContext(InnerStatementListContext.class,0); + } + public List<TerminalNode> SemiColon() { return getTokens(PhpParser.SemiColon); } + public TerminalNode SemiColon(int i) { + return getToken(PhpParser.SemiColon, i); + } + public List<TerminalNode> Case() { return getTokens(PhpParser.Case); } + public TerminalNode Case(int i) { + return getToken(PhpParser.Case, i); + } + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List<TerminalNode> Default() { return getTokens(PhpParser.Default); } + public TerminalNode Default(int i) { + return getToken(PhpParser.Default, i); + } + public SwitchBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchBlock; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterSwitchBlock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitSwitchBlock(this); + } + } + + public final SwitchBlockContext switchBlock() throws RecognitionException { + SwitchBlockContext _localctx = new SwitchBlockContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_switchBlock); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(730); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(727); + switch (_input.LA(1)) { + case Case: + { + setState(724); + match(Case); + setState(725); + expression(0); + } + break; + case Default: + { + setState(726); + match(Default); + } + break; + default: + throw new NoViableAltException(this); + } + setState(729); + _la = _input.LA(1); + if ( !(_la==Colon || _la==SemiColon) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(732); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,66,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(734); + innerStatementList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BreakStatementContext extends ParserRuleContext { + public TerminalNode Break() { return getToken(PhpParser.Break, 0); } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public BreakStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_breakStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterBreakStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitBreakStatement(this); + } + } + + public final BreakStatementContext breakStatement() throws RecognitionException { + BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_breakStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(736); + match(Break); + setState(738); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(737); + expression(0); + } + } + + setState(740); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ContinueStatementContext extends ParserRuleContext { + public TerminalNode Continue() { return getToken(PhpParser.Continue, 0); } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ContinueStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_continueStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterContinueStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitContinueStatement(this); + } + } + + public final ContinueStatementContext continueStatement() throws RecognitionException { + ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_continueStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(742); + match(Continue); + setState(744); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(743); + expression(0); + } + } + + setState(746); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ReturnStatementContext extends ParserRuleContext { + public TerminalNode Return() { return getToken(PhpParser.Return, 0); } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ReturnStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_returnStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterReturnStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitReturnStatement(this); + } + } + + public final ReturnStatementContext returnStatement() throws RecognitionException { + ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_returnStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(748); + match(Return); + setState(750); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(749); + expression(0); + } + } + + setState(752); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public ExpressionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterExpressionStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitExpressionStatement(this); + } + } + + public final ExpressionStatementContext expressionStatement() throws RecognitionException { + ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_expressionStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(754); + expression(0); + setState(755); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnsetStatementContext extends ParserRuleContext { + public TerminalNode Unset() { return getToken(PhpParser.Unset, 0); } + public ChainListContext chainList() { + return getRuleContext(ChainListContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public UnsetStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unsetStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterUnsetStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitUnsetStatement(this); + } + } + + public final UnsetStatementContext unsetStatement() throws RecognitionException { + UnsetStatementContext _localctx = new UnsetStatementContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_unsetStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(757); + match(Unset); + setState(758); + match(OpenRoundBracket); + setState(759); + chainList(); + setState(760); + match(CloseRoundBracket); + setState(761); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForeachStatementContext extends ParserRuleContext { + public TerminalNode Foreach() { return getToken(PhpParser.Foreach, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode As() { return getToken(PhpParser.As, 0); } + public ArrayDestructuringContext arrayDestructuring() { + return getRuleContext(ArrayDestructuringContext.class,0); + } + public List<ChainContext> chain() { + return getRuleContexts(ChainContext.class); + } + public ChainContext chain(int i) { + return getRuleContext(ChainContext.class,i); + } + public AssignableContext assignable() { + return getRuleContext(AssignableContext.class,0); + } + public TerminalNode List() { return getToken(PhpParser.List, 0); } + public AssignmentListContext assignmentList() { + return getRuleContext(AssignmentListContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public InnerStatementListContext innerStatementList() { + return getRuleContext(InnerStatementListContext.class,0); + } + public TerminalNode EndForeach() { return getToken(PhpParser.EndForeach, 0); } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public ForeachStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_foreachStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterForeachStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitForeachStatement(this); + } + } + + public final ForeachStatementContext foreachStatement() throws RecognitionException { + ForeachStatementContext _localctx = new ForeachStatementContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_foreachStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(763); + match(Foreach); + setState(808); + switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { + case 1: + { + setState(764); + match(OpenRoundBracket); + setState(765); + expression(0); + setState(766); + match(As); + setState(767); + arrayDestructuring(); + setState(768); + match(CloseRoundBracket); + } + break; + case 2: + { + setState(770); + match(OpenRoundBracket); + setState(771); + chain(); + setState(772); + match(As); + setState(774); + _la = _input.LA(1); + if (_la==Ampersand) { + { + setState(773); + match(Ampersand); + } + } + + setState(776); + assignable(); + setState(782); + _la = _input.LA(1); + if (_la==DoubleArrow) { + { + setState(777); + match(DoubleArrow); + setState(779); + _la = _input.LA(1); + if (_la==Ampersand) { + { + setState(778); + match(Ampersand); + } + } + + setState(781); + chain(); + } + } + + setState(784); + match(CloseRoundBracket); + } + break; + case 3: + { + setState(786); + match(OpenRoundBracket); + setState(787); + expression(0); + setState(788); + match(As); + setState(789); + assignable(); + setState(795); + _la = _input.LA(1); + if (_la==DoubleArrow) { + { + setState(790); + match(DoubleArrow); + setState(792); + _la = _input.LA(1); + if (_la==Ampersand) { + { + setState(791); + match(Ampersand); + } + } + + setState(794); + chain(); + } + } + + setState(797); + match(CloseRoundBracket); + } + break; + case 4: + { + setState(799); + match(OpenRoundBracket); + setState(800); + chain(); + setState(801); + match(As); + setState(802); + match(List); + setState(803); + match(OpenRoundBracket); + setState(804); + assignmentList(); + setState(805); + match(CloseRoundBracket); + setState(806); + match(CloseRoundBracket); + } + break; + } + setState(816); + switch (_input.LA(1)) { + case HtmlText: + case XmlStart: + case HtmlScriptOpen: + case HtmlStyleOpen: + case HtmlDtd: + case HtmlOpen: + case HtmlClose: + case HtmlSlashClose: + case HtmlSlash: + case HtmlEquals: + case HtmlStartQuoteString: + case HtmlStartDoubleQuoteString: + case HtmlHex: + case HtmlDecimal: + case HtmlName: + case HtmlEndQuoteString: + case HtmlQuoteString: + case HtmlEndDoubleQuoteString: + case HtmlDoubleQuoteString: + case ScriptText: + case HtmlScriptClose: + case StyleBody: + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case Inc: + case Dec: + case NamespaceSeparator: + case Bang: + case Plus: + case Minus: + case Tilde: + case SuppressWarnings: + case Dollar: + case OpenRoundBracket: + case OpenSquareBracket: + case OpenCurlyBracket: + case SemiColon: + case VarName: + case Label: + case Octal: + case Decimal: + case Real: + case Hex: + case Binary: + case BackQuoteString: + case SingleQuoteString: + case DoubleQuote: + case StartNowDoc: + case StartHereDoc: + { + setState(810); + statement(); + } + break; + case Colon: + { + setState(811); + match(Colon); + setState(812); + innerStatementList(); + setState(813); + match(EndForeach); + setState(814); + match(SemiColon); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TryCatchFinallyContext extends ParserRuleContext { + public TerminalNode Try() { return getToken(PhpParser.Try, 0); } + public BlockStatementContext blockStatement() { + return getRuleContext(BlockStatementContext.class,0); + } + public FinallyStatementContext finallyStatement() { + return getRuleContext(FinallyStatementContext.class,0); + } + public List<CatchClauseContext> catchClause() { + return getRuleContexts(CatchClauseContext.class); + } + public CatchClauseContext catchClause(int i) { + return getRuleContext(CatchClauseContext.class,i); + } + public TryCatchFinallyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tryCatchFinally; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTryCatchFinally(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTryCatchFinally(this); + } + } + + public final TryCatchFinallyContext tryCatchFinally() throws RecognitionException { + TryCatchFinallyContext _localctx = new TryCatchFinallyContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_tryCatchFinally); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(818); + match(Try); + setState(819); + blockStatement(); + setState(835); + switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { + case 1: + { + setState(821); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(820); + catchClause(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(823); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,77,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(826); + switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) { + case 1: + { + setState(825); + finallyStatement(); + } + break; + } + } + break; + case 2: + { + setState(831); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Catch) { + { + { + setState(828); + catchClause(); + } + } + setState(833); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(834); + finallyStatement(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchClauseContext extends ParserRuleContext { + public TerminalNode Catch() { return getToken(PhpParser.Catch, 0); } + public List<QualifiedStaticTypeRefContext> qualifiedStaticTypeRef() { + return getRuleContexts(QualifiedStaticTypeRefContext.class); + } + public QualifiedStaticTypeRefContext qualifiedStaticTypeRef(int i) { + return getRuleContext(QualifiedStaticTypeRefContext.class,i); + } + public BlockStatementContext blockStatement() { + return getRuleContext(BlockStatementContext.class,0); + } + public TerminalNode VarName() { return getToken(PhpParser.VarName, 0); } + public CatchClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterCatchClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitCatchClause(this); + } + } + + public final CatchClauseContext catchClause() throws RecognitionException { + CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_catchClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(837); + match(Catch); + setState(838); + match(OpenRoundBracket); + setState(839); + qualifiedStaticTypeRef(); + setState(844); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Pipe) { + { + { + setState(840); + match(Pipe); + setState(841); + qualifiedStaticTypeRef(); + } + } + setState(846); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(848); + _la = _input.LA(1); + if (_la==VarName) { + { + setState(847); + match(VarName); + } + } + + setState(850); + match(CloseRoundBracket); + setState(851); + blockStatement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FinallyStatementContext extends ParserRuleContext { + public TerminalNode Finally() { return getToken(PhpParser.Finally, 0); } + public BlockStatementContext blockStatement() { + return getRuleContext(BlockStatementContext.class,0); + } + public FinallyStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_finallyStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFinallyStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFinallyStatement(this); + } + } + + public final FinallyStatementContext finallyStatement() throws RecognitionException { + FinallyStatementContext _localctx = new FinallyStatementContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_finallyStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(853); + match(Finally); + setState(854); + blockStatement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ThrowStatementContext extends ParserRuleContext { + public TerminalNode Throw() { return getToken(PhpParser.Throw, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public ThrowStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_throwStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterThrowStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitThrowStatement(this); + } + } + + public final ThrowStatementContext throwStatement() throws RecognitionException { + ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_throwStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(856); + match(Throw); + setState(857); + expression(0); + setState(858); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class GotoStatementContext extends ParserRuleContext { + public TerminalNode Goto() { return getToken(PhpParser.Goto, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public GotoStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_gotoStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterGotoStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitGotoStatement(this); + } + } + + public final GotoStatementContext gotoStatement() throws RecognitionException { + GotoStatementContext _localctx = new GotoStatementContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_gotoStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(860); + match(Goto); + setState(861); + identifier(); + setState(862); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeclareStatementContext extends ParserRuleContext { + public TerminalNode Declare() { return getToken(PhpParser.Declare, 0); } + public DeclareListContext declareList() { + return getRuleContext(DeclareListContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public InnerStatementListContext innerStatementList() { + return getRuleContext(InnerStatementListContext.class,0); + } + public TerminalNode EndDeclare() { return getToken(PhpParser.EndDeclare, 0); } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public DeclareStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declareStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterDeclareStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitDeclareStatement(this); + } + } + + public final DeclareStatementContext declareStatement() throws RecognitionException { + DeclareStatementContext _localctx = new DeclareStatementContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_declareStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(864); + match(Declare); + setState(865); + match(OpenRoundBracket); + setState(866); + declareList(); + setState(867); + match(CloseRoundBracket); + setState(874); + switch (_input.LA(1)) { + case HtmlText: + case XmlStart: + case HtmlScriptOpen: + case HtmlStyleOpen: + case HtmlDtd: + case HtmlOpen: + case HtmlClose: + case HtmlSlashClose: + case HtmlSlash: + case HtmlEquals: + case HtmlStartQuoteString: + case HtmlStartDoubleQuoteString: + case HtmlHex: + case HtmlDecimal: + case HtmlName: + case HtmlEndQuoteString: + case HtmlQuoteString: + case HtmlEndDoubleQuoteString: + case HtmlDoubleQuoteString: + case ScriptText: + case HtmlScriptClose: + case StyleBody: + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case Inc: + case Dec: + case NamespaceSeparator: + case Bang: + case Plus: + case Minus: + case Tilde: + case SuppressWarnings: + case Dollar: + case OpenRoundBracket: + case OpenSquareBracket: + case OpenCurlyBracket: + case SemiColon: + case VarName: + case Label: + case Octal: + case Decimal: + case Real: + case Hex: + case Binary: + case BackQuoteString: + case SingleQuoteString: + case DoubleQuote: + case StartNowDoc: + case StartHereDoc: + { + setState(868); + statement(); + } + break; + case Colon: + { + setState(869); + match(Colon); + setState(870); + innerStatementList(); + setState(871); + match(EndDeclare); + setState(872); + match(SemiColon); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InlineHtmlStatementContext extends ParserRuleContext { + public List<InlineHtmlContext> inlineHtml() { + return getRuleContexts(InlineHtmlContext.class); + } + public InlineHtmlContext inlineHtml(int i) { + return getRuleContext(InlineHtmlContext.class,i); + } + public InlineHtmlStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inlineHtmlStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInlineHtmlStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInlineHtmlStatement(this); + } + } + + public final InlineHtmlStatementContext inlineHtmlStatement() throws RecognitionException { + InlineHtmlStatementContext _localctx = new InlineHtmlStatementContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_inlineHtmlStatement); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(877); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(876); + inlineHtml(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(879); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,84,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeclareListContext extends ParserRuleContext { + public List<DirectiveContext> directive() { + return getRuleContexts(DirectiveContext.class); + } + public DirectiveContext directive(int i) { + return getRuleContext(DirectiveContext.class,i); + } + public DeclareListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declareList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterDeclareList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitDeclareList(this); + } + } + + public final DeclareListContext declareList() throws RecognitionException { + DeclareListContext _localctx = new DeclareListContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_declareList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(881); + directive(); + setState(886); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(882); + match(Comma); + setState(883); + directive(); + } + } + setState(888); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DirectiveContext extends ParserRuleContext { + public TerminalNode Ticks() { return getToken(PhpParser.Ticks, 0); } + public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); } + public NumericConstantContext numericConstant() { + return getRuleContext(NumericConstantContext.class,0); + } + public TerminalNode Real() { return getToken(PhpParser.Real, 0); } + public TerminalNode Encoding() { return getToken(PhpParser.Encoding, 0); } + public TerminalNode SingleQuoteString() { return getToken(PhpParser.SingleQuoteString, 0); } + public TerminalNode StrictTypes() { return getToken(PhpParser.StrictTypes, 0); } + public DirectiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_directive; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterDirective(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitDirective(this); + } + } + + public final DirectiveContext directive() throws RecognitionException { + DirectiveContext _localctx = new DirectiveContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_directive); + try { + setState(901); + switch (_input.LA(1)) { + case Ticks: + enterOuterAlt(_localctx, 1); + { + setState(889); + match(Ticks); + setState(890); + match(Eq); + setState(893); + switch (_input.LA(1)) { + case Octal: + case Decimal: + case Hex: + case Binary: + { + setState(891); + numericConstant(); + } + break; + case Real: + { + setState(892); + match(Real); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case Encoding: + enterOuterAlt(_localctx, 2); + { + setState(895); + match(Encoding); + setState(896); + match(Eq); + setState(897); + match(SingleQuoteString); + } + break; + case StrictTypes: + enterOuterAlt(_localctx, 3); + { + setState(898); + match(StrictTypes); + setState(899); + match(Eq); + setState(900); + numericConstant(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FormalParameterListContext extends ParserRuleContext { + public List<FormalParameterContext> formalParameter() { + return getRuleContexts(FormalParameterContext.class); + } + public FormalParameterContext formalParameter(int i) { + return getRuleContext(FormalParameterContext.class,i); + } + public FormalParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameterList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFormalParameterList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFormalParameterList(this); + } + } + + public final FormalParameterListContext formalParameterList() throws RecognitionException { + FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_formalParameterList); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(904); + _la = _input.LA(1); + if (((((_la - 43)) & ~0x3f) == 0 && ((1L << (_la - 43)) & ((1L << (AttributeStart - 43)) | (1L << (Abstract - 43)) | (1L << (Array - 43)) | (1L << (As - 43)) | (1L << (BinaryCast - 43)) | (1L << (BoolType - 43)) | (1L << (BooleanConstant - 43)) | (1L << (Break - 43)) | (1L << (Callable - 43)) | (1L << (Case - 43)) | (1L << (Catch - 43)) | (1L << (Class - 43)) | (1L << (Clone - 43)) | (1L << (Const - 43)) | (1L << (Continue - 43)) | (1L << (Declare - 43)) | (1L << (Default - 43)) | (1L << (Do - 43)) | (1L << (DoubleCast - 43)) | (1L << (DoubleType - 43)) | (1L << (Echo - 43)) | (1L << (Else - 43)) | (1L << (ElseIf - 43)) | (1L << (Empty - 43)) | (1L << (Enum_ - 43)) | (1L << (EndDeclare - 43)) | (1L << (EndFor - 43)) | (1L << (EndForeach - 43)) | (1L << (EndIf - 43)) | (1L << (EndSwitch - 43)) | (1L << (EndWhile - 43)) | (1L << (Eval - 43)) | (1L << (Exit - 43)) | (1L << (Extends - 43)) | (1L << (Final - 43)) | (1L << (Finally - 43)) | (1L << (FloatCast - 43)) | (1L << (For - 43)) | (1L << (Foreach - 43)) | (1L << (Function_ - 43)) | (1L << (Global - 43)) | (1L << (Goto - 43)) | (1L << (If - 43)) | (1L << (Implements - 43)) | (1L << (Import - 43)) | (1L << (Include - 43)) | (1L << (IncludeOnce - 43)) | (1L << (InstanceOf - 43)) | (1L << (InsteadOf - 43)) | (1L << (Int8Cast - 43)) | (1L << (Int16Cast - 43)) | (1L << (Int64Type - 43)) | (1L << (IntType - 43)) | (1L << (Interface - 43)) | (1L << (IsSet - 43)) | (1L << (List - 43)) | (1L << (LogicalAnd - 43)) | (1L << (LogicalOr - 43)) | (1L << (LogicalXor - 43)) | (1L << (Match_ - 43)) | (1L << (Namespace - 43)) | (1L << (New - 43)) | (1L << (Null - 43)) | (1L << (ObjectType - 43)))) != 0) || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (Parent_ - 107)) | (1L << (Partial - 107)) | (1L << (Print - 107)) | (1L << (Private - 107)) | (1L << (Protected - 107)) | (1L << (Public - 107)) | (1L << (Readonly - 107)) | (1L << (Require - 107)) | (1L << (RequireOnce - 107)) | (1L << (Resource - 107)) | (1L << (Return - 107)) | (1L << (Static - 107)) | (1L << (StringType - 107)) | (1L << (Switch - 107)) | (1L << (Throw - 107)) | (1L << (Trait - 107)) | (1L << (Try - 107)) | (1L << (Typeof - 107)) | (1L << (UintCast - 107)) | (1L << (UnicodeCast - 107)) | (1L << (Unset - 107)) | (1L << (Use - 107)) | (1L << (Var - 107)) | (1L << (While - 107)) | (1L << (Yield - 107)) | (1L << (From - 107)) | (1L << (LambdaFn - 107)) | (1L << (Ticks - 107)) | (1L << (Encoding - 107)) | (1L << (StrictTypes - 107)) | (1L << (Get - 107)) | (1L << (Set - 107)) | (1L << (Call - 107)) | (1L << (CallStatic - 107)) | (1L << (Constructor - 107)) | (1L << (Destruct - 107)) | (1L << (Wakeup - 107)) | (1L << (Sleep - 107)) | (1L << (Autoload - 107)) | (1L << (IsSet__ - 107)) | (1L << (Unset__ - 107)) | (1L << (ToString__ - 107)) | (1L << (Invoke - 107)) | (1L << (SetState - 107)) | (1L << (Clone__ - 107)) | (1L << (DebugInfo - 107)) | (1L << (Namespace__ - 107)) | (1L << (Class__ - 107)) | (1L << (Traic__ - 107)) | (1L << (Function__ - 107)) | (1L << (Method__ - 107)) | (1L << (Line__ - 107)) | (1L << (File__ - 107)) | (1L << (Dir__ - 107)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ellipsis - 194)) | (1L << (Ampersand - 194)) | (1L << (QuestionMark - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)))) != 0)) { + { + setState(903); + formalParameter(); + } + } + + setState(910); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,89,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(906); + match(Comma); + setState(907); + formalParameter(); + } + } + } + setState(912); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,89,_ctx); + } + setState(914); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(913); + match(Comma); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FormalParameterContext extends ParserRuleContext { + public VariableInitializerContext variableInitializer() { + return getRuleContext(VariableInitializerContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public List<MemberModifierContext> memberModifier() { + return getRuleContexts(MemberModifierContext.class); + } + public MemberModifierContext memberModifier(int i) { + return getRuleContext(MemberModifierContext.class,i); + } + public TerminalNode QuestionMark() { return getToken(PhpParser.QuestionMark, 0); } + public TypeHintContext typeHint() { + return getRuleContext(TypeHintContext.class,0); + } + public FormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFormalParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFormalParameter(this); + } + } + + public final FormalParameterContext formalParameter() throws RecognitionException { + FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_formalParameter); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(917); + _la = _input.LA(1); + if (_la==AttributeStart) { + { + setState(916); + attributes(); + } + } + + setState(922); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,92,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(919); + memberModifier(); + } + } + } + setState(924); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,92,_ctx); + } + setState(926); + _la = _input.LA(1); + if (_la==QuestionMark) { + { + setState(925); + match(QuestionMark); + } + } + + setState(929); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)))) != 0) || _la==NamespaceSeparator || _la==Label) { + { + setState(928); + typeHint(0); + } + } + + setState(932); + _la = _input.LA(1); + if (_la==Ampersand) { + { + setState(931); + match(Ampersand); + } + } + + setState(935); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(934); + match(Ellipsis); + } + } + + setState(937); + variableInitializer(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeHintContext extends ParserRuleContext { + public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() { + return getRuleContext(QualifiedStaticTypeRefContext.class,0); + } + public TerminalNode Callable() { return getToken(PhpParser.Callable, 0); } + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public List<TypeHintContext> typeHint() { + return getRuleContexts(TypeHintContext.class); + } + public TypeHintContext typeHint(int i) { + return getRuleContext(TypeHintContext.class,i); + } + public TypeHintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeHint; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeHint(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeHint(this); + } + } + + public final TypeHintContext typeHint() throws RecognitionException { + return typeHint(0); + } + + private TypeHintContext typeHint(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + TypeHintContext _localctx = new TypeHintContext(_ctx, _parentState); + TypeHintContext _prevctx = _localctx; + int _startState = 118; + enterRecursionRule(_localctx, 118, RULE_typeHint, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(943); + switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) { + case 1: + { + setState(940); + qualifiedStaticTypeRef(); + } + break; + case 2: + { + setState(941); + match(Callable); + } + break; + case 3: + { + setState(942); + primitiveType(); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(950); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,98,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new TypeHintContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_typeHint); + setState(945); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(946); + match(Pipe); + setState(947); + typeHint(2); + } + } + } + setState(952); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,98,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class GlobalStatementContext extends ParserRuleContext { + public TerminalNode Global() { return getToken(PhpParser.Global, 0); } + public List<GlobalVarContext> globalVar() { + return getRuleContexts(GlobalVarContext.class); + } + public GlobalVarContext globalVar(int i) { + return getRuleContext(GlobalVarContext.class,i); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public GlobalStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_globalStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterGlobalStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitGlobalStatement(this); + } + } + + public final GlobalStatementContext globalStatement() throws RecognitionException { + GlobalStatementContext _localctx = new GlobalStatementContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_globalStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(953); + match(Global); + setState(954); + globalVar(); + setState(959); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(955); + match(Comma); + setState(956); + globalVar(); + } + } + setState(961); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(962); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class GlobalVarContext extends ParserRuleContext { + public TerminalNode VarName() { return getToken(PhpParser.VarName, 0); } + public TerminalNode Dollar() { return getToken(PhpParser.Dollar, 0); } + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public GlobalVarContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_globalVar; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterGlobalVar(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitGlobalVar(this); + } + } + + public final GlobalVarContext globalVar() throws RecognitionException { + GlobalVarContext _localctx = new GlobalVarContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_globalVar); + try { + setState(972); + switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(964); + match(VarName); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(965); + match(Dollar); + setState(966); + chain(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(967); + match(Dollar); + setState(968); + match(OpenCurlyBracket); + setState(969); + expression(0); + setState(970); + match(CloseCurlyBracket); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EchoStatementContext extends ParserRuleContext { + public TerminalNode Echo() { return getToken(PhpParser.Echo, 0); } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public EchoStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_echoStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterEchoStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitEchoStatement(this); + } + } + + public final EchoStatementContext echoStatement() throws RecognitionException { + EchoStatementContext _localctx = new EchoStatementContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_echoStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(974); + match(Echo); + setState(975); + expressionList(); + setState(976); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StaticVariableStatementContext extends ParserRuleContext { + public TerminalNode Static() { return getToken(PhpParser.Static, 0); } + public List<VariableInitializerContext> variableInitializer() { + return getRuleContexts(VariableInitializerContext.class); + } + public VariableInitializerContext variableInitializer(int i) { + return getRuleContext(VariableInitializerContext.class,i); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public StaticVariableStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_staticVariableStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterStaticVariableStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitStaticVariableStatement(this); + } + } + + public final StaticVariableStatementContext staticVariableStatement() throws RecognitionException { + StaticVariableStatementContext _localctx = new StaticVariableStatementContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_staticVariableStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(978); + match(Static); + setState(979); + variableInitializer(); + setState(984); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(980); + match(Comma); + setState(981); + variableInitializer(); + } + } + setState(986); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(987); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassStatementContext extends ParserRuleContext { + public PropertyModifiersContext propertyModifiers() { + return getRuleContext(PropertyModifiersContext.class,0); + } + public List<VariableInitializerContext> variableInitializer() { + return getRuleContexts(VariableInitializerContext.class); + } + public VariableInitializerContext variableInitializer(int i) { + return getRuleContext(VariableInitializerContext.class,i); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public TerminalNode Const() { return getToken(PhpParser.Const, 0); } + public List<IdentifierInitializerContext> identifierInitializer() { + return getRuleContexts(IdentifierInitializerContext.class); + } + public IdentifierInitializerContext identifierInitializer(int i) { + return getRuleContext(IdentifierInitializerContext.class,i); + } + public TerminalNode Function_() { return getToken(PhpParser.Function_, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public MethodBodyContext methodBody() { + return getRuleContext(MethodBodyContext.class,0); + } + public TypeHintContext typeHint() { + return getRuleContext(TypeHintContext.class,0); + } + public MemberModifiersContext memberModifiers() { + return getRuleContext(MemberModifiersContext.class,0); + } + public TypeParameterListInBracketsContext typeParameterListInBrackets() { + return getRuleContext(TypeParameterListInBracketsContext.class,0); + } + public BaseCtorCallContext baseCtorCall() { + return getRuleContext(BaseCtorCallContext.class,0); + } + public ReturnTypeDeclContext returnTypeDecl() { + return getRuleContext(ReturnTypeDeclContext.class,0); + } + public TerminalNode Use() { return getToken(PhpParser.Use, 0); } + public QualifiedNamespaceNameListContext qualifiedNamespaceNameList() { + return getRuleContext(QualifiedNamespaceNameListContext.class,0); + } + public TraitAdaptationsContext traitAdaptations() { + return getRuleContext(TraitAdaptationsContext.class,0); + } + public ClassStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterClassStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitClassStatement(this); + } + } + + public final ClassStatementContext classStatement() throws RecognitionException { + ClassStatementContext _localctx = new ClassStatementContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_classStatement); + int _la; + try { + setState(1048); + switch (_input.LA(1)) { + case AttributeStart: + case Abstract: + case Const: + case Final: + case Function_: + case Private: + case Protected: + case Public: + case Readonly: + case Static: + case Var: + enterOuterAlt(_localctx, 1); + { + setState(990); + _la = _input.LA(1); + if (_la==AttributeStart) { + { + setState(989); + attributes(); + } + } + + setState(1042); + switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) { + case 1: + { + setState(992); + propertyModifiers(); + setState(994); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)))) != 0) || _la==NamespaceSeparator || _la==Label) { + { + setState(993); + typeHint(0); + } + } + + setState(996); + variableInitializer(); + setState(1001); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(997); + match(Comma); + setState(998); + variableInitializer(); + } + } + setState(1003); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1004); + match(SemiColon); + } + break; + case 2: + { + setState(1007); + _la = _input.LA(1); + if (_la==Abstract || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)))) != 0)) { + { + setState(1006); + memberModifiers(); + } + } + + setState(1040); + switch (_input.LA(1)) { + case Const: + { + setState(1009); + match(Const); + setState(1011); + switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) { + case 1: + { + setState(1010); + typeHint(0); + } + break; + } + setState(1013); + identifierInitializer(); + setState(1018); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1014); + match(Comma); + setState(1015); + identifierInitializer(); + } + } + setState(1020); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1021); + match(SemiColon); + } + break; + case Function_: + { + setState(1023); + match(Function_); + setState(1025); + _la = _input.LA(1); + if (_la==Ampersand) { + { + setState(1024); + match(Ampersand); + } + } + + setState(1027); + identifier(); + setState(1029); + _la = _input.LA(1); + if (_la==Lgeneric) { + { + setState(1028); + typeParameterListInBrackets(); + } + } + + setState(1031); + match(OpenRoundBracket); + setState(1032); + formalParameterList(); + setState(1033); + match(CloseRoundBracket); + setState(1036); + switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) { + case 1: + { + setState(1034); + baseCtorCall(); + } + break; + case 2: + { + setState(1035); + returnTypeDecl(); + } + break; + } + setState(1038); + methodBody(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + } + break; + case Use: + enterOuterAlt(_localctx, 2); + { + setState(1044); + match(Use); + setState(1045); + qualifiedNamespaceNameList(); + setState(1046); + traitAdaptations(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TraitAdaptationsContext extends ParserRuleContext { + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public List<TraitAdaptationStatementContext> traitAdaptationStatement() { + return getRuleContexts(TraitAdaptationStatementContext.class); + } + public TraitAdaptationStatementContext traitAdaptationStatement(int i) { + return getRuleContext(TraitAdaptationStatementContext.class,i); + } + public TraitAdaptationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_traitAdaptations; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTraitAdaptations(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTraitAdaptations(this); + } + } + + public final TraitAdaptationsContext traitAdaptations() throws RecognitionException { + TraitAdaptationsContext _localctx = new TraitAdaptationsContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_traitAdaptations); + int _la; + try { + setState(1059); + switch (_input.LA(1)) { + case SemiColon: + enterOuterAlt(_localctx, 1); + { + setState(1050); + match(SemiColon); + } + break; + case OpenCurlyBracket: + enterOuterAlt(_localctx, 2); + { + setState(1051); + match(OpenCurlyBracket); + setState(1055); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)))) != 0) || _la==NamespaceSeparator || _la==Label) { + { + { + setState(1052); + traitAdaptationStatement(); + } + } + setState(1057); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1058); + match(CloseCurlyBracket); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TraitAdaptationStatementContext extends ParserRuleContext { + public TraitPrecedenceContext traitPrecedence() { + return getRuleContext(TraitPrecedenceContext.class,0); + } + public TraitAliasContext traitAlias() { + return getRuleContext(TraitAliasContext.class,0); + } + public TraitAdaptationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_traitAdaptationStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTraitAdaptationStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTraitAdaptationStatement(this); + } + } + + public final TraitAdaptationStatementContext traitAdaptationStatement() throws RecognitionException { + TraitAdaptationStatementContext _localctx = new TraitAdaptationStatementContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_traitAdaptationStatement); + try { + setState(1063); + switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1061); + traitPrecedence(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1062); + traitAlias(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TraitPrecedenceContext extends ParserRuleContext { + public QualifiedNamespaceNameContext qualifiedNamespaceName() { + return getRuleContext(QualifiedNamespaceNameContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode InsteadOf() { return getToken(PhpParser.InsteadOf, 0); } + public QualifiedNamespaceNameListContext qualifiedNamespaceNameList() { + return getRuleContext(QualifiedNamespaceNameListContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public TraitPrecedenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_traitPrecedence; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTraitPrecedence(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTraitPrecedence(this); + } + } + + public final TraitPrecedenceContext traitPrecedence() throws RecognitionException { + TraitPrecedenceContext _localctx = new TraitPrecedenceContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_traitPrecedence); + try { + enterOuterAlt(_localctx, 1); + { + setState(1065); + qualifiedNamespaceName(); + setState(1066); + match(DoubleColon); + setState(1067); + identifier(); + setState(1068); + match(InsteadOf); + setState(1069); + qualifiedNamespaceNameList(); + setState(1070); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TraitAliasContext extends ParserRuleContext { + public TraitMethodReferenceContext traitMethodReference() { + return getRuleContext(TraitMethodReferenceContext.class,0); + } + public TerminalNode As() { return getToken(PhpParser.As, 0); } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public MemberModifierContext memberModifier() { + return getRuleContext(MemberModifierContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TraitAliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_traitAlias; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTraitAlias(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTraitAlias(this); + } + } + + public final TraitAliasContext traitAlias() throws RecognitionException { + TraitAliasContext _localctx = new TraitAliasContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_traitAlias); + try { + enterOuterAlt(_localctx, 1); + { + setState(1072); + traitMethodReference(); + setState(1073); + match(As); + setState(1079); + switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) { + case 1: + { + setState(1074); + memberModifier(); + } + break; + case 2: + { + setState(1076); + switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) { + case 1: + { + setState(1075); + memberModifier(); + } + break; + } + setState(1078); + identifier(); + } + break; + } + setState(1081); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TraitMethodReferenceContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public QualifiedNamespaceNameContext qualifiedNamespaceName() { + return getRuleContext(QualifiedNamespaceNameContext.class,0); + } + public TraitMethodReferenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_traitMethodReference; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTraitMethodReference(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTraitMethodReference(this); + } + } + + public final TraitMethodReferenceContext traitMethodReference() throws RecognitionException { + TraitMethodReferenceContext _localctx = new TraitMethodReferenceContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_traitMethodReference); + try { + enterOuterAlt(_localctx, 1); + { + setState(1086); + switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) { + case 1: + { + setState(1083); + qualifiedNamespaceName(); + setState(1084); + match(DoubleColon); + } + break; + } + setState(1088); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BaseCtorCallContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public BaseCtorCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_baseCtorCall; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterBaseCtorCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitBaseCtorCall(this); + } + } + + public final BaseCtorCallContext baseCtorCall() throws RecognitionException { + BaseCtorCallContext _localctx = new BaseCtorCallContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_baseCtorCall); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1090); + match(Colon); + setState(1091); + identifier(); + setState(1093); + _la = _input.LA(1); + if (_la==OpenRoundBracket) { + { + setState(1092); + arguments(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ReturnTypeDeclContext extends ParserRuleContext { + public TypeHintContext typeHint() { + return getRuleContext(TypeHintContext.class,0); + } + public TerminalNode QuestionMark() { return getToken(PhpParser.QuestionMark, 0); } + public ReturnTypeDeclContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_returnTypeDecl; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterReturnTypeDecl(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitReturnTypeDecl(this); + } + } + + public final ReturnTypeDeclContext returnTypeDecl() throws RecognitionException { + ReturnTypeDeclContext _localctx = new ReturnTypeDeclContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_returnTypeDecl); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1095); + match(Colon); + setState(1097); + _la = _input.LA(1); + if (_la==QuestionMark) { + { + setState(1096); + match(QuestionMark); + } + } + + setState(1099); + typeHint(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodBodyContext extends ParserRuleContext { + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public BlockStatementContext blockStatement() { + return getRuleContext(BlockStatementContext.class,0); + } + public MethodBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMethodBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMethodBody(this); + } + } + + public final MethodBodyContext methodBody() throws RecognitionException { + MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_methodBody); + try { + setState(1103); + switch (_input.LA(1)) { + case SemiColon: + enterOuterAlt(_localctx, 1); + { + setState(1101); + match(SemiColon); + } + break; + case OpenCurlyBracket: + enterOuterAlt(_localctx, 2); + { + setState(1102); + blockStatement(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PropertyModifiersContext extends ParserRuleContext { + public MemberModifiersContext memberModifiers() { + return getRuleContext(MemberModifiersContext.class,0); + } + public TerminalNode Var() { return getToken(PhpParser.Var, 0); } + public PropertyModifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_propertyModifiers; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPropertyModifiers(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPropertyModifiers(this); + } + } + + public final PropertyModifiersContext propertyModifiers() throws RecognitionException { + PropertyModifiersContext _localctx = new PropertyModifiersContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_propertyModifiers); + try { + setState(1107); + switch (_input.LA(1)) { + case Abstract: + case Final: + case Private: + case Protected: + case Public: + case Readonly: + case Static: + enterOuterAlt(_localctx, 1); + { + setState(1105); + memberModifiers(); + } + break; + case Var: + enterOuterAlt(_localctx, 2); + { + setState(1106); + match(Var); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MemberModifiersContext extends ParserRuleContext { + public List<MemberModifierContext> memberModifier() { + return getRuleContexts(MemberModifierContext.class); + } + public MemberModifierContext memberModifier(int i) { + return getRuleContext(MemberModifierContext.class,i); + } + public MemberModifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memberModifiers; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMemberModifiers(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMemberModifiers(this); + } + } + + public final MemberModifiersContext memberModifiers() throws RecognitionException { + MemberModifiersContext _localctx = new MemberModifiersContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_memberModifiers); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1110); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1109); + memberModifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1112); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,124,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableInitializerContext extends ParserRuleContext { + public TerminalNode VarName() { return getToken(PhpParser.VarName, 0); } + public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); } + public ConstantInitializerContext constantInitializer() { + return getRuleContext(ConstantInitializerContext.class,0); + } + public VariableInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableInitializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterVariableInitializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitVariableInitializer(this); + } + } + + public final VariableInitializerContext variableInitializer() throws RecognitionException { + VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_variableInitializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1114); + match(VarName); + setState(1117); + _la = _input.LA(1); + if (_la==Eq) { + { + setState(1115); + match(Eq); + setState(1116); + constantInitializer(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IdentifierInitializerContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); } + public ConstantInitializerContext constantInitializer() { + return getRuleContext(ConstantInitializerContext.class,0); + } + public IdentifierInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifierInitializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIdentifierInitializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIdentifierInitializer(this); + } + } + + public final IdentifierInitializerContext identifierInitializer() throws RecognitionException { + IdentifierInitializerContext _localctx = new IdentifierInitializerContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_identifierInitializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(1119); + identifier(); + setState(1120); + match(Eq); + setState(1121); + constantInitializer(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class GlobalConstantDeclarationContext extends ParserRuleContext { + public TerminalNode Const() { return getToken(PhpParser.Const, 0); } + public List<IdentifierInitializerContext> identifierInitializer() { + return getRuleContexts(IdentifierInitializerContext.class); + } + public IdentifierInitializerContext identifierInitializer(int i) { + return getRuleContext(IdentifierInitializerContext.class,i); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public GlobalConstantDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_globalConstantDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterGlobalConstantDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitGlobalConstantDeclaration(this); + } + } + + public final GlobalConstantDeclarationContext globalConstantDeclaration() throws RecognitionException { + GlobalConstantDeclarationContext _localctx = new GlobalConstantDeclarationContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_globalConstantDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1124); + _la = _input.LA(1); + if (_la==AttributeStart) { + { + setState(1123); + attributes(); + } + } + + setState(1126); + match(Const); + setState(1127); + identifierInitializer(); + setState(1132); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1128); + match(Comma); + setState(1129); + identifierInitializer(); + } + } + setState(1134); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1135); + match(SemiColon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumDeclarationContext extends ParserRuleContext { + public TerminalNode Enum_() { return getToken(PhpParser.Enum_, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public TerminalNode Colon() { return getToken(PhpParser.Colon, 0); } + public TerminalNode Implements() { return getToken(PhpParser.Implements, 0); } + public InterfaceListContext interfaceList() { + return getRuleContext(InterfaceListContext.class,0); + } + public List<EnumItemContext> enumItem() { + return getRuleContexts(EnumItemContext.class); + } + public EnumItemContext enumItem(int i) { + return getRuleContext(EnumItemContext.class,i); + } + public TerminalNode IntType() { return getToken(PhpParser.IntType, 0); } + public TerminalNode StringType() { return getToken(PhpParser.StringType, 0); } + public EnumDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterEnumDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitEnumDeclaration(this); + } + } + + public final EnumDeclarationContext enumDeclaration() throws RecognitionException { + EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_enumDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1137); + match(Enum_); + setState(1138); + identifier(); + setState(1141); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1139); + match(Colon); + setState(1140); + _la = _input.LA(1); + if ( !(_la==IntType || _la==StringType) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + + setState(1145); + _la = _input.LA(1); + if (_la==Implements) { + { + setState(1143); + match(Implements); + setState(1144); + interfaceList(); + } + } + + setState(1147); + match(OpenCurlyBracket); + setState(1151); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AttributeStart) | (1L << Abstract) | (1L << Case))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Function_ - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)) | (1L << (Use - 77)))) != 0)) { + { + { + setState(1148); + enumItem(); + } + } + setState(1153); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1154); + match(CloseCurlyBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumItemContext extends ParserRuleContext { + public TerminalNode Case() { return getToken(PhpParser.Case, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); } + public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public FunctionDeclarationContext functionDeclaration() { + return getRuleContext(FunctionDeclarationContext.class,0); + } + public MemberModifiersContext memberModifiers() { + return getRuleContext(MemberModifiersContext.class,0); + } + public TerminalNode Use() { return getToken(PhpParser.Use, 0); } + public QualifiedNamespaceNameListContext qualifiedNamespaceNameList() { + return getRuleContext(QualifiedNamespaceNameListContext.class,0); + } + public TraitAdaptationsContext traitAdaptations() { + return getRuleContext(TraitAdaptationsContext.class,0); + } + public EnumItemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumItem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterEnumItem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitEnumItem(this); + } + } + + public final EnumItemContext enumItem() throws RecognitionException { + EnumItemContext _localctx = new EnumItemContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_enumItem); + int _la; + try { + setState(1172); + switch (_input.LA(1)) { + case Case: + enterOuterAlt(_localctx, 1); + { + setState(1156); + match(Case); + setState(1157); + identifier(); + setState(1160); + _la = _input.LA(1); + if (_la==Eq) { + { + setState(1158); + match(Eq); + setState(1159); + expression(0); + } + } + + setState(1162); + match(SemiColon); + } + break; + case AttributeStart: + case Abstract: + case Final: + case Function_: + case Private: + case Protected: + case Public: + case Readonly: + case Static: + enterOuterAlt(_localctx, 2); + { + setState(1165); + _la = _input.LA(1); + if (_la==Abstract || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)))) != 0)) { + { + setState(1164); + memberModifiers(); + } + } + + setState(1167); + functionDeclaration(); + } + break; + case Use: + enterOuterAlt(_localctx, 3); + { + setState(1168); + match(Use); + setState(1169); + qualifiedNamespaceNameList(); + setState(1170); + traitAdaptations(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionListContext extends ParserRuleContext { + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public ExpressionListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterExpressionList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitExpressionList(this); + } + } + + public final ExpressionListContext expressionList() throws RecognitionException { + ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_expressionList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1174); + expression(0); + setState(1179); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1175); + match(Comma); + setState(1176); + expression(0); + } + } + setState(1181); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ParenthesesContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public YieldExpressionContext yieldExpression() { + return getRuleContext(YieldExpressionContext.class,0); + } + public ParenthesesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parentheses; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterParentheses(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitParentheses(this); + } + } + + public final ParenthesesContext parentheses() throws RecognitionException { + ParenthesesContext _localctx = new ParenthesesContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_parentheses); + try { + enterOuterAlt(_localctx, 1); + { + setState(1182); + match(OpenRoundBracket); + setState(1185); + switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { + case 1: + { + setState(1183); + expression(0); + } + break; + case 2: + { + setState(1184); + yieldExpression(); + } + break; + } + setState(1187); + match(CloseRoundBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionContext extends ParserRuleContext { + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression; } + + public ExpressionContext() { } + public void copyFrom(ExpressionContext ctx) { + super.copyFrom(ctx); + } + } + public static class ChainExpressionContext extends ExpressionContext { + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public ChainExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterChainExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitChainExpression(this); + } + } + public static class SpecialWordExpressionContext extends ExpressionContext { + public TerminalNode List() { return getToken(PhpParser.List, 0); } + public AssignmentListContext assignmentList() { + return getRuleContext(AssignmentListContext.class,0); + } + public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode Include() { return getToken(PhpParser.Include, 0); } + public TerminalNode IncludeOnce() { return getToken(PhpParser.IncludeOnce, 0); } + public TerminalNode Require() { return getToken(PhpParser.Require, 0); } + public TerminalNode RequireOnce() { return getToken(PhpParser.RequireOnce, 0); } + public TerminalNode Throw() { return getToken(PhpParser.Throw, 0); } + public TerminalNode Yield() { return getToken(PhpParser.Yield, 0); } + public TerminalNode IsSet() { return getToken(PhpParser.IsSet, 0); } + public ChainListContext chainList() { + return getRuleContext(ChainListContext.class,0); + } + public TerminalNode Empty() { return getToken(PhpParser.Empty, 0); } + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public TerminalNode Eval() { return getToken(PhpParser.Eval, 0); } + public TerminalNode Exit() { return getToken(PhpParser.Exit, 0); } + public ParenthesesContext parentheses() { + return getRuleContext(ParenthesesContext.class,0); + } + public SpecialWordExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterSpecialWordExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitSpecialWordExpression(this); + } + } + public static class ArrayCreationExpressionContext extends ExpressionContext { + public ArrayCreationContext arrayCreation() { + return getRuleContext(ArrayCreationContext.class,0); + } + public ArrayCreationExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayCreationExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayCreationExpression(this); + } + } + public static class BackQuoteStringExpressionContext extends ExpressionContext { + public TerminalNode BackQuoteString() { return getToken(PhpParser.BackQuoteString, 0); } + public BackQuoteStringExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterBackQuoteStringExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitBackQuoteStringExpression(this); + } + } + public static class MatchExpressionContext extends ExpressionContext { + public MatchExprContext matchExpr() { + return getRuleContext(MatchExprContext.class,0); + } + public MatchExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMatchExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMatchExpression(this); + } + } + public static class LogicalExpressionContext extends ExpressionContext { + public Token op; + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode LogicalAnd() { return getToken(PhpParser.LogicalAnd, 0); } + public TerminalNode LogicalXor() { return getToken(PhpParser.LogicalXor, 0); } + public TerminalNode LogicalOr() { return getToken(PhpParser.LogicalOr, 0); } + public LogicalExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLogicalExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLogicalExpression(this); + } + } + public static class PrintExpressionContext extends ExpressionContext { + public TerminalNode Print() { return getToken(PhpParser.Print, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public PrintExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPrintExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPrintExpression(this); + } + } + public static class AssignmentExpressionContext extends ExpressionContext { + public AssignableContext assignable() { + return getRuleContext(AssignableContext.class,0); + } + public AssignmentOperatorContext assignmentOperator() { + return getRuleContext(AssignmentOperatorContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); } + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public NewExprContext newExpr() { + return getRuleContext(NewExprContext.class,0); + } + public AssignmentExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAssignmentExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAssignmentExpression(this); + } + } + public static class PostfixIncDecExpressionContext extends ExpressionContext { + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public PostfixIncDecExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPostfixIncDecExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPostfixIncDecExpression(this); + } + } + public static class CloneExpressionContext extends ExpressionContext { + public TerminalNode Clone() { return getToken(PhpParser.Clone, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public CloneExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterCloneExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitCloneExpression(this); + } + } + public static class UnaryOperatorExpressionContext extends ExpressionContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public UnaryOperatorExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterUnaryOperatorExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitUnaryOperatorExpression(this); + } + } + public static class NewExpressionContext extends ExpressionContext { + public NewExprContext newExpr() { + return getRuleContext(NewExprContext.class,0); + } + public NewExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNewExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNewExpression(this); + } + } + public static class ParenthesisExpressionContext extends ExpressionContext { + public ParenthesesContext parentheses() { + return getRuleContext(ParenthesesContext.class,0); + } + public ParenthesisExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterParenthesisExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitParenthesisExpression(this); + } + } + public static class SpaceshipExpressionContext extends ExpressionContext { + public Token op; + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public SpaceshipExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterSpaceshipExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitSpaceshipExpression(this); + } + } + public static class ConditionalExpressionContext extends ExpressionContext { + public Token op; + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode QuestionMark() { return getToken(PhpParser.QuestionMark, 0); } + public ConditionalExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterConditionalExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitConditionalExpression(this); + } + } + public static class NullCoalescingExpressionContext extends ExpressionContext { + public Token op; + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public NullCoalescingExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNullCoalescingExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNullCoalescingExpression(this); + } + } + public static class ArithmeticExpressionContext extends ExpressionContext { + public Token op; + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode Divide() { return getToken(PhpParser.Divide, 0); } + public ArithmeticExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArithmeticExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArithmeticExpression(this); + } + } + public static class IndexerExpressionContext extends ExpressionContext { + public StringConstantContext stringConstant() { + return getRuleContext(StringConstantContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public IndexerExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIndexerExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIndexerExpression(this); + } + } + public static class ScalarExpressionContext extends ExpressionContext { + public ConstantContext constant() { + return getRuleContext(ConstantContext.class,0); + } + public StringContext string() { + return getRuleContext(StringContext.class,0); + } + public TerminalNode Label() { return getToken(PhpParser.Label, 0); } + public ScalarExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterScalarExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitScalarExpression(this); + } + } + public static class PrefixIncDecExpressionContext extends ExpressionContext { + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public PrefixIncDecExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPrefixIncDecExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPrefixIncDecExpression(this); + } + } + public static class ComparisonExpressionContext extends ExpressionContext { + public Token op; + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode Less() { return getToken(PhpParser.Less, 0); } + public TerminalNode Greater() { return getToken(PhpParser.Greater, 0); } + public TerminalNode IsNotEq() { return getToken(PhpParser.IsNotEq, 0); } + public ComparisonExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterComparisonExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitComparisonExpression(this); + } + } + public static class CastExpressionContext extends ExpressionContext { + public CastOperationContext castOperation() { + return getRuleContext(CastOperationContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public CastExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterCastExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitCastExpression(this); + } + } + public static class InstanceOfExpressionContext extends ExpressionContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode InstanceOf() { return getToken(PhpParser.InstanceOf, 0); } + public TypeRefContext typeRef() { + return getRuleContext(TypeRefContext.class,0); + } + public InstanceOfExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInstanceOfExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInstanceOfExpression(this); + } + } + public static class ArrayDestructExpressionContext extends ExpressionContext { + public ArrayDestructuringContext arrayDestructuring() { + return getRuleContext(ArrayDestructuringContext.class,0); + } + public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ArrayDestructExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayDestructExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayDestructExpression(this); + } + } + public static class LambdaFunctionExpressionContext extends ExpressionContext { + public LambdaFunctionExprContext lambdaFunctionExpr() { + return getRuleContext(LambdaFunctionExprContext.class,0); + } + public LambdaFunctionExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLambdaFunctionExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLambdaFunctionExpression(this); + } + } + public static class BitwiseExpressionContext extends ExpressionContext { + public Token op; + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public BitwiseExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterBitwiseExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitBitwiseExpression(this); + } + } + + public final ExpressionContext expression() throws RecognitionException { + return expression(0); + } + + private ExpressionContext expression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); + ExpressionContext _prevctx = _localctx; + int _startState = 164; + enterRecursionRule(_localctx, 164, RULE_expression, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1279); + switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { + case 1: + { + _localctx = new CloneExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + + setState(1190); + match(Clone); + setState(1191); + expression(48); + } + break; + case 2: + { + _localctx = new CastExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1192); + match(OpenRoundBracket); + setState(1193); + castOperation(); + setState(1194); + match(CloseRoundBracket); + setState(1195); + expression(45); + } + break; + case 3: + { + _localctx = new UnaryOperatorExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1197); + _la = _input.LA(1); + if ( !(_la==Tilde || _la==SuppressWarnings) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + setState(1198); + expression(44); + } + break; + case 4: + { + _localctx = new UnaryOperatorExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1199); + _la = _input.LA(1); + if ( !(((((_la - 200)) & ~0x3f) == 0 && ((1L << (_la - 200)) & ((1L << (Bang - 200)) | (1L << (Plus - 200)) | (1L << (Minus - 200)))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + setState(1200); + expression(43); + } + break; + case 5: + { + _localctx = new PrintExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1201); + match(Print); + setState(1202); + expression(40); + } + break; + case 6: + { + _localctx = new SpecialWordExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1203); + match(List); + setState(1204); + match(OpenRoundBracket); + setState(1205); + assignmentList(); + setState(1206); + match(CloseRoundBracket); + setState(1207); + match(Eq); + setState(1208); + expression(31); + } + break; + case 7: + { + _localctx = new SpecialWordExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1210); + _la = _input.LA(1); + if ( !(_la==Include || _la==IncludeOnce) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + setState(1211); + expression(26); + } + break; + case 8: + { + _localctx = new SpecialWordExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1212); + _la = _input.LA(1); + if ( !(_la==Require || _la==RequireOnce) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + setState(1213); + expression(25); + } + break; + case 9: + { + _localctx = new SpecialWordExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1214); + match(Throw); + setState(1215); + expression(7); + } + break; + case 10: + { + _localctx = new ArrayDestructExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1216); + arrayDestructuring(); + setState(1217); + match(Eq); + setState(1218); + expression(6); + } + break; + case 11: + { + _localctx = new AssignmentExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1220); + assignable(); + setState(1221); + assignmentOperator(); + setState(1223); + _la = _input.LA(1); + if (_la==AttributeStart) { + { + setState(1222); + attributes(); + } + } + + setState(1225); + expression(5); + } + break; + case 12: + { + _localctx = new NewExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1227); + newExpr(); + } + break; + case 13: + { + _localctx = new IndexerExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1228); + stringConstant(); + setState(1229); + match(OpenSquareBracket); + setState(1230); + expression(0); + setState(1231); + match(CloseSquareBracket); + } + break; + case 14: + { + _localctx = new PrefixIncDecExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1233); + _la = _input.LA(1); + if ( !(_la==Inc || _la==Dec) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + setState(1234); + chain(); + } + break; + case 15: + { + _localctx = new PostfixIncDecExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1235); + chain(); + setState(1236); + _la = _input.LA(1); + if ( !(_la==Inc || _la==Dec) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + break; + case 16: + { + _localctx = new ArrayCreationExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1238); + arrayCreation(); + } + break; + case 17: + { + _localctx = new ChainExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1239); + chain(); + } + break; + case 18: + { + _localctx = new ScalarExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1240); + constant(); + } + break; + case 19: + { + _localctx = new ScalarExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1241); + string(); + } + break; + case 20: + { + _localctx = new ScalarExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1242); + match(Label); + } + break; + case 21: + { + _localctx = new BackQuoteStringExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1243); + match(BackQuoteString); + } + break; + case 22: + { + _localctx = new ParenthesisExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1244); + parentheses(); + } + break; + case 23: + { + _localctx = new SpecialWordExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1245); + match(Yield); + } + break; + case 24: + { + _localctx = new SpecialWordExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1246); + match(IsSet); + setState(1247); + match(OpenRoundBracket); + setState(1248); + chainList(); + setState(1249); + match(CloseRoundBracket); + } + break; + case 25: + { + _localctx = new SpecialWordExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1251); + match(Empty); + setState(1252); + match(OpenRoundBracket); + setState(1253); + chain(); + setState(1254); + match(CloseRoundBracket); + } + break; + case 26: + { + _localctx = new SpecialWordExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1256); + match(Eval); + setState(1257); + match(OpenRoundBracket); + setState(1258); + expression(0); + setState(1259); + match(CloseRoundBracket); + } + break; + case 27: + { + _localctx = new SpecialWordExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1261); + match(Exit); + setState(1265); + switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { + case 1: + { + setState(1262); + match(OpenRoundBracket); + setState(1263); + match(CloseRoundBracket); + } + break; + case 2: + { + setState(1264); + parentheses(); + } + break; + } + } + break; + case 28: + { + _localctx = new LambdaFunctionExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1267); + lambdaFunctionExpr(); + } + break; + case 29: + { + _localctx = new MatchExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1268); + matchExpr(); + } + break; + case 30: + { + _localctx = new AssignmentExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(1269); + assignable(); + setState(1270); + match(Eq); + setState(1272); + _la = _input.LA(1); + if (_la==AttributeStart) { + { + setState(1271); + attributes(); + } + } + + setState(1274); + match(Ampersand); + setState(1277); + switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) { + case 1: + { + setState(1275); + chain(); + } + break; + case 2: + { + setState(1276); + newExpr(); + } + break; + } + } + break; + } + _ctx.stop = _input.LT(-1); + setState(1341); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,143,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(1339); + switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { + case 1: + { + _localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1281); + if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)"); + setState(1282); + ((ArithmeticExpressionContext)_localctx).op = match(Pow); + setState(1283); + expression(22); + } + break; + case 2: + { + _localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1284); + if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)"); + setState(1285); + ((ArithmeticExpressionContext)_localctx).op = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 204)) & ~0x3f) == 0 && ((1L << (_la - 204)) & ((1L << (Asterisk - 204)) | (1L << (Percent - 204)) | (1L << (Divide - 204)))) != 0)) ) { + ((ArithmeticExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this); + } else { + consume(); + } + setState(1286); + expression(21); + } + break; + case 3: + { + _localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1287); + if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)"); + setState(1288); + ((ArithmeticExpressionContext)_localctx).op = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 202)) & ~0x3f) == 0 && ((1L << (_la - 202)) & ((1L << (Plus - 202)) | (1L << (Minus - 202)) | (1L << (Dot - 202)))) != 0)) ) { + ((ArithmeticExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this); + } else { + consume(); + } + setState(1289); + expression(20); + } + break; + case 4: + { + _localctx = new ComparisonExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1290); + if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)"); + setState(1291); + ((ComparisonExpressionContext)_localctx).op = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ShiftLeft || _la==ShiftRight) ) { + ((ComparisonExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this); + } else { + consume(); + } + setState(1292); + expression(19); + } + break; + case 5: + { + _localctx = new ComparisonExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1293); + if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)"); + setState(1294); + ((ComparisonExpressionContext)_localctx).op = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 171)) & ~0x3f) == 0 && ((1L << (_la - 171)) & ((1L << (IsSmallerOrEqual - 171)) | (1L << (IsGreaterOrEqual - 171)) | (1L << (Less - 171)) | (1L << (Greater - 171)))) != 0)) ) { + ((ComparisonExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this); + } else { + consume(); + } + setState(1295); + expression(18); + } + break; + case 6: + { + _localctx = new ComparisonExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1296); + if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)"); + setState(1297); + ((ComparisonExpressionContext)_localctx).op = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & ((1L << (IsIdentical - 167)) | (1L << (IsNoidentical - 167)) | (1L << (IsEqual - 167)) | (1L << (IsNotEq - 167)))) != 0)) ) { + ((ComparisonExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this); + } else { + consume(); + } + setState(1298); + expression(17); + } + break; + case 7: + { + _localctx = new BitwiseExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1299); + if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)"); + setState(1300); + ((BitwiseExpressionContext)_localctx).op = match(Ampersand); + setState(1301); + expression(16); + } + break; + case 8: + { + _localctx = new BitwiseExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1302); + if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)"); + setState(1303); + ((BitwiseExpressionContext)_localctx).op = match(Caret); + setState(1304); + expression(15); + } + break; + case 9: + { + _localctx = new BitwiseExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1305); + if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); + setState(1306); + ((BitwiseExpressionContext)_localctx).op = match(Pipe); + setState(1307); + expression(14); + } + break; + case 10: + { + _localctx = new BitwiseExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1308); + if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); + setState(1309); + ((BitwiseExpressionContext)_localctx).op = match(BooleanAnd); + setState(1310); + expression(13); + } + break; + case 11: + { + _localctx = new BitwiseExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1311); + if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); + setState(1312); + ((BitwiseExpressionContext)_localctx).op = match(BooleanOr); + setState(1313); + expression(12); + } + break; + case 12: + { + _localctx = new ConditionalExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1314); + if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); + setState(1315); + ((ConditionalExpressionContext)_localctx).op = match(QuestionMark); + setState(1317); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(1316); + expression(0); + } + } + + setState(1319); + match(Colon); + setState(1320); + expression(11); + } + break; + case 13: + { + _localctx = new NullCoalescingExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1321); + if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); + setState(1322); + ((NullCoalescingExpressionContext)_localctx).op = match(NullCoalescing); + setState(1323); + expression(10); + } + break; + case 14: + { + _localctx = new SpaceshipExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1324); + if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); + setState(1325); + ((SpaceshipExpressionContext)_localctx).op = match(Spaceship); + setState(1326); + expression(9); + } + break; + case 15: + { + _localctx = new LogicalExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1327); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(1328); + ((LogicalExpressionContext)_localctx).op = match(LogicalAnd); + setState(1329); + expression(4); + } + break; + case 16: + { + _localctx = new LogicalExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1330); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1331); + ((LogicalExpressionContext)_localctx).op = match(LogicalXor); + setState(1332); + expression(3); + } + break; + case 17: + { + _localctx = new LogicalExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1333); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(1334); + ((LogicalExpressionContext)_localctx).op = match(LogicalOr); + setState(1335); + expression(2); + } + break; + case 18: + { + _localctx = new InstanceOfExpressionContext(new ExpressionContext(_parentctx, _parentState)); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1336); + if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)"); + setState(1337); + match(InstanceOf); + setState(1338); + typeRef(); + } + break; + } + } + } + setState(1343); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,143,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class AssignableContext extends ParserRuleContext { + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public ArrayCreationContext arrayCreation() { + return getRuleContext(ArrayCreationContext.class,0); + } + public AssignableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAssignable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAssignable(this); + } + } + + public final AssignableContext assignable() throws RecognitionException { + AssignableContext _localctx = new AssignableContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_assignable); + try { + setState(1346); + switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1344); + chain(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1345); + arrayCreation(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayCreationContext extends ParserRuleContext { + public TerminalNode Array() { return getToken(PhpParser.Array, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ArrayItemListContext arrayItemList() { + return getRuleContext(ArrayItemListContext.class,0); + } + public ArrayCreationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayCreation; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayCreation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayCreation(this); + } + } + + public final ArrayCreationContext arrayCreation() throws RecognitionException { + ArrayCreationContext _localctx = new ArrayCreationContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_arrayCreation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1359); + switch (_input.LA(1)) { + case Array: + { + setState(1348); + match(Array); + setState(1349); + match(OpenRoundBracket); + setState(1351); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(1350); + arrayItemList(); + } + } + + setState(1353); + match(CloseRoundBracket); + } + break; + case OpenSquareBracket: + { + setState(1354); + match(OpenSquareBracket); + setState(1356); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(1355); + arrayItemList(); + } + } + + setState(1358); + match(CloseSquareBracket); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1365); + switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { + case 1: + { + setState(1361); + match(OpenSquareBracket); + setState(1362); + expression(0); + setState(1363); + match(CloseSquareBracket); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayDestructuringContext extends ParserRuleContext { + public List<IndexedDestructItemContext> indexedDestructItem() { + return getRuleContexts(IndexedDestructItemContext.class); + } + public IndexedDestructItemContext indexedDestructItem(int i) { + return getRuleContext(IndexedDestructItemContext.class,i); + } + public List<KeyedDestructItemContext> keyedDestructItem() { + return getRuleContexts(KeyedDestructItemContext.class); + } + public KeyedDestructItemContext keyedDestructItem(int i) { + return getRuleContext(KeyedDestructItemContext.class,i); + } + public ArrayDestructuringContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayDestructuring; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayDestructuring(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayDestructuring(this); + } + } + + public final ArrayDestructuringContext arrayDestructuring() throws RecognitionException { + ArrayDestructuringContext _localctx = new ArrayDestructuringContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_arrayDestructuring); + int _la; + try { + int _alt; + setState(1412); + switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1367); + match(OpenSquareBracket); + setState(1371); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1368); + match(Comma); + } + } + setState(1373); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1374); + indexedDestructItem(); + setState(1383); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,151,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1376); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1375); + match(Comma); + } + } + setState(1378); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==Comma ); + setState(1380); + indexedDestructItem(); + } + } + } + setState(1385); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,151,_ctx); + } + setState(1389); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1386); + match(Comma); + } + } + setState(1391); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1392); + match(CloseSquareBracket); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1394); + match(OpenSquareBracket); + setState(1395); + keyedDestructItem(); + setState(1404); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,154,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1397); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1396); + match(Comma); + } + } + setState(1399); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==Comma ); + setState(1401); + keyedDestructItem(); + } + } + } + setState(1406); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,154,_ctx); + } + setState(1408); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1407); + match(Comma); + } + } + + setState(1410); + match(CloseSquareBracket); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IndexedDestructItemContext extends ParserRuleContext { + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public IndexedDestructItemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indexedDestructItem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIndexedDestructItem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIndexedDestructItem(this); + } + } + + public final IndexedDestructItemContext indexedDestructItem() throws RecognitionException { + IndexedDestructItemContext _localctx = new IndexedDestructItemContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_indexedDestructItem); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1415); + _la = _input.LA(1); + if (_la==Ampersand) { + { + setState(1414); + match(Ampersand); + } + } + + setState(1417); + chain(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class KeyedDestructItemContext extends ParserRuleContext { + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public KeyedDestructItemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_keyedDestructItem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterKeyedDestructItem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitKeyedDestructItem(this); + } + } + + public final KeyedDestructItemContext keyedDestructItem() throws RecognitionException { + KeyedDestructItemContext _localctx = new KeyedDestructItemContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_keyedDestructItem); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1422); + switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) { + case 1: + { + setState(1419); + expression(0); + setState(1420); + match(DoubleArrow); + } + break; + } + setState(1425); + _la = _input.LA(1); + if (_la==Ampersand) { + { + setState(1424); + match(Ampersand); + } + } + + setState(1427); + chain(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaFunctionExprContext extends ParserRuleContext { + public TerminalNode Function_() { return getToken(PhpParser.Function_, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public BlockStatementContext blockStatement() { + return getRuleContext(BlockStatementContext.class,0); + } + public TerminalNode Static() { return getToken(PhpParser.Static, 0); } + public LambdaFunctionUseVarsContext lambdaFunctionUseVars() { + return getRuleContext(LambdaFunctionUseVarsContext.class,0); + } + public TypeHintContext typeHint() { + return getRuleContext(TypeHintContext.class,0); + } + public TerminalNode LambdaFn() { return getToken(PhpParser.LambdaFn, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public LambdaFunctionExprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaFunctionExpr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLambdaFunctionExpr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLambdaFunctionExpr(this); + } + } + + public final LambdaFunctionExprContext lambdaFunctionExpr() throws RecognitionException { + LambdaFunctionExprContext _localctx = new LambdaFunctionExprContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_lambdaFunctionExpr); + int _la; + try { + setState(1455); + switch (_input.LA(1)) { + case Function_: + case Static: + enterOuterAlt(_localctx, 1); + { + setState(1430); + _la = _input.LA(1); + if (_la==Static) { + { + setState(1429); + match(Static); + } + } + + setState(1432); + match(Function_); + setState(1434); + _la = _input.LA(1); + if (_la==Ampersand) { + { + setState(1433); + match(Ampersand); + } + } + + setState(1436); + match(OpenRoundBracket); + setState(1437); + formalParameterList(); + setState(1438); + match(CloseRoundBracket); + setState(1440); + _la = _input.LA(1); + if (_la==Use) { + { + setState(1439); + lambdaFunctionUseVars(); + } + } + + setState(1444); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1442); + match(Colon); + setState(1443); + typeHint(0); + } + } + + setState(1446); + blockStatement(); + } + break; + case LambdaFn: + enterOuterAlt(_localctx, 2); + { + setState(1448); + match(LambdaFn); + setState(1449); + match(OpenRoundBracket); + setState(1450); + formalParameterList(); + setState(1451); + match(CloseRoundBracket); + setState(1452); + match(DoubleArrow); + setState(1453); + expression(0); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MatchExprContext extends ParserRuleContext { + public TerminalNode Match_() { return getToken(PhpParser.Match_, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public List<MatchItemContext> matchItem() { + return getRuleContexts(MatchItemContext.class); + } + public MatchItemContext matchItem(int i) { + return getRuleContext(MatchItemContext.class,i); + } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public MatchExprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_matchExpr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMatchExpr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMatchExpr(this); + } + } + + public final MatchExprContext matchExpr() throws RecognitionException { + MatchExprContext _localctx = new MatchExprContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_matchExpr); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1457); + match(Match_); + setState(1458); + match(OpenRoundBracket); + setState(1459); + expression(0); + setState(1460); + match(CloseRoundBracket); + setState(1461); + match(OpenCurlyBracket); + setState(1462); + matchItem(); + setState(1467); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,165,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1463); + match(Comma); + setState(1464); + matchItem(); + } + } + } + setState(1469); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,165,_ctx); + } + setState(1471); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1470); + match(Comma); + } + } + + setState(1473); + match(CloseCurlyBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MatchItemContext extends ParserRuleContext { + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public MatchItemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_matchItem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMatchItem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMatchItem(this); + } + } + + public final MatchItemContext matchItem() throws RecognitionException { + MatchItemContext _localctx = new MatchItemContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_matchItem); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1475); + expression(0); + setState(1480); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1476); + match(Comma); + setState(1477); + expression(0); + } + } + setState(1482); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1483); + match(DoubleArrow); + setState(1484); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NewExprContext extends ParserRuleContext { + public TerminalNode New() { return getToken(PhpParser.New, 0); } + public TypeRefContext typeRef() { + return getRuleContext(TypeRefContext.class,0); + } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public NewExprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_newExpr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNewExpr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNewExpr(this); + } + } + + public final NewExprContext newExpr() throws RecognitionException { + NewExprContext _localctx = new NewExprContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_newExpr); + try { + enterOuterAlt(_localctx, 1); + { + setState(1486); + match(New); + setState(1487); + typeRef(); + setState(1489); + switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) { + case 1: + { + setState(1488); + arguments(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignmentOperatorContext extends ParserRuleContext { + public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); } + public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentOperator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAssignmentOperator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAssignmentOperator(this); + } + } + + public final AssignmentOperatorContext assignmentOperator() throws RecognitionException { + AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_assignmentOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1491); + _la = _input.LA(1); + if ( !(((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & ((1L << (PlusEqual - 173)) | (1L << (MinusEqual - 173)) | (1L << (MulEqual - 173)) | (1L << (PowEqual - 173)) | (1L << (DivEqual - 173)) | (1L << (Concaequal - 173)) | (1L << (ModEqual - 173)) | (1L << (ShiftLeftEqual - 173)) | (1L << (ShiftRightEqual - 173)) | (1L << (AndEqual - 173)) | (1L << (OrEqual - 173)) | (1L << (XorEqual - 173)) | (1L << (NullCoalescingEqual - 173)) | (1L << (Eq - 173)))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class YieldExpressionContext extends ParserRuleContext { + public TerminalNode Yield() { return getToken(PhpParser.Yield, 0); } + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode From() { return getToken(PhpParser.From, 0); } + public YieldExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_yieldExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterYieldExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitYieldExpression(this); + } + } + + public final YieldExpressionContext yieldExpression() throws RecognitionException { + YieldExpressionContext _localctx = new YieldExpressionContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_yieldExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1493); + match(Yield); + setState(1501); + switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) { + case 1: + { + setState(1494); + expression(0); + setState(1497); + _la = _input.LA(1); + if (_la==DoubleArrow) { + { + setState(1495); + match(DoubleArrow); + setState(1496); + expression(0); + } + } + + } + break; + case 2: + { + setState(1499); + match(From); + setState(1500); + expression(0); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayItemListContext extends ParserRuleContext { + public List<ArrayItemContext> arrayItem() { + return getRuleContexts(ArrayItemContext.class); + } + public ArrayItemContext arrayItem(int i) { + return getRuleContext(ArrayItemContext.class,i); + } + public ArrayItemListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayItemList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayItemList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayItemList(this); + } + } + + public final ArrayItemListContext arrayItemList() throws RecognitionException { + ArrayItemListContext _localctx = new ArrayItemListContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_arrayItemList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1503); + arrayItem(); + setState(1508); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,171,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1504); + match(Comma); + setState(1505); + arrayItem(); + } + } + } + setState(1510); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,171,_ctx); + } + setState(1512); + switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) { + case 1: + { + setState(1511); + match(Comma); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayItemContext extends ParserRuleContext { + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public ArrayItemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayItem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayItem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayItem(this); + } + } + + public final ArrayItemContext arrayItem() throws RecognitionException { + ArrayItemContext _localctx = new ArrayItemContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_arrayItem); + int _la; + try { + setState(1526); + switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1514); + expression(0); + setState(1517); + _la = _input.LA(1); + if (_la==DoubleArrow) { + { + setState(1515); + match(DoubleArrow); + setState(1516); + expression(0); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1522); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(1519); + expression(0); + setState(1520); + match(DoubleArrow); + } + } + + setState(1524); + match(Ampersand); + setState(1525); + chain(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaFunctionUseVarsContext extends ParserRuleContext { + public TerminalNode Use() { return getToken(PhpParser.Use, 0); } + public List<LambdaFunctionUseVarContext> lambdaFunctionUseVar() { + return getRuleContexts(LambdaFunctionUseVarContext.class); + } + public LambdaFunctionUseVarContext lambdaFunctionUseVar(int i) { + return getRuleContext(LambdaFunctionUseVarContext.class,i); + } + public LambdaFunctionUseVarsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaFunctionUseVars; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLambdaFunctionUseVars(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLambdaFunctionUseVars(this); + } + } + + public final LambdaFunctionUseVarsContext lambdaFunctionUseVars() throws RecognitionException { + LambdaFunctionUseVarsContext _localctx = new LambdaFunctionUseVarsContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_lambdaFunctionUseVars); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1528); + match(Use); + setState(1529); + match(OpenRoundBracket); + setState(1530); + lambdaFunctionUseVar(); + setState(1535); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1531); + match(Comma); + setState(1532); + lambdaFunctionUseVar(); + } + } + setState(1537); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1538); + match(CloseRoundBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaFunctionUseVarContext extends ParserRuleContext { + public TerminalNode VarName() { return getToken(PhpParser.VarName, 0); } + public LambdaFunctionUseVarContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaFunctionUseVar; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLambdaFunctionUseVar(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLambdaFunctionUseVar(this); + } + } + + public final LambdaFunctionUseVarContext lambdaFunctionUseVar() throws RecognitionException { + LambdaFunctionUseVarContext _localctx = new LambdaFunctionUseVarContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_lambdaFunctionUseVar); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1541); + _la = _input.LA(1); + if (_la==Ampersand) { + { + setState(1540); + match(Ampersand); + } + } + + setState(1543); + match(VarName); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class QualifiedStaticTypeRefContext extends ParserRuleContext { + public QualifiedNamespaceNameContext qualifiedNamespaceName() { + return getRuleContext(QualifiedNamespaceNameContext.class,0); + } + public GenericDynamicArgsContext genericDynamicArgs() { + return getRuleContext(GenericDynamicArgsContext.class,0); + } + public TerminalNode Static() { return getToken(PhpParser.Static, 0); } + public QualifiedStaticTypeRefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualifiedStaticTypeRef; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterQualifiedStaticTypeRef(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitQualifiedStaticTypeRef(this); + } + } + + public final QualifiedStaticTypeRefContext qualifiedStaticTypeRef() throws RecognitionException { + QualifiedStaticTypeRefContext _localctx = new QualifiedStaticTypeRefContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_qualifiedStaticTypeRef); + try { + setState(1550); + switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1545); + qualifiedNamespaceName(); + setState(1547); + switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) { + case 1: + { + setState(1546); + genericDynamicArgs(); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1549); + match(Static); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeRefContext extends ParserRuleContext { + public QualifiedNamespaceNameContext qualifiedNamespaceName() { + return getRuleContext(QualifiedNamespaceNameContext.class,0); + } + public IndirectTypeRefContext indirectTypeRef() { + return getRuleContext(IndirectTypeRefContext.class,0); + } + public GenericDynamicArgsContext genericDynamicArgs() { + return getRuleContext(GenericDynamicArgsContext.class,0); + } + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public TerminalNode Static() { return getToken(PhpParser.Static, 0); } + public AnonymousClassContext anonymousClass() { + return getRuleContext(AnonymousClassContext.class,0); + } + public TypeRefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeRef; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeRef(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeRef(this); + } + } + + public final TypeRefContext typeRef() throws RecognitionException { + TypeRefContext _localctx = new TypeRefContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_typeRef); + try { + setState(1562); + switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1554); + switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) { + case 1: + { + setState(1552); + qualifiedNamespaceName(); + } + break; + case 2: + { + setState(1553); + indirectTypeRef(); + } + break; + } + setState(1557); + switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) { + case 1: + { + setState(1556); + genericDynamicArgs(); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1559); + primitiveType(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1560); + match(Static); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1561); + anonymousClass(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnonymousClassContext extends ParserRuleContext { + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public ClassEntryTypeContext classEntryType() { + return getRuleContext(ClassEntryTypeContext.class,0); + } + public TerminalNode Interface() { return getToken(PhpParser.Interface, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AttributesContext attributes() { + return getRuleContext(AttributesContext.class,0); + } + public TerminalNode Private() { return getToken(PhpParser.Private, 0); } + public ModifierContext modifier() { + return getRuleContext(ModifierContext.class,0); + } + public TerminalNode Partial() { return getToken(PhpParser.Partial, 0); } + public List<ClassStatementContext> classStatement() { + return getRuleContexts(ClassStatementContext.class); + } + public ClassStatementContext classStatement(int i) { + return getRuleContext(ClassStatementContext.class,i); + } + public TypeParameterListInBracketsContext typeParameterListInBrackets() { + return getRuleContext(TypeParameterListInBracketsContext.class,0); + } + public TerminalNode Extends() { return getToken(PhpParser.Extends, 0); } + public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() { + return getRuleContext(QualifiedStaticTypeRefContext.class,0); + } + public TerminalNode Implements() { return getToken(PhpParser.Implements, 0); } + public InterfaceListContext interfaceList() { + return getRuleContext(InterfaceListContext.class,0); + } + public AnonymousClassContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_anonymousClass; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAnonymousClass(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAnonymousClass(this); + } + } + + public final AnonymousClassContext anonymousClass() throws RecognitionException { + AnonymousClassContext _localctx = new AnonymousClassContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_anonymousClass); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1565); + _la = _input.LA(1); + if (_la==AttributeStart) { + { + setState(1564); + attributes(); + } + } + + setState(1568); + _la = _input.LA(1); + if (_la==Private) { + { + setState(1567); + match(Private); + } + } + + setState(1571); + _la = _input.LA(1); + if (_la==Abstract || _la==Final) { + { + setState(1570); + modifier(); + } + } + + setState(1574); + _la = _input.LA(1); + if (_la==Partial) { + { + setState(1573); + match(Partial); + } + } + + setState(1597); + switch (_input.LA(1)) { + case Class: + case Trait: + { + setState(1576); + classEntryType(); + setState(1578); + _la = _input.LA(1); + if (_la==Lgeneric) { + { + setState(1577); + typeParameterListInBrackets(); + } + } + + setState(1582); + _la = _input.LA(1); + if (_la==Extends) { + { + setState(1580); + match(Extends); + setState(1581); + qualifiedStaticTypeRef(); + } + } + + setState(1586); + _la = _input.LA(1); + if (_la==Implements) { + { + setState(1584); + match(Implements); + setState(1585); + interfaceList(); + } + } + + } + break; + case Interface: + { + setState(1588); + match(Interface); + setState(1589); + identifier(); + setState(1591); + _la = _input.LA(1); + if (_la==Lgeneric) { + { + setState(1590); + typeParameterListInBrackets(); + } + } + + setState(1595); + _la = _input.LA(1); + if (_la==Extends) { + { + setState(1593); + match(Extends); + setState(1594); + interfaceList(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + setState(1599); + match(OpenCurlyBracket); + setState(1603); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AttributeStart) | (1L << Abstract) | (1L << Const))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Function_ - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)) | (1L << (Use - 77)) | (1L << (Var - 77)))) != 0)) { + { + { + setState(1600); + classStatement(); + } + } + setState(1605); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1606); + match(CloseCurlyBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IndirectTypeRefContext extends ParserRuleContext { + public ChainBaseContext chainBase() { + return getRuleContext(ChainBaseContext.class,0); + } + public List<KeyedFieldNameContext> keyedFieldName() { + return getRuleContexts(KeyedFieldNameContext.class); + } + public KeyedFieldNameContext keyedFieldName(int i) { + return getRuleContext(KeyedFieldNameContext.class,i); + } + public IndirectTypeRefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_indirectTypeRef; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIndirectTypeRef(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIndirectTypeRef(this); + } + } + + public final IndirectTypeRefContext indirectTypeRef() throws RecognitionException { + IndirectTypeRefContext _localctx = new IndirectTypeRefContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_indirectTypeRef); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1608); + chainBase(); + setState(1613); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,194,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1609); + match(ObjectOperator); + setState(1610); + keyedFieldName(); + } + } + } + setState(1615); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,194,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class QualifiedNamespaceNameContext extends ParserRuleContext { + public NamespaceNameListContext namespaceNameList() { + return getRuleContext(NamespaceNameListContext.class,0); + } + public TerminalNode Namespace() { return getToken(PhpParser.Namespace, 0); } + public QualifiedNamespaceNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualifiedNamespaceName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterQualifiedNamespaceName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitQualifiedNamespaceName(this); + } + } + + public final QualifiedNamespaceNameContext qualifiedNamespaceName() throws RecognitionException { + QualifiedNamespaceNameContext _localctx = new QualifiedNamespaceNameContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_qualifiedNamespaceName); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1617); + switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) { + case 1: + { + setState(1616); + match(Namespace); + } + break; + } + setState(1620); + _la = _input.LA(1); + if (_la==NamespaceSeparator) { + { + setState(1619); + match(NamespaceSeparator); + } + } + + setState(1622); + namespaceNameList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NamespaceNameListContext extends ParserRuleContext { + public List<IdentifierContext> identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public NamespaceNameTailContext namespaceNameTail() { + return getRuleContext(NamespaceNameTailContext.class,0); + } + public NamespaceNameListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespaceNameList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNamespaceNameList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNamespaceNameList(this); + } + } + + public final NamespaceNameListContext namespaceNameList() throws RecognitionException { + NamespaceNameListContext _localctx = new NamespaceNameListContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_namespaceNameList); + try { + int _alt; + setState(1637); + switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1624); + identifier(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1625); + identifier(); + setState(1630); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,197,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1626); + match(NamespaceSeparator); + setState(1627); + identifier(); + } + } + } + setState(1632); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,197,_ctx); + } + setState(1635); + switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) { + case 1: + { + setState(1633); + match(NamespaceSeparator); + setState(1634); + namespaceNameTail(); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NamespaceNameTailContext extends ParserRuleContext { + public List<IdentifierContext> identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public TerminalNode As() { return getToken(PhpParser.As, 0); } + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public List<NamespaceNameTailContext> namespaceNameTail() { + return getRuleContexts(NamespaceNameTailContext.class); + } + public NamespaceNameTailContext namespaceNameTail(int i) { + return getRuleContext(NamespaceNameTailContext.class,i); + } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public NamespaceNameTailContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespaceNameTail; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNamespaceNameTail(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNamespaceNameTail(this); + } + } + + public final NamespaceNameTailContext namespaceNameTail() throws RecognitionException { + NamespaceNameTailContext _localctx = new NamespaceNameTailContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_namespaceNameTail); + int _la; + try { + int _alt; + setState(1658); + switch (_input.LA(1)) { + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case Label: + enterOuterAlt(_localctx, 1); + { + setState(1639); + identifier(); + setState(1642); + switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) { + case 1: + { + setState(1640); + match(As); + setState(1641); + identifier(); + } + break; + } + } + break; + case OpenCurlyBracket: + enterOuterAlt(_localctx, 2); + { + setState(1644); + match(OpenCurlyBracket); + setState(1645); + namespaceNameTail(); + setState(1650); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,201,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1646); + match(Comma); + setState(1647); + namespaceNameTail(); + } + } + } + setState(1652); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,201,_ctx); + } + setState(1654); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1653); + match(Comma); + } + } + + setState(1656); + match(CloseCurlyBracket); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class QualifiedNamespaceNameListContext extends ParserRuleContext { + public List<QualifiedNamespaceNameContext> qualifiedNamespaceName() { + return getRuleContexts(QualifiedNamespaceNameContext.class); + } + public QualifiedNamespaceNameContext qualifiedNamespaceName(int i) { + return getRuleContext(QualifiedNamespaceNameContext.class,i); + } + public QualifiedNamespaceNameListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualifiedNamespaceNameList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterQualifiedNamespaceNameList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitQualifiedNamespaceNameList(this); + } + } + + public final QualifiedNamespaceNameListContext qualifiedNamespaceNameList() throws RecognitionException { + QualifiedNamespaceNameListContext _localctx = new QualifiedNamespaceNameListContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_qualifiedNamespaceNameList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1660); + qualifiedNamespaceName(); + setState(1665); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1661); + match(Comma); + setState(1662); + qualifiedNamespaceName(); + } + } + setState(1667); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArgumentsContext extends ParserRuleContext { + public List<ActualArgumentContext> actualArgument() { + return getRuleContexts(ActualArgumentContext.class); + } + public ActualArgumentContext actualArgument(int i) { + return getRuleContext(ActualArgumentContext.class,i); + } + public YieldExpressionContext yieldExpression() { + return getRuleContext(YieldExpressionContext.class,0); + } + public ArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arguments; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArguments(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArguments(this); + } + } + + public final ArgumentsContext arguments() throws RecognitionException { + ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_arguments); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1668); + match(OpenRoundBracket); + setState(1678); + switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) { + case 1: + { + setState(1669); + actualArgument(); + setState(1674); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,205,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1670); + match(Comma); + setState(1671); + actualArgument(); + } + } + } + setState(1676); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,205,_ctx); + } + } + break; + case 2: + { + setState(1677); + yieldExpression(); + } + break; + } + setState(1681); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1680); + match(Comma); + } + } + + setState(1683); + match(CloseRoundBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ActualArgumentContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ArgumentNameContext argumentName() { + return getRuleContext(ArgumentNameContext.class,0); + } + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public ActualArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_actualArgument; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterActualArgument(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitActualArgument(this); + } + } + + public final ActualArgumentContext actualArgument() throws RecognitionException { + ActualArgumentContext _localctx = new ActualArgumentContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_actualArgument); + int _la; + try { + setState(1694); + switch (_input.LA(1)) { + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case Inc: + case Dec: + case NamespaceSeparator: + case Ellipsis: + case Bang: + case Plus: + case Minus: + case Tilde: + case SuppressWarnings: + case Dollar: + case OpenRoundBracket: + case OpenSquareBracket: + case VarName: + case Label: + case Octal: + case Decimal: + case Real: + case Hex: + case Binary: + case BackQuoteString: + case SingleQuoteString: + case DoubleQuote: + case StartNowDoc: + case StartHereDoc: + enterOuterAlt(_localctx, 1); + { + setState(1686); + switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) { + case 1: + { + setState(1685); + argumentName(); + } + break; + } + setState(1689); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1688); + match(Ellipsis); + } + } + + setState(1691); + expression(0); + } + break; + case Ampersand: + enterOuterAlt(_localctx, 2); + { + setState(1692); + match(Ampersand); + setState(1693); + chain(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArgumentNameContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public ArgumentNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_argumentName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArgumentName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArgumentName(this); + } + } + + public final ArgumentNameContext argumentName() throws RecognitionException { + ArgumentNameContext _localctx = new ArgumentNameContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_argumentName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1696); + identifier(); + setState(1697); + match(Colon); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstantInitializerContext extends ParserRuleContext { + public List<ConstantContext> constant() { + return getRuleContexts(ConstantContext.class); + } + public ConstantContext constant(int i) { + return getRuleContext(ConstantContext.class,i); + } + public List<StringContext> string() { + return getRuleContexts(StringContext.class); + } + public StringContext string(int i) { + return getRuleContext(StringContext.class,i); + } + public TerminalNode Array() { return getToken(PhpParser.Array, 0); } + public ArrayItemListContext arrayItemList() { + return getRuleContext(ArrayItemListContext.class,0); + } + public ConstantInitializerContext constantInitializer() { + return getRuleContext(ConstantInitializerContext.class,0); + } + public ConstantInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constantInitializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterConstantInitializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitConstantInitializer(this); + } + } + + public final ConstantInitializerContext constantInitializer() throws RecognitionException { + ConstantInitializerContext _localctx = new ConstantInitializerContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_constantInitializer); + int _la; + try { + setState(1734); + switch ( getInterpreter().adaptivePredict(_input,218,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1699); + constant(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1700); + string(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1701); + match(Array); + setState(1702); + match(OpenRoundBracket); + setState(1707); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(1703); + arrayItemList(); + setState(1705); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1704); + match(Comma); + } + } + + } + } + + setState(1709); + match(CloseRoundBracket); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1710); + match(OpenSquareBracket); + setState(1715); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(1711); + arrayItemList(); + setState(1713); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1712); + match(Comma); + } + } + + } + } + + setState(1717); + match(CloseSquareBracket); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1718); + _la = _input.LA(1); + if ( !(_la==Plus || _la==Minus) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + setState(1719); + constantInitializer(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1722); + switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) { + case 1: + { + setState(1720); + string(); + } + break; + case 2: + { + setState(1721); + constant(); + } + break; + } + setState(1731); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Dot) { + { + { + setState(1724); + match(Dot); + setState(1727); + switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) { + case 1: + { + setState(1725); + string(); + } + break; + case 2: + { + setState(1726); + constant(); + } + break; + } + } + } + setState(1733); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstantContext extends ParserRuleContext { + public TerminalNode Null() { return getToken(PhpParser.Null, 0); } + public LiteralConstantContext literalConstant() { + return getRuleContext(LiteralConstantContext.class,0); + } + public MagicConstantContext magicConstant() { + return getRuleContext(MagicConstantContext.class,0); + } + public ClassConstantContext classConstant() { + return getRuleContext(ClassConstantContext.class,0); + } + public QualifiedNamespaceNameContext qualifiedNamespaceName() { + return getRuleContext(QualifiedNamespaceNameContext.class,0); + } + public ConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constant; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterConstant(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitConstant(this); + } + } + + public final ConstantContext constant() throws RecognitionException { + ConstantContext _localctx = new ConstantContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_constant); + try { + setState(1741); + switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1736); + match(Null); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1737); + literalConstant(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1738); + magicConstant(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1739); + classConstant(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1740); + qualifiedNamespaceName(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LiteralConstantContext extends ParserRuleContext { + public TerminalNode Real() { return getToken(PhpParser.Real, 0); } + public TerminalNode BooleanConstant() { return getToken(PhpParser.BooleanConstant, 0); } + public NumericConstantContext numericConstant() { + return getRuleContext(NumericConstantContext.class,0); + } + public StringConstantContext stringConstant() { + return getRuleContext(StringConstantContext.class,0); + } + public LiteralConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literalConstant; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLiteralConstant(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLiteralConstant(this); + } + } + + public final LiteralConstantContext literalConstant() throws RecognitionException { + LiteralConstantContext _localctx = new LiteralConstantContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_literalConstant); + try { + setState(1747); + switch (_input.LA(1)) { + case Real: + enterOuterAlt(_localctx, 1); + { + setState(1743); + match(Real); + } + break; + case BooleanConstant: + enterOuterAlt(_localctx, 2); + { + setState(1744); + match(BooleanConstant); + } + break; + case Octal: + case Decimal: + case Hex: + case Binary: + enterOuterAlt(_localctx, 3); + { + setState(1745); + numericConstant(); + } + break; + case Label: + enterOuterAlt(_localctx, 4); + { + setState(1746); + stringConstant(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NumericConstantContext extends ParserRuleContext { + public TerminalNode Octal() { return getToken(PhpParser.Octal, 0); } + public TerminalNode Decimal() { return getToken(PhpParser.Decimal, 0); } + public TerminalNode Hex() { return getToken(PhpParser.Hex, 0); } + public TerminalNode Binary() { return getToken(PhpParser.Binary, 0); } + public NumericConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_numericConstant; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNumericConstant(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNumericConstant(this); + } + } + + public final NumericConstantContext numericConstant() throws RecognitionException { + NumericConstantContext _localctx = new NumericConstantContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_numericConstant); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1749); + _la = _input.LA(1); + if ( !(((((_la - 226)) & ~0x3f) == 0 && ((1L << (_la - 226)) & ((1L << (Octal - 226)) | (1L << (Decimal - 226)) | (1L << (Hex - 226)) | (1L << (Binary - 226)))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassConstantContext extends ParserRuleContext { + public TerminalNode Class() { return getToken(PhpParser.Class, 0); } + public TerminalNode Parent_() { return getToken(PhpParser.Parent_, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode Constructor() { return getToken(PhpParser.Constructor, 0); } + public TerminalNode Get() { return getToken(PhpParser.Get, 0); } + public TerminalNode Set() { return getToken(PhpParser.Set, 0); } + public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() { + return getRuleContext(QualifiedStaticTypeRefContext.class,0); + } + public List<KeyedVariableContext> keyedVariable() { + return getRuleContexts(KeyedVariableContext.class); + } + public KeyedVariableContext keyedVariable(int i) { + return getRuleContext(KeyedVariableContext.class,i); + } + public StringContext string() { + return getRuleContext(StringContext.class,0); + } + public ClassConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classConstant; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterClassConstant(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitClassConstant(this); + } + } + + public final ClassConstantContext classConstant() throws RecognitionException { + ClassConstantContext _localctx = new ClassConstantContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_classConstant); + int _la; + try { + setState(1769); + switch ( getInterpreter().adaptivePredict(_input,224,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1751); + _la = _input.LA(1); + if ( !(_la==Class || _la==Parent_) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + setState(1752); + match(DoubleColon); + setState(1757); + switch ( getInterpreter().adaptivePredict(_input,221,_ctx) ) { + case 1: + { + setState(1753); + identifier(); + } + break; + case 2: + { + setState(1754); + match(Constructor); + } + break; + case 3: + { + setState(1755); + match(Get); + } + break; + case 4: + { + setState(1756); + match(Set); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1762); + switch (_input.LA(1)) { + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case NamespaceSeparator: + case Label: + { + setState(1759); + qualifiedStaticTypeRef(); + } + break; + case Dollar: + case VarName: + { + setState(1760); + keyedVariable(); + } + break; + case SingleQuoteString: + case DoubleQuote: + case StartNowDoc: + case StartHereDoc: + { + setState(1761); + string(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1764); + match(DoubleColon); + setState(1767); + switch (_input.LA(1)) { + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case Label: + { + setState(1765); + identifier(); + } + break; + case Dollar: + case VarName: + { + setState(1766); + keyedVariable(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StringConstantContext extends ParserRuleContext { + public TerminalNode Label() { return getToken(PhpParser.Label, 0); } + public StringConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stringConstant; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterStringConstant(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitStringConstant(this); + } + } + + public final StringConstantContext stringConstant() throws RecognitionException { + StringConstantContext _localctx = new StringConstantContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_stringConstant); + try { + enterOuterAlt(_localctx, 1); + { + setState(1771); + match(Label); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StringContext extends ParserRuleContext { + public TerminalNode StartHereDoc() { return getToken(PhpParser.StartHereDoc, 0); } + public List<TerminalNode> HereDocText() { return getTokens(PhpParser.HereDocText); } + public TerminalNode HereDocText(int i) { + return getToken(PhpParser.HereDocText, i); + } + public TerminalNode StartNowDoc() { return getToken(PhpParser.StartNowDoc, 0); } + public TerminalNode SingleQuoteString() { return getToken(PhpParser.SingleQuoteString, 0); } + public List<TerminalNode> DoubleQuote() { return getTokens(PhpParser.DoubleQuote); } + public TerminalNode DoubleQuote(int i) { + return getToken(PhpParser.DoubleQuote, i); + } + public List<InterpolatedStringPartContext> interpolatedStringPart() { + return getRuleContexts(InterpolatedStringPartContext.class); + } + public InterpolatedStringPartContext interpolatedStringPart(int i) { + return getRuleContext(InterpolatedStringPartContext.class,i); + } + public StringContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_string; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterString(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitString(this); + } + } + + public final StringContext string() throws RecognitionException { + StringContext _localctx = new StringContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_string); + try { + int _alt; + setState(1794); + switch (_input.LA(1)) { + case StartHereDoc: + enterOuterAlt(_localctx, 1); + { + setState(1773); + match(StartHereDoc); + setState(1775); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1774); + match(HereDocText); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1777); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,225,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + break; + case StartNowDoc: + enterOuterAlt(_localctx, 2); + { + setState(1779); + match(StartNowDoc); + setState(1781); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1780); + match(HereDocText); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1783); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,226,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + break; + case SingleQuoteString: + enterOuterAlt(_localctx, 3); + { + setState(1785); + match(SingleQuoteString); + } + break; + case DoubleQuote: + enterOuterAlt(_localctx, 4); + { + setState(1786); + match(DoubleQuote); + setState(1790); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,227,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1787); + interpolatedStringPart(); + } + } + } + setState(1792); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,227,_ctx); + } + setState(1793); + match(DoubleQuote); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterpolatedStringPartContext extends ParserRuleContext { + public TerminalNode StringPart() { return getToken(PhpParser.StringPart, 0); } + public TerminalNode UnicodeEscape() { return getToken(PhpParser.UnicodeEscape, 0); } + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public InterpolatedStringPartContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interpolatedStringPart; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInterpolatedStringPart(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInterpolatedStringPart(this); + } + } + + public final InterpolatedStringPartContext interpolatedStringPart() throws RecognitionException { + InterpolatedStringPartContext _localctx = new InterpolatedStringPartContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_interpolatedStringPart); + try { + setState(1799); + switch (_input.LA(1)) { + case StringPart: + enterOuterAlt(_localctx, 1); + { + setState(1796); + match(StringPart); + } + break; + case UnicodeEscape: + enterOuterAlt(_localctx, 2); + { + setState(1797); + match(UnicodeEscape); + } + break; + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case NamespaceSeparator: + case Dollar: + case OpenRoundBracket: + case VarName: + case Label: + case SingleQuoteString: + case DoubleQuote: + case StartNowDoc: + case StartHereDoc: + enterOuterAlt(_localctx, 3); + { + setState(1798); + chain(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ChainListContext extends ParserRuleContext { + public List<ChainContext> chain() { + return getRuleContexts(ChainContext.class); + } + public ChainContext chain(int i) { + return getRuleContext(ChainContext.class,i); + } + public ChainListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_chainList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterChainList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitChainList(this); + } + } + + public final ChainListContext chainList() throws RecognitionException { + ChainListContext _localctx = new ChainListContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_chainList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1801); + chain(); + setState(1806); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1802); + match(Comma); + setState(1803); + chain(); + } + } + setState(1808); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ChainContext extends ParserRuleContext { + public ChainOriginContext chainOrigin() { + return getRuleContext(ChainOriginContext.class,0); + } + public List<MemberAccessContext> memberAccess() { + return getRuleContexts(MemberAccessContext.class); + } + public MemberAccessContext memberAccess(int i) { + return getRuleContext(MemberAccessContext.class,i); + } + public ChainContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_chain; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterChain(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitChain(this); + } + } + + public final ChainContext chain() throws RecognitionException { + ChainContext _localctx = new ChainContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_chain); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1809); + chainOrigin(); + setState(1813); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,231,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1810); + memberAccess(); + } + } + } + setState(1815); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,231,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ChainOriginContext extends ParserRuleContext { + public ChainBaseContext chainBase() { + return getRuleContext(ChainBaseContext.class,0); + } + public FunctionCallContext functionCall() { + return getRuleContext(FunctionCallContext.class,0); + } + public NewExprContext newExpr() { + return getRuleContext(NewExprContext.class,0); + } + public ChainOriginContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_chainOrigin; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterChainOrigin(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitChainOrigin(this); + } + } + + public final ChainOriginContext chainOrigin() throws RecognitionException { + ChainOriginContext _localctx = new ChainOriginContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_chainOrigin); + try { + setState(1822); + switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1816); + chainBase(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1817); + functionCall(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1818); + match(OpenRoundBracket); + setState(1819); + newExpr(); + setState(1820); + match(CloseRoundBracket); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MemberAccessContext extends ParserRuleContext { + public KeyedFieldNameContext keyedFieldName() { + return getRuleContext(KeyedFieldNameContext.class,0); + } + public ActualArgumentsContext actualArguments() { + return getRuleContext(ActualArgumentsContext.class,0); + } + public MemberAccessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memberAccess; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMemberAccess(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMemberAccess(this); + } + } + + public final MemberAccessContext memberAccess() throws RecognitionException { + MemberAccessContext _localctx = new MemberAccessContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_memberAccess); + try { + enterOuterAlt(_localctx, 1); + { + setState(1824); + match(ObjectOperator); + setState(1825); + keyedFieldName(); + setState(1827); + switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) { + case 1: + { + setState(1826); + actualArguments(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FunctionCallContext extends ParserRuleContext { + public FunctionCallNameContext functionCallName() { + return getRuleContext(FunctionCallNameContext.class,0); + } + public ActualArgumentsContext actualArguments() { + return getRuleContext(ActualArgumentsContext.class,0); + } + public FunctionCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionCall; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFunctionCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFunctionCall(this); + } + } + + public final FunctionCallContext functionCall() throws RecognitionException { + FunctionCallContext _localctx = new FunctionCallContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_functionCall); + try { + enterOuterAlt(_localctx, 1); + { + setState(1829); + functionCallName(); + setState(1830); + actualArguments(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FunctionCallNameContext extends ParserRuleContext { + public QualifiedNamespaceNameContext qualifiedNamespaceName() { + return getRuleContext(QualifiedNamespaceNameContext.class,0); + } + public ClassConstantContext classConstant() { + return getRuleContext(ClassConstantContext.class,0); + } + public ChainBaseContext chainBase() { + return getRuleContext(ChainBaseContext.class,0); + } + public ParenthesesContext parentheses() { + return getRuleContext(ParenthesesContext.class,0); + } + public FunctionCallNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionCallName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFunctionCallName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFunctionCallName(this); + } + } + + public final FunctionCallNameContext functionCallName() throws RecognitionException { + FunctionCallNameContext _localctx = new FunctionCallNameContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_functionCallName); + try { + setState(1836); + switch ( getInterpreter().adaptivePredict(_input,234,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1832); + qualifiedNamespaceName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1833); + classConstant(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1834); + chainBase(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1835); + parentheses(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ActualArgumentsContext extends ParserRuleContext { + public GenericDynamicArgsContext genericDynamicArgs() { + return getRuleContext(GenericDynamicArgsContext.class,0); + } + public List<ArgumentsContext> arguments() { + return getRuleContexts(ArgumentsContext.class); + } + public ArgumentsContext arguments(int i) { + return getRuleContext(ArgumentsContext.class,i); + } + public List<SquareCurlyExpressionContext> squareCurlyExpression() { + return getRuleContexts(SquareCurlyExpressionContext.class); + } + public SquareCurlyExpressionContext squareCurlyExpression(int i) { + return getRuleContext(SquareCurlyExpressionContext.class,i); + } + public ActualArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_actualArguments; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterActualArguments(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitActualArguments(this); + } + } + + public final ActualArgumentsContext actualArguments() throws RecognitionException { + ActualArgumentsContext _localctx = new ActualArgumentsContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_actualArguments); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1839); + _la = _input.LA(1); + if (_la==Lgeneric) { + { + setState(1838); + genericDynamicArgs(); + } + } + + setState(1842); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1841); + arguments(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1844); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,236,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(1849); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,237,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1846); + squareCurlyExpression(); + } + } + } + setState(1851); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,237,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ChainBaseContext extends ParserRuleContext { + public List<KeyedVariableContext> keyedVariable() { + return getRuleContexts(KeyedVariableContext.class); + } + public KeyedVariableContext keyedVariable(int i) { + return getRuleContext(KeyedVariableContext.class,i); + } + public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() { + return getRuleContext(QualifiedStaticTypeRefContext.class,0); + } + public ChainBaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_chainBase; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterChainBase(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitChainBase(this); + } + } + + public final ChainBaseContext chainBase() throws RecognitionException { + ChainBaseContext _localctx = new ChainBaseContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_chainBase); + try { + setState(1861); + switch (_input.LA(1)) { + case Dollar: + case VarName: + enterOuterAlt(_localctx, 1); + { + setState(1852); + keyedVariable(); + setState(1855); + switch ( getInterpreter().adaptivePredict(_input,238,_ctx) ) { + case 1: + { + setState(1853); + match(DoubleColon); + setState(1854); + keyedVariable(); + } + break; + } + } + break; + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case NamespaceSeparator: + case Label: + enterOuterAlt(_localctx, 2); + { + setState(1857); + qualifiedStaticTypeRef(); + setState(1858); + match(DoubleColon); + setState(1859); + keyedVariable(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class KeyedFieldNameContext extends ParserRuleContext { + public KeyedSimpleFieldNameContext keyedSimpleFieldName() { + return getRuleContext(KeyedSimpleFieldNameContext.class,0); + } + public KeyedVariableContext keyedVariable() { + return getRuleContext(KeyedVariableContext.class,0); + } + public KeyedFieldNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_keyedFieldName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterKeyedFieldName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitKeyedFieldName(this); + } + } + + public final KeyedFieldNameContext keyedFieldName() throws RecognitionException { + KeyedFieldNameContext _localctx = new KeyedFieldNameContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_keyedFieldName); + try { + setState(1865); + switch (_input.LA(1)) { + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case OpenCurlyBracket: + case Label: + enterOuterAlt(_localctx, 1); + { + setState(1863); + keyedSimpleFieldName(); + } + break; + case Dollar: + case VarName: + enterOuterAlt(_localctx, 2); + { + setState(1864); + keyedVariable(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class KeyedSimpleFieldNameContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public List<SquareCurlyExpressionContext> squareCurlyExpression() { + return getRuleContexts(SquareCurlyExpressionContext.class); + } + public SquareCurlyExpressionContext squareCurlyExpression(int i) { + return getRuleContext(SquareCurlyExpressionContext.class,i); + } + public KeyedSimpleFieldNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_keyedSimpleFieldName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterKeyedSimpleFieldName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitKeyedSimpleFieldName(this); + } + } + + public final KeyedSimpleFieldNameContext keyedSimpleFieldName() throws RecognitionException { + KeyedSimpleFieldNameContext _localctx = new KeyedSimpleFieldNameContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_keyedSimpleFieldName); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1872); + switch (_input.LA(1)) { + case Abstract: + case Array: + case As: + case BinaryCast: + case BoolType: + case BooleanConstant: + case Break: + case Callable: + case Case: + case Catch: + case Class: + case Clone: + case Const: + case Continue: + case Declare: + case Default: + case Do: + case DoubleCast: + case DoubleType: + case Echo: + case Else: + case ElseIf: + case Empty: + case Enum_: + case EndDeclare: + case EndFor: + case EndForeach: + case EndIf: + case EndSwitch: + case EndWhile: + case Eval: + case Exit: + case Extends: + case Final: + case Finally: + case FloatCast: + case For: + case Foreach: + case Function_: + case Global: + case Goto: + case If: + case Implements: + case Import: + case Include: + case IncludeOnce: + case InstanceOf: + case InsteadOf: + case Int8Cast: + case Int16Cast: + case Int64Type: + case IntType: + case Interface: + case IsSet: + case List: + case LogicalAnd: + case LogicalOr: + case LogicalXor: + case Match_: + case Namespace: + case New: + case Null: + case ObjectType: + case Parent_: + case Partial: + case Print: + case Private: + case Protected: + case Public: + case Readonly: + case Require: + case RequireOnce: + case Resource: + case Return: + case Static: + case StringType: + case Switch: + case Throw: + case Trait: + case Try: + case Typeof: + case UintCast: + case UnicodeCast: + case Unset: + case Use: + case Var: + case While: + case Yield: + case From: + case LambdaFn: + case Ticks: + case Encoding: + case StrictTypes: + case Get: + case Set: + case Call: + case CallStatic: + case Constructor: + case Destruct: + case Wakeup: + case Sleep: + case Autoload: + case IsSet__: + case Unset__: + case ToString__: + case Invoke: + case SetState: + case Clone__: + case DebugInfo: + case Namespace__: + case Class__: + case Traic__: + case Function__: + case Method__: + case Line__: + case File__: + case Dir__: + case Label: + { + setState(1867); + identifier(); + } + break; + case OpenCurlyBracket: + { + setState(1868); + match(OpenCurlyBracket); + setState(1869); + expression(0); + setState(1870); + match(CloseCurlyBracket); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1877); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,242,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1874); + squareCurlyExpression(); + } + } + } + setState(1879); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,242,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class KeyedVariableContext extends ParserRuleContext { + public TerminalNode VarName() { return getToken(PhpParser.VarName, 0); } + public List<TerminalNode> Dollar() { return getTokens(PhpParser.Dollar); } + public TerminalNode Dollar(int i) { + return getToken(PhpParser.Dollar, i); + } + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public List<SquareCurlyExpressionContext> squareCurlyExpression() { + return getRuleContexts(SquareCurlyExpressionContext.class); + } + public SquareCurlyExpressionContext squareCurlyExpression(int i) { + return getRuleContext(SquareCurlyExpressionContext.class,i); + } + public KeyedVariableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_keyedVariable; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterKeyedVariable(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitKeyedVariable(this); + } + } + + public final KeyedVariableContext keyedVariable() throws RecognitionException { + KeyedVariableContext _localctx = new KeyedVariableContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_keyedVariable); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1883); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,243,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1880); + match(Dollar); + } + } + } + setState(1885); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,243,_ctx); + } + setState(1892); + switch (_input.LA(1)) { + case VarName: + { + setState(1886); + match(VarName); + } + break; + case Dollar: + { + setState(1887); + match(Dollar); + setState(1888); + match(OpenCurlyBracket); + setState(1889); + expression(0); + setState(1890); + match(CloseCurlyBracket); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1897); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,245,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1894); + squareCurlyExpression(); + } + } + } + setState(1899); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,245,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SquareCurlyExpressionContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); } + public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); } + public SquareCurlyExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_squareCurlyExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterSquareCurlyExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitSquareCurlyExpression(this); + } + } + + public final SquareCurlyExpressionContext squareCurlyExpression() throws RecognitionException { + SquareCurlyExpressionContext _localctx = new SquareCurlyExpressionContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_squareCurlyExpression); + int _la; + try { + setState(1909); + switch (_input.LA(1)) { + case OpenSquareBracket: + enterOuterAlt(_localctx, 1); + { + setState(1900); + match(OpenSquareBracket); + setState(1902); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(1901); + expression(0); + } + } + + setState(1904); + match(CloseSquareBracket); + } + break; + case OpenCurlyBracket: + enterOuterAlt(_localctx, 2); + { + setState(1905); + match(OpenCurlyBracket); + setState(1906); + expression(0); + setState(1907); + match(CloseCurlyBracket); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignmentListContext extends ParserRuleContext { + public List<AssignmentListElementContext> assignmentListElement() { + return getRuleContexts(AssignmentListElementContext.class); + } + public AssignmentListElementContext assignmentListElement(int i) { + return getRuleContext(AssignmentListElementContext.class,i); + } + public AssignmentListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAssignmentList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAssignmentList(this); + } + } + + public final AssignmentListContext assignmentList() throws RecognitionException { + AssignmentListContext _localctx = new AssignmentListContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_assignmentList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1912); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(1911); + assignmentListElement(); + } + } + + setState(1920); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1914); + match(Comma); + setState(1916); + _la = _input.LA(1); + if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) { + { + setState(1915); + assignmentListElement(); + } + } + + } + } + setState(1922); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignmentListElementContext extends ParserRuleContext { + public ChainContext chain() { + return getRuleContext(ChainContext.class,0); + } + public TerminalNode List() { return getToken(PhpParser.List, 0); } + public AssignmentListContext assignmentList() { + return getRuleContext(AssignmentListContext.class,0); + } + public ArrayItemContext arrayItem() { + return getRuleContext(ArrayItemContext.class,0); + } + public AssignmentListElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentListElement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAssignmentListElement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAssignmentListElement(this); + } + } + + public final AssignmentListElementContext assignmentListElement() throws RecognitionException { + AssignmentListElementContext _localctx = new AssignmentListElementContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_assignmentListElement); + try { + setState(1930); + switch ( getInterpreter().adaptivePredict(_input,251,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1923); + chain(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1924); + match(List); + setState(1925); + match(OpenRoundBracket); + setState(1926); + assignmentList(); + setState(1927); + match(CloseRoundBracket); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1929); + arrayItem(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ModifierContext extends ParserRuleContext { + public TerminalNode Abstract() { return getToken(PhpParser.Abstract, 0); } + public TerminalNode Final() { return getToken(PhpParser.Final, 0); } + public ModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_modifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterModifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitModifier(this); + } + } + + public final ModifierContext modifier() throws RecognitionException { + ModifierContext _localctx = new ModifierContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_modifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1932); + _la = _input.LA(1); + if ( !(_la==Abstract || _la==Final) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IdentifierContext extends ParserRuleContext { + public TerminalNode Label() { return getToken(PhpParser.Label, 0); } + public TerminalNode Abstract() { return getToken(PhpParser.Abstract, 0); } + public TerminalNode Array() { return getToken(PhpParser.Array, 0); } + public TerminalNode As() { return getToken(PhpParser.As, 0); } + public TerminalNode BinaryCast() { return getToken(PhpParser.BinaryCast, 0); } + public TerminalNode BoolType() { return getToken(PhpParser.BoolType, 0); } + public TerminalNode BooleanConstant() { return getToken(PhpParser.BooleanConstant, 0); } + public TerminalNode Break() { return getToken(PhpParser.Break, 0); } + public TerminalNode Callable() { return getToken(PhpParser.Callable, 0); } + public TerminalNode Case() { return getToken(PhpParser.Case, 0); } + public TerminalNode Catch() { return getToken(PhpParser.Catch, 0); } + public TerminalNode Class() { return getToken(PhpParser.Class, 0); } + public TerminalNode Clone() { return getToken(PhpParser.Clone, 0); } + public TerminalNode Const() { return getToken(PhpParser.Const, 0); } + public TerminalNode Continue() { return getToken(PhpParser.Continue, 0); } + public TerminalNode Declare() { return getToken(PhpParser.Declare, 0); } + public TerminalNode Default() { return getToken(PhpParser.Default, 0); } + public TerminalNode Do() { return getToken(PhpParser.Do, 0); } + public TerminalNode DoubleCast() { return getToken(PhpParser.DoubleCast, 0); } + public TerminalNode DoubleType() { return getToken(PhpParser.DoubleType, 0); } + public TerminalNode Echo() { return getToken(PhpParser.Echo, 0); } + public TerminalNode Else() { return getToken(PhpParser.Else, 0); } + public TerminalNode ElseIf() { return getToken(PhpParser.ElseIf, 0); } + public TerminalNode Empty() { return getToken(PhpParser.Empty, 0); } + public TerminalNode EndDeclare() { return getToken(PhpParser.EndDeclare, 0); } + public TerminalNode EndFor() { return getToken(PhpParser.EndFor, 0); } + public TerminalNode EndForeach() { return getToken(PhpParser.EndForeach, 0); } + public TerminalNode EndIf() { return getToken(PhpParser.EndIf, 0); } + public TerminalNode EndSwitch() { return getToken(PhpParser.EndSwitch, 0); } + public TerminalNode EndWhile() { return getToken(PhpParser.EndWhile, 0); } + public TerminalNode Eval() { return getToken(PhpParser.Eval, 0); } + public TerminalNode Exit() { return getToken(PhpParser.Exit, 0); } + public TerminalNode Extends() { return getToken(PhpParser.Extends, 0); } + public TerminalNode Final() { return getToken(PhpParser.Final, 0); } + public TerminalNode Finally() { return getToken(PhpParser.Finally, 0); } + public TerminalNode FloatCast() { return getToken(PhpParser.FloatCast, 0); } + public TerminalNode For() { return getToken(PhpParser.For, 0); } + public TerminalNode Foreach() { return getToken(PhpParser.Foreach, 0); } + public TerminalNode Function_() { return getToken(PhpParser.Function_, 0); } + public TerminalNode Global() { return getToken(PhpParser.Global, 0); } + public TerminalNode Goto() { return getToken(PhpParser.Goto, 0); } + public TerminalNode If() { return getToken(PhpParser.If, 0); } + public TerminalNode Implements() { return getToken(PhpParser.Implements, 0); } + public TerminalNode Import() { return getToken(PhpParser.Import, 0); } + public TerminalNode Include() { return getToken(PhpParser.Include, 0); } + public TerminalNode IncludeOnce() { return getToken(PhpParser.IncludeOnce, 0); } + public TerminalNode InstanceOf() { return getToken(PhpParser.InstanceOf, 0); } + public TerminalNode InsteadOf() { return getToken(PhpParser.InsteadOf, 0); } + public TerminalNode Int16Cast() { return getToken(PhpParser.Int16Cast, 0); } + public TerminalNode Int64Type() { return getToken(PhpParser.Int64Type, 0); } + public TerminalNode Int8Cast() { return getToken(PhpParser.Int8Cast, 0); } + public TerminalNode Interface() { return getToken(PhpParser.Interface, 0); } + public TerminalNode IntType() { return getToken(PhpParser.IntType, 0); } + public TerminalNode IsSet() { return getToken(PhpParser.IsSet, 0); } + public TerminalNode LambdaFn() { return getToken(PhpParser.LambdaFn, 0); } + public TerminalNode List() { return getToken(PhpParser.List, 0); } + public TerminalNode LogicalAnd() { return getToken(PhpParser.LogicalAnd, 0); } + public TerminalNode LogicalOr() { return getToken(PhpParser.LogicalOr, 0); } + public TerminalNode LogicalXor() { return getToken(PhpParser.LogicalXor, 0); } + public TerminalNode Namespace() { return getToken(PhpParser.Namespace, 0); } + public TerminalNode New() { return getToken(PhpParser.New, 0); } + public TerminalNode Null() { return getToken(PhpParser.Null, 0); } + public TerminalNode ObjectType() { return getToken(PhpParser.ObjectType, 0); } + public TerminalNode Parent_() { return getToken(PhpParser.Parent_, 0); } + public TerminalNode Partial() { return getToken(PhpParser.Partial, 0); } + public TerminalNode Print() { return getToken(PhpParser.Print, 0); } + public TerminalNode Private() { return getToken(PhpParser.Private, 0); } + public TerminalNode Protected() { return getToken(PhpParser.Protected, 0); } + public TerminalNode Public() { return getToken(PhpParser.Public, 0); } + public TerminalNode Readonly() { return getToken(PhpParser.Readonly, 0); } + public TerminalNode Require() { return getToken(PhpParser.Require, 0); } + public TerminalNode RequireOnce() { return getToken(PhpParser.RequireOnce, 0); } + public TerminalNode Resource() { return getToken(PhpParser.Resource, 0); } + public TerminalNode Return() { return getToken(PhpParser.Return, 0); } + public TerminalNode Static() { return getToken(PhpParser.Static, 0); } + public TerminalNode StringType() { return getToken(PhpParser.StringType, 0); } + public TerminalNode Switch() { return getToken(PhpParser.Switch, 0); } + public TerminalNode Throw() { return getToken(PhpParser.Throw, 0); } + public TerminalNode Trait() { return getToken(PhpParser.Trait, 0); } + public TerminalNode Try() { return getToken(PhpParser.Try, 0); } + public TerminalNode Typeof() { return getToken(PhpParser.Typeof, 0); } + public TerminalNode UintCast() { return getToken(PhpParser.UintCast, 0); } + public TerminalNode UnicodeCast() { return getToken(PhpParser.UnicodeCast, 0); } + public TerminalNode Unset() { return getToken(PhpParser.Unset, 0); } + public TerminalNode Use() { return getToken(PhpParser.Use, 0); } + public TerminalNode Var() { return getToken(PhpParser.Var, 0); } + public TerminalNode While() { return getToken(PhpParser.While, 0); } + public TerminalNode Yield() { return getToken(PhpParser.Yield, 0); } + public TerminalNode From() { return getToken(PhpParser.From, 0); } + public TerminalNode Enum_() { return getToken(PhpParser.Enum_, 0); } + public TerminalNode Match_() { return getToken(PhpParser.Match_, 0); } + public TerminalNode Ticks() { return getToken(PhpParser.Ticks, 0); } + public TerminalNode Encoding() { return getToken(PhpParser.Encoding, 0); } + public TerminalNode StrictTypes() { return getToken(PhpParser.StrictTypes, 0); } + public TerminalNode Get() { return getToken(PhpParser.Get, 0); } + public TerminalNode Set() { return getToken(PhpParser.Set, 0); } + public TerminalNode Call() { return getToken(PhpParser.Call, 0); } + public TerminalNode CallStatic() { return getToken(PhpParser.CallStatic, 0); } + public TerminalNode Constructor() { return getToken(PhpParser.Constructor, 0); } + public TerminalNode Destruct() { return getToken(PhpParser.Destruct, 0); } + public TerminalNode Wakeup() { return getToken(PhpParser.Wakeup, 0); } + public TerminalNode Sleep() { return getToken(PhpParser.Sleep, 0); } + public TerminalNode Autoload() { return getToken(PhpParser.Autoload, 0); } + public TerminalNode IsSet__() { return getToken(PhpParser.IsSet__, 0); } + public TerminalNode Unset__() { return getToken(PhpParser.Unset__, 0); } + public TerminalNode ToString__() { return getToken(PhpParser.ToString__, 0); } + public TerminalNode Invoke() { return getToken(PhpParser.Invoke, 0); } + public TerminalNode SetState() { return getToken(PhpParser.SetState, 0); } + public TerminalNode Clone__() { return getToken(PhpParser.Clone__, 0); } + public TerminalNode DebugInfo() { return getToken(PhpParser.DebugInfo, 0); } + public TerminalNode Namespace__() { return getToken(PhpParser.Namespace__, 0); } + public TerminalNode Class__() { return getToken(PhpParser.Class__, 0); } + public TerminalNode Traic__() { return getToken(PhpParser.Traic__, 0); } + public TerminalNode Function__() { return getToken(PhpParser.Function__, 0); } + public TerminalNode Method__() { return getToken(PhpParser.Method__, 0); } + public TerminalNode Line__() { return getToken(PhpParser.Line__, 0); } + public TerminalNode File__() { return getToken(PhpParser.File__, 0); } + public TerminalNode Dir__() { return getToken(PhpParser.Dir__, 0); } + public IdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIdentifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIdentifier(this); + } + } + + public final IdentifierContext identifier() throws RecognitionException { + IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_identifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1934); + _la = _input.LA(1); + if ( !(((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)))) != 0) || _la==Label) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MemberModifierContext extends ParserRuleContext { + public TerminalNode Public() { return getToken(PhpParser.Public, 0); } + public TerminalNode Protected() { return getToken(PhpParser.Protected, 0); } + public TerminalNode Private() { return getToken(PhpParser.Private, 0); } + public TerminalNode Static() { return getToken(PhpParser.Static, 0); } + public TerminalNode Abstract() { return getToken(PhpParser.Abstract, 0); } + public TerminalNode Final() { return getToken(PhpParser.Final, 0); } + public TerminalNode Readonly() { return getToken(PhpParser.Readonly, 0); } + public MemberModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memberModifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMemberModifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMemberModifier(this); + } + } + + public final MemberModifierContext memberModifier() throws RecognitionException { + MemberModifierContext _localctx = new MemberModifierContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_memberModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1936); + _la = _input.LA(1); + if ( !(_la==Abstract || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MagicConstantContext extends ParserRuleContext { + public TerminalNode Namespace__() { return getToken(PhpParser.Namespace__, 0); } + public TerminalNode Class__() { return getToken(PhpParser.Class__, 0); } + public TerminalNode Traic__() { return getToken(PhpParser.Traic__, 0); } + public TerminalNode Function__() { return getToken(PhpParser.Function__, 0); } + public TerminalNode Method__() { return getToken(PhpParser.Method__, 0); } + public TerminalNode Line__() { return getToken(PhpParser.Line__, 0); } + public TerminalNode File__() { return getToken(PhpParser.File__, 0); } + public TerminalNode Dir__() { return getToken(PhpParser.Dir__, 0); } + public MagicConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_magicConstant; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMagicConstant(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMagicConstant(this); + } + } + + public final MagicConstantContext magicConstant() throws RecognitionException { + MagicConstantContext _localctx = new MagicConstantContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_magicConstant); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1938); + _la = _input.LA(1); + if ( !(((((_la - 153)) & ~0x3f) == 0 && ((1L << (_la - 153)) & ((1L << (Namespace__ - 153)) | (1L << (Class__ - 153)) | (1L << (Traic__ - 153)) | (1L << (Function__ - 153)) | (1L << (Method__ - 153)) | (1L << (Line__ - 153)) | (1L << (File__ - 153)) | (1L << (Dir__ - 153)))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MagicMethodContext extends ParserRuleContext { + public TerminalNode Get() { return getToken(PhpParser.Get, 0); } + public TerminalNode Set() { return getToken(PhpParser.Set, 0); } + public TerminalNode Call() { return getToken(PhpParser.Call, 0); } + public TerminalNode CallStatic() { return getToken(PhpParser.CallStatic, 0); } + public TerminalNode Constructor() { return getToken(PhpParser.Constructor, 0); } + public TerminalNode Destruct() { return getToken(PhpParser.Destruct, 0); } + public TerminalNode Wakeup() { return getToken(PhpParser.Wakeup, 0); } + public TerminalNode Sleep() { return getToken(PhpParser.Sleep, 0); } + public TerminalNode Autoload() { return getToken(PhpParser.Autoload, 0); } + public TerminalNode IsSet__() { return getToken(PhpParser.IsSet__, 0); } + public TerminalNode Unset__() { return getToken(PhpParser.Unset__, 0); } + public TerminalNode ToString__() { return getToken(PhpParser.ToString__, 0); } + public TerminalNode Invoke() { return getToken(PhpParser.Invoke, 0); } + public TerminalNode SetState() { return getToken(PhpParser.SetState, 0); } + public TerminalNode Clone__() { return getToken(PhpParser.Clone__, 0); } + public TerminalNode DebugInfo() { return getToken(PhpParser.DebugInfo, 0); } + public MagicMethodContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_magicMethod; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMagicMethod(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMagicMethod(this); + } + } + + public final MagicMethodContext magicMethod() throws RecognitionException { + MagicMethodContext _localctx = new MagicMethodContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_magicMethod); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1940); + _la = _input.LA(1); + if ( !(((((_la - 137)) & ~0x3f) == 0 && ((1L << (_la - 137)) & ((1L << (Get - 137)) | (1L << (Set - 137)) | (1L << (Call - 137)) | (1L << (CallStatic - 137)) | (1L << (Constructor - 137)) | (1L << (Destruct - 137)) | (1L << (Wakeup - 137)) | (1L << (Sleep - 137)) | (1L << (Autoload - 137)) | (1L << (IsSet__ - 137)) | (1L << (Unset__ - 137)) | (1L << (ToString__ - 137)) | (1L << (Invoke - 137)) | (1L << (SetState - 137)) | (1L << (Clone__ - 137)) | (1L << (DebugInfo - 137)))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimitiveTypeContext extends ParserRuleContext { + public TerminalNode BoolType() { return getToken(PhpParser.BoolType, 0); } + public TerminalNode IntType() { return getToken(PhpParser.IntType, 0); } + public TerminalNode Int64Type() { return getToken(PhpParser.Int64Type, 0); } + public TerminalNode DoubleType() { return getToken(PhpParser.DoubleType, 0); } + public TerminalNode StringType() { return getToken(PhpParser.StringType, 0); } + public TerminalNode Resource() { return getToken(PhpParser.Resource, 0); } + public TerminalNode ObjectType() { return getToken(PhpParser.ObjectType, 0); } + public TerminalNode Array() { return getToken(PhpParser.Array, 0); } + public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primitiveType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPrimitiveType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPrimitiveType(this); + } + } + + public final PrimitiveTypeContext primitiveType() throws RecognitionException { + PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_primitiveType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1942); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Array) | (1L << BoolType) | (1L << DoubleType))) != 0) || ((((_la - 94)) & ~0x3f) == 0 && ((1L << (_la - 94)) & ((1L << (Int64Type - 94)) | (1L << (IntType - 94)) | (1L << (ObjectType - 94)) | (1L << (Resource - 94)) | (1L << (StringType - 94)))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CastOperationContext extends ParserRuleContext { + public TerminalNode BoolType() { return getToken(PhpParser.BoolType, 0); } + public TerminalNode Int8Cast() { return getToken(PhpParser.Int8Cast, 0); } + public TerminalNode Int16Cast() { return getToken(PhpParser.Int16Cast, 0); } + public TerminalNode IntType() { return getToken(PhpParser.IntType, 0); } + public TerminalNode Int64Type() { return getToken(PhpParser.Int64Type, 0); } + public TerminalNode UintCast() { return getToken(PhpParser.UintCast, 0); } + public TerminalNode DoubleCast() { return getToken(PhpParser.DoubleCast, 0); } + public TerminalNode DoubleType() { return getToken(PhpParser.DoubleType, 0); } + public TerminalNode FloatCast() { return getToken(PhpParser.FloatCast, 0); } + public TerminalNode StringType() { return getToken(PhpParser.StringType, 0); } + public TerminalNode BinaryCast() { return getToken(PhpParser.BinaryCast, 0); } + public TerminalNode UnicodeCast() { return getToken(PhpParser.UnicodeCast, 0); } + public TerminalNode Array() { return getToken(PhpParser.Array, 0); } + public TerminalNode ObjectType() { return getToken(PhpParser.ObjectType, 0); } + public TerminalNode Resource() { return getToken(PhpParser.Resource, 0); } + public TerminalNode Unset() { return getToken(PhpParser.Unset, 0); } + public CastOperationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_castOperation; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterCastOperation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitCastOperation(this); + } + } + + public final CastOperationContext castOperation() throws RecognitionException { + CastOperationContext _localctx = new CastOperationContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_castOperation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1944); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Array) | (1L << BinaryCast) | (1L << BoolType) | (1L << DoubleCast) | (1L << DoubleType))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (FloatCast - 79)) | (1L << (Int8Cast - 79)) | (1L << (Int16Cast - 79)) | (1L << (Int64Type - 79)) | (1L << (IntType - 79)) | (1L << (ObjectType - 79)) | (1L << (Resource - 79)) | (1L << (StringType - 79)) | (1L << (UintCast - 79)) | (1L << (UnicodeCast - 79)) | (1L << (Unset - 79)))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 59: + return typeHint_sempred((TypeHintContext)_localctx, predIndex); + case 82: + return expression_sempred((ExpressionContext)_localctx, predIndex); + } + return true; + } + private boolean typeHint_sempred(TypeHintContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 1); + } + return true; + } + private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return precpred(_ctx, 22); + case 2: + return precpred(_ctx, 20); + case 3: + return precpred(_ctx, 19); + case 4: + return precpred(_ctx, 18); + case 5: + return precpred(_ctx, 17); + case 6: + return precpred(_ctx, 16); + case 7: + return precpred(_ctx, 15); + case 8: + return precpred(_ctx, 14); + case 9: + return precpred(_ctx, 13); + case 10: + return precpred(_ctx, 12); + case 11: + return precpred(_ctx, 11); + case 12: + return precpred(_ctx, 10); + case 13: + return precpred(_ctx, 9); + case 14: + return precpred(_ctx, 8); + case 15: + return precpred(_ctx, 3); + case 16: + return precpred(_ctx, 2); + case 17: + return precpred(_ctx, 1); + case 18: + return precpred(_ctx, 21); + } + return true; + } + + public static final String _serializedATN = + "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\u00f6\u079d\4\2\t"+ + "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ + "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ + ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ + "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ + "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ + "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ + "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ + "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ + "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ + "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+ + "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+ + "\4\u008a\t\u008a\4\u008b\t\u008b\3\2\5\2\u0118\n\2\3\2\3\2\7\2\u011c\n"+ + "\2\f\2\16\2\u011f\13\2\3\2\3\2\3\3\6\3\u0124\n\3\r\3\16\3\u0125\3\3\5"+ + "\3\u0129\n\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+ + "\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\7\4\u0141\n\4\f\4\16\4\u0144\13\4\3\4\5"+ + "\4\u0147\n\4\3\5\6\5\u014a\n\5\r\5\16\5\u014b\3\6\7\6\u014f\n\6\f\6\16"+ + "\6\u0152\13\6\3\6\6\6\u0155\n\6\r\6\16\6\u0156\3\7\3\7\3\7\3\7\3\7\3\b"+ + "\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u0165\n\b\3\t\3\t\5\t\u0169\n\t\3\t\3\t\3"+ + "\t\3\n\5\n\u016f\n\n\3\n\3\n\3\n\5\n\u0174\n\n\3\n\7\n\u0177\n\n\f\n\16"+ + "\n\u017a\13\n\3\13\3\13\3\f\3\f\5\f\u0180\n\f\3\f\3\f\7\f\u0184\n\f\f"+ + "\f\16\f\u0187\13\f\3\f\3\f\3\f\3\f\5\f\u018d\n\f\3\r\3\r\3\r\3\r\3\r\5"+ + "\r\u0194\n\r\3\16\5\16\u0197\n\16\3\16\3\16\5\16\u019b\n\16\3\16\3\16"+ + "\5\16\u019f\n\16\3\16\3\16\3\16\3\16\3\16\5\16\u01a6\n\16\3\16\5\16\u01a9"+ + "\n\16\3\16\3\16\3\17\5\17\u01ae\n\17\3\17\5\17\u01b1\n\17\3\17\5\17\u01b4"+ + "\n\17\3\17\5\17\u01b7\n\17\3\17\3\17\3\17\5\17\u01bc\n\17\3\17\3\17\5"+ + "\17\u01c0\n\17\3\17\3\17\5\17\u01c4\n\17\3\17\3\17\3\17\5\17\u01c9\n\17"+ + "\3\17\3\17\5\17\u01cd\n\17\5\17\u01cf\n\17\3\17\3\17\7\17\u01d3\n\17\f"+ + "\17\16\17\u01d6\13\17\3\17\3\17\3\20\3\20\3\21\3\21\3\21\7\21\u01df\n"+ + "\21\f\21\16\21\u01e2\13\21\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22"+ + "\3\22\3\22\3\22\3\22\3\22\5\22\u01f2\n\22\3\23\3\23\3\23\7\23\u01f7\n"+ + "\23\f\23\16\23\u01fa\13\23\3\24\3\24\3\24\7\24\u01ff\n\24\f\24\16\24\u0202"+ + "\13\24\3\25\5\25\u0205\n\25\3\25\3\25\3\26\5\26\u020a\n\26\3\26\3\26\3"+ + "\26\3\26\5\26\u0210\n\26\3\27\3\27\3\27\3\27\7\27\u0216\n\27\f\27\16\27"+ + "\u0219\13\27\3\27\3\27\3\30\6\30\u021e\n\30\r\30\16\30\u021f\3\31\3\31"+ + "\3\31\3\31\5\31\u0226\n\31\3\31\3\31\3\31\7\31\u022b\n\31\f\31\16\31\u022e"+ + "\13\31\3\31\3\31\3\32\3\32\5\32\u0234\n\32\3\33\7\33\u0237\n\33\f\33\16"+ + "\33\u023a\13\33\3\34\3\34\3\34\5\34\u023f\n\34\3\35\3\35\3\35\3\35\3\35"+ + "\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35"+ + "\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u025c\n\35\3\36\3\36\3\37"+ + "\3\37\3\37\3\37\3 \3 \3 \3 \7 \u0268\n \f \16 \u026b\13 \3 \5 \u026e\n"+ + " \3 \3 \3 \3 \3 \7 \u0275\n \f \16 \u0278\13 \3 \5 \u027b\n \3 \3 \3 "+ + "\5 \u0280\n \3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3$\3$\3$\3$\3%\3"+ + "%\3%\3%\3%\3%\3%\3%\5%\u029a\n%\3&\3&\3&\3&\3&\3&\3\'\3\'\3\'\5\'\u02a5"+ + "\n\'\3\'\3\'\5\'\u02a9\n\'\3\'\3\'\5\'\u02ad\n\'\3\'\3\'\3\'\3\'\3\'\3"+ + "\'\3\'\5\'\u02b6\n\'\3(\3(\3)\3)\3*\3*\3*\3*\5*\u02c0\n*\3*\7*\u02c3\n"+ + "*\f*\16*\u02c6\13*\3*\3*\3*\5*\u02cb\n*\3*\7*\u02ce\n*\f*\16*\u02d1\13"+ + "*\3*\3*\5*\u02d5\n*\3+\3+\3+\5+\u02da\n+\3+\6+\u02dd\n+\r+\16+\u02de\3"+ + "+\3+\3,\3,\5,\u02e5\n,\3,\3,\3-\3-\5-\u02eb\n-\3-\3-\3.\3.\5.\u02f1\n"+ + ".\3.\3.\3/\3/\3/\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61"+ + "\3\61\3\61\3\61\3\61\3\61\3\61\5\61\u0309\n\61\3\61\3\61\3\61\5\61\u030e"+ + "\n\61\3\61\5\61\u0311\n\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\5\61"+ + "\u031b\n\61\3\61\5\61\u031e\n\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3"+ + "\61\3\61\3\61\3\61\5\61\u032b\n\61\3\61\3\61\3\61\3\61\3\61\3\61\5\61"+ + "\u0333\n\61\3\62\3\62\3\62\6\62\u0338\n\62\r\62\16\62\u0339\3\62\5\62"+ + "\u033d\n\62\3\62\7\62\u0340\n\62\f\62\16\62\u0343\13\62\3\62\5\62\u0346"+ + "\n\62\3\63\3\63\3\63\3\63\3\63\7\63\u034d\n\63\f\63\16\63\u0350\13\63"+ + "\3\63\5\63\u0353\n\63\3\63\3\63\3\63\3\64\3\64\3\64\3\65\3\65\3\65\3\65"+ + "\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67"+ + "\5\67\u036d\n\67\38\68\u0370\n8\r8\168\u0371\39\39\39\79\u0377\n9\f9\16"+ + "9\u037a\139\3:\3:\3:\3:\5:\u0380\n:\3:\3:\3:\3:\3:\3:\5:\u0388\n:\3;\5"+ + ";\u038b\n;\3;\3;\7;\u038f\n;\f;\16;\u0392\13;\3;\5;\u0395\n;\3<\5<\u0398"+ + "\n<\3<\7<\u039b\n<\f<\16<\u039e\13<\3<\5<\u03a1\n<\3<\5<\u03a4\n<\3<\5"+ + "<\u03a7\n<\3<\5<\u03aa\n<\3<\3<\3=\3=\3=\3=\5=\u03b2\n=\3=\3=\3=\7=\u03b7"+ + "\n=\f=\16=\u03ba\13=\3>\3>\3>\3>\7>\u03c0\n>\f>\16>\u03c3\13>\3>\3>\3"+ + "?\3?\3?\3?\3?\3?\3?\3?\5?\u03cf\n?\3@\3@\3@\3@\3A\3A\3A\3A\7A\u03d9\n"+ + "A\fA\16A\u03dc\13A\3A\3A\3B\5B\u03e1\nB\3B\3B\5B\u03e5\nB\3B\3B\3B\7B"+ + "\u03ea\nB\fB\16B\u03ed\13B\3B\3B\3B\5B\u03f2\nB\3B\3B\5B\u03f6\nB\3B\3"+ + "B\3B\7B\u03fb\nB\fB\16B\u03fe\13B\3B\3B\3B\3B\5B\u0404\nB\3B\3B\5B\u0408"+ + "\nB\3B\3B\3B\3B\3B\5B\u040f\nB\3B\3B\5B\u0413\nB\5B\u0415\nB\3B\3B\3B"+ + "\3B\5B\u041b\nB\3C\3C\3C\7C\u0420\nC\fC\16C\u0423\13C\3C\5C\u0426\nC\3"+ + "D\3D\5D\u042a\nD\3E\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F\5F\u0437\nF\3F\5F\u043a"+ + "\nF\3F\3F\3G\3G\3G\5G\u0441\nG\3G\3G\3H\3H\3H\5H\u0448\nH\3I\3I\5I\u044c"+ + "\nI\3I\3I\3J\3J\5J\u0452\nJ\3K\3K\5K\u0456\nK\3L\6L\u0459\nL\rL\16L\u045a"+ + "\3M\3M\3M\5M\u0460\nM\3N\3N\3N\3N\3O\5O\u0467\nO\3O\3O\3O\3O\7O\u046d"+ + "\nO\fO\16O\u0470\13O\3O\3O\3P\3P\3P\3P\5P\u0478\nP\3P\3P\5P\u047c\nP\3"+ + "P\3P\7P\u0480\nP\fP\16P\u0483\13P\3P\3P\3Q\3Q\3Q\3Q\5Q\u048b\nQ\3Q\3Q"+ + "\3Q\5Q\u0490\nQ\3Q\3Q\3Q\3Q\3Q\5Q\u0497\nQ\3R\3R\3R\7R\u049c\nR\fR\16"+ + "R\u049f\13R\3S\3S\3S\5S\u04a4\nS\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+ + "T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+ + "T\5T\u04ca\nT\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+ + "T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\5T\u04f4"+ + "\nT\3T\3T\3T\3T\3T\5T\u04fb\nT\3T\3T\3T\5T\u0500\nT\5T\u0502\nT\3T\3T"+ + "\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T"+ + "\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\5T\u0528\nT\3T\3T\3T\3T\3T\3T\3T\3T"+ + "\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\7T\u053e\nT\fT\16T\u0541\13T\3U\3"+ + "U\5U\u0545\nU\3V\3V\3V\5V\u054a\nV\3V\3V\3V\5V\u054f\nV\3V\5V\u0552\n"+ + "V\3V\3V\3V\3V\5V\u0558\nV\3W\3W\7W\u055c\nW\fW\16W\u055f\13W\3W\3W\6W"+ + "\u0563\nW\rW\16W\u0564\3W\7W\u0568\nW\fW\16W\u056b\13W\3W\7W\u056e\nW"+ + "\fW\16W\u0571\13W\3W\3W\3W\3W\3W\6W\u0578\nW\rW\16W\u0579\3W\7W\u057d"+ + "\nW\fW\16W\u0580\13W\3W\5W\u0583\nW\3W\3W\5W\u0587\nW\3X\5X\u058a\nX\3"+ + "X\3X\3Y\3Y\3Y\5Y\u0591\nY\3Y\5Y\u0594\nY\3Y\3Y\3Z\5Z\u0599\nZ\3Z\3Z\5"+ + "Z\u059d\nZ\3Z\3Z\3Z\3Z\5Z\u05a3\nZ\3Z\3Z\5Z\u05a7\nZ\3Z\3Z\3Z\3Z\3Z\3"+ + "Z\3Z\3Z\3Z\5Z\u05b2\nZ\3[\3[\3[\3[\3[\3[\3[\3[\7[\u05bc\n[\f[\16[\u05bf"+ + "\13[\3[\5[\u05c2\n[\3[\3[\3\\\3\\\3\\\7\\\u05c9\n\\\f\\\16\\\u05cc\13"+ + "\\\3\\\3\\\3\\\3]\3]\3]\5]\u05d4\n]\3^\3^\3_\3_\3_\3_\5_\u05dc\n_\3_\3"+ + "_\5_\u05e0\n_\3`\3`\3`\7`\u05e5\n`\f`\16`\u05e8\13`\3`\5`\u05eb\n`\3a"+ + "\3a\3a\5a\u05f0\na\3a\3a\3a\5a\u05f5\na\3a\3a\5a\u05f9\na\3b\3b\3b\3b"+ + "\3b\7b\u0600\nb\fb\16b\u0603\13b\3b\3b\3c\5c\u0608\nc\3c\3c\3d\3d\5d\u060e"+ + "\nd\3d\5d\u0611\nd\3e\3e\5e\u0615\ne\3e\5e\u0618\ne\3e\3e\3e\5e\u061d"+ + "\ne\3f\5f\u0620\nf\3f\5f\u0623\nf\3f\5f\u0626\nf\3f\5f\u0629\nf\3f\3f"+ + "\5f\u062d\nf\3f\3f\5f\u0631\nf\3f\3f\5f\u0635\nf\3f\3f\3f\5f\u063a\nf"+ + "\3f\3f\5f\u063e\nf\5f\u0640\nf\3f\3f\7f\u0644\nf\ff\16f\u0647\13f\3f\3"+ + "f\3g\3g\3g\7g\u064e\ng\fg\16g\u0651\13g\3h\5h\u0654\nh\3h\5h\u0657\nh"+ + "\3h\3h\3i\3i\3i\3i\7i\u065f\ni\fi\16i\u0662\13i\3i\3i\5i\u0666\ni\5i\u0668"+ + "\ni\3j\3j\3j\5j\u066d\nj\3j\3j\3j\3j\7j\u0673\nj\fj\16j\u0676\13j\3j\5"+ + "j\u0679\nj\3j\3j\5j\u067d\nj\3k\3k\3k\7k\u0682\nk\fk\16k\u0685\13k\3l"+ + "\3l\3l\3l\7l\u068b\nl\fl\16l\u068e\13l\3l\5l\u0691\nl\3l\5l\u0694\nl\3"+ + "l\3l\3m\5m\u0699\nm\3m\5m\u069c\nm\3m\3m\3m\5m\u06a1\nm\3n\3n\3n\3o\3"+ + "o\3o\3o\3o\3o\5o\u06ac\no\5o\u06ae\no\3o\3o\3o\3o\5o\u06b4\no\5o\u06b6"+ + "\no\3o\3o\3o\3o\3o\5o\u06bd\no\3o\3o\3o\5o\u06c2\no\7o\u06c4\no\fo\16"+ + "o\u06c7\13o\5o\u06c9\no\3p\3p\3p\3p\3p\5p\u06d0\np\3q\3q\3q\3q\5q\u06d6"+ + "\nq\3r\3r\3s\3s\3s\3s\3s\3s\5s\u06e0\ns\3s\3s\3s\5s\u06e5\ns\3s\3s\3s"+ + "\5s\u06ea\ns\5s\u06ec\ns\3t\3t\3u\3u\6u\u06f2\nu\ru\16u\u06f3\3u\3u\6"+ + "u\u06f8\nu\ru\16u\u06f9\3u\3u\3u\7u\u06ff\nu\fu\16u\u0702\13u\3u\5u\u0705"+ + "\nu\3v\3v\3v\5v\u070a\nv\3w\3w\3w\7w\u070f\nw\fw\16w\u0712\13w\3x\3x\7"+ + "x\u0716\nx\fx\16x\u0719\13x\3y\3y\3y\3y\3y\3y\5y\u0721\ny\3z\3z\3z\5z"+ + "\u0726\nz\3{\3{\3{\3|\3|\3|\3|\5|\u072f\n|\3}\5}\u0732\n}\3}\6}\u0735"+ + "\n}\r}\16}\u0736\3}\7}\u073a\n}\f}\16}\u073d\13}\3~\3~\3~\5~\u0742\n~"+ + "\3~\3~\3~\3~\5~\u0748\n~\3\177\3\177\5\177\u074c\n\177\3\u0080\3\u0080"+ + "\3\u0080\3\u0080\3\u0080\5\u0080\u0753\n\u0080\3\u0080\7\u0080\u0756\n"+ + "\u0080\f\u0080\16\u0080\u0759\13\u0080\3\u0081\7\u0081\u075c\n\u0081\f"+ + "\u0081\16\u0081\u075f\13\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081"+ + "\3\u0081\5\u0081\u0767\n\u0081\3\u0081\7\u0081\u076a\n\u0081\f\u0081\16"+ + "\u0081\u076d\13\u0081\3\u0082\3\u0082\5\u0082\u0771\n\u0082\3\u0082\3"+ + "\u0082\3\u0082\3\u0082\3\u0082\5\u0082\u0778\n\u0082\3\u0083\5\u0083\u077b"+ + "\n\u0083\3\u0083\3\u0083\5\u0083\u077f\n\u0083\7\u0083\u0781\n\u0083\f"+ + "\u0083\16\u0083\u0784\13\u0083\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084"+ + "\3\u0084\3\u0084\5\u0084\u078d\n\u0084\3\u0085\3\u0085\3\u0086\3\u0086"+ + "\3\u0087\3\u0087\3\u0088\3\u0088\3\u0089\3\u0089\3\u008a\3\u008a\3\u008b"+ + "\3\u008b\3\u008b\2\4x\u00a6\u008c\2\4\6\b\n\f\16\20\22\24\26\30\32\34"+ + "\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082"+ + "\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a"+ + "\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2"+ + "\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca"+ + "\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2"+ + "\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa"+ + "\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112"+ + "\u0114\2\33\4\2::TT\4\288||\3\2\u00dd\u00de\4\2aayy\3\2\u00d1\u00d2\4"+ + "\2\u00ca\u00ca\u00cc\u00cd\3\2Z[\3\2tu\3\2\u00a7\u00a8\3\2\u00ce\u00d0"+ + "\4\2\u00cc\u00cd\u00d4\u00d4\3\2\u00c0\u00c1\4\2\u00ad\u00ae\u00c6\u00c7"+ + "\3\2\u00a9\u00ac\6\2\u00af\u00b1\u00b3\u00bb\u00bf\u00bf\u00df\u00df\3"+ + "\2\u00cc\u00cd\4\2\u00e4\u00e5\u00e7\u00e8\4\288mm\4\2..OO\4\2.\u00a2"+ + "\u00e3\u00e3\6\2..OOpsxx\3\2\u009b\u00a2\3\2\u008b\u009a\t\2//\62\62@"+ + "@`allvvyy\13\2//\61\62?@QQ^allvvyy\177\u0081\u088a\2\u0117\3\2\2\2\4\u0128"+ + "\3\2\2\2\6\u0146\3\2\2\2\b\u0149\3\2\2\2\n\u0150\3\2\2\2\f\u0158\3\2\2"+ + "\2\16\u0164\3\2\2\2\20\u0166\3\2\2\2\22\u016e\3\2\2\2\24\u017b\3\2\2\2"+ + "\26\u017d\3\2\2\2\30\u0193\3\2\2\2\32\u0196\3\2\2\2\34\u01ad\3\2\2\2\36"+ + "\u01d9\3\2\2\2 \u01db\3\2\2\2\"\u01f1\3\2\2\2$\u01f3\3\2\2\2&\u01fb\3"+ + "\2\2\2(\u0204\3\2\2\2*\u0209\3\2\2\2,\u0211\3\2\2\2.\u021d\3\2\2\2\60"+ + "\u0221\3\2\2\2\62\u0231\3\2\2\2\64\u0238\3\2\2\2\66\u023e\3\2\2\28\u025b"+ + "\3\2\2\2:\u025d\3\2\2\2<\u025f\3\2\2\2>\u027f\3\2\2\2@\u0281\3\2\2\2B"+ + "\u0285\3\2\2\2D\u028a\3\2\2\2F\u028d\3\2\2\2H\u0291\3\2\2\2J\u029b\3\2"+ + "\2\2L\u02a1\3\2\2\2N\u02b7\3\2\2\2P\u02b9\3\2\2\2R\u02bb\3\2\2\2T\u02dc"+ + "\3\2\2\2V\u02e2\3\2\2\2X\u02e8\3\2\2\2Z\u02ee\3\2\2\2\\\u02f4\3\2\2\2"+ + "^\u02f7\3\2\2\2`\u02fd\3\2\2\2b\u0334\3\2\2\2d\u0347\3\2\2\2f\u0357\3"+ + "\2\2\2h\u035a\3\2\2\2j\u035e\3\2\2\2l\u0362\3\2\2\2n\u036f\3\2\2\2p\u0373"+ + "\3\2\2\2r\u0387\3\2\2\2t\u038a\3\2\2\2v\u0397\3\2\2\2x\u03b1\3\2\2\2z"+ + "\u03bb\3\2\2\2|\u03ce\3\2\2\2~\u03d0\3\2\2\2\u0080\u03d4\3\2\2\2\u0082"+ + "\u041a\3\2\2\2\u0084\u0425\3\2\2\2\u0086\u0429\3\2\2\2\u0088\u042b\3\2"+ + "\2\2\u008a\u0432\3\2\2\2\u008c\u0440\3\2\2\2\u008e\u0444\3\2\2\2\u0090"+ + "\u0449\3\2\2\2\u0092\u0451\3\2\2\2\u0094\u0455\3\2\2\2\u0096\u0458\3\2"+ + "\2\2\u0098\u045c\3\2\2\2\u009a\u0461\3\2\2\2\u009c\u0466\3\2\2\2\u009e"+ + "\u0473\3\2\2\2\u00a0\u0496\3\2\2\2\u00a2\u0498\3\2\2\2\u00a4\u04a0\3\2"+ + "\2\2\u00a6\u0501\3\2\2\2\u00a8\u0544\3\2\2\2\u00aa\u0551\3\2\2\2\u00ac"+ + "\u0586\3\2\2\2\u00ae\u0589\3\2\2\2\u00b0\u0590\3\2\2\2\u00b2\u05b1\3\2"+ + "\2\2\u00b4\u05b3\3\2\2\2\u00b6\u05c5\3\2\2\2\u00b8\u05d0\3\2\2\2\u00ba"+ + "\u05d5\3\2\2\2\u00bc\u05d7\3\2\2\2\u00be\u05e1\3\2\2\2\u00c0\u05f8\3\2"+ + "\2\2\u00c2\u05fa\3\2\2\2\u00c4\u0607\3\2\2\2\u00c6\u0610\3\2\2\2\u00c8"+ + "\u061c\3\2\2\2\u00ca\u061f\3\2\2\2\u00cc\u064a\3\2\2\2\u00ce\u0653\3\2"+ + "\2\2\u00d0\u0667\3\2\2\2\u00d2\u067c\3\2\2\2\u00d4\u067e\3\2\2\2\u00d6"+ + "\u0686\3\2\2\2\u00d8\u06a0\3\2\2\2\u00da\u06a2\3\2\2\2\u00dc\u06c8\3\2"+ + "\2\2\u00de\u06cf\3\2\2\2\u00e0\u06d5\3\2\2\2\u00e2\u06d7\3\2\2\2\u00e4"+ + "\u06eb\3\2\2\2\u00e6\u06ed\3\2\2\2\u00e8\u0704\3\2\2\2\u00ea\u0709\3\2"+ + "\2\2\u00ec\u070b\3\2\2\2\u00ee\u0713\3\2\2\2\u00f0\u0720\3\2\2\2\u00f2"+ + "\u0722\3\2\2\2\u00f4\u0727\3\2\2\2\u00f6\u072e\3\2\2\2\u00f8\u0731\3\2"+ + "\2\2\u00fa\u0747\3\2\2\2\u00fc\u074b\3\2\2\2\u00fe\u0752\3\2\2\2\u0100"+ + "\u075d\3\2\2\2\u0102\u0777\3\2\2\2\u0104\u077a\3\2\2\2\u0106\u078c\3\2"+ + "\2\2\u0108\u078e\3\2\2\2\u010a\u0790\3\2\2\2\u010c\u0792\3\2\2\2\u010e"+ + "\u0794\3\2\2\2\u0110\u0796\3\2\2\2\u0112\u0798\3\2\2\2\u0114\u079a\3\2"+ + "\2\2\u0116\u0118\7\f\2\2\u0117\u0116\3\2\2\2\u0117\u0118\3\2\2\2\u0118"+ + "\u011d\3\2\2\2\u0119\u011c\5\4\3\2\u011a\u011c\5\n\6\2\u011b\u0119\3\2"+ + "\2\2\u011b\u011a\3\2\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d"+ + "\u011e\3\2\2\2\u011e\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\7\2"+ + "\2\3\u0121\3\3\2\2\2\u0122\u0124\5\6\4\2\u0123\u0122\3\2\2\2\u0124\u0125"+ + "\3\2\2\2\u0125\u0123\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0129\3\2\2\2\u0127"+ + "\u0129\5\b\5\2\u0128\u0123\3\2\2\2\u0128\u0127\3\2\2\2\u0129\5\3\2\2\2"+ + "\u012a\u0147\7\n\2\2\u012b\u0147\7\21\2\2\u012c\u0147\7\b\2\2\u012d\u0147"+ + "\7\13\2\2\u012e\u0147\7\32\2\2\u012f\u0147\7\22\2\2\u0130\u0147\7\23\2"+ + "\2\u0131\u0147\7\4\2\2\u0132\u0147\7\24\2\2\u0133\u0147\7\25\2\2\u0134"+ + "\u0147\7\35\2\2\u0135\u0147\7\26\2\2\u0136\u0147\7!\2\2\u0137\u0147\7"+ + "\27\2\2\u0138\u0147\7\30\2\2\u0139\u0147\7\36\2\2\u013a\u0147\7\"\2\2"+ + "\u013b\u0147\7\'\2\2\u013c\u0147\7\7\2\2\u013d\u0147\7%\2\2\u013e\u0142"+ + "\7\5\2\2\u013f\u0141\7\16\2\2\u0140\u013f\3\2\2\2\u0141\u0144\3\2\2\2"+ + "\u0142\u0140\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0145\3\2\2\2\u0144\u0142"+ + "\3\2\2\2\u0145\u0147\7\17\2\2\u0146\u012a\3\2\2\2\u0146\u012b\3\2\2\2"+ + "\u0146\u012c\3\2\2\2\u0146\u012d\3\2\2\2\u0146\u012e\3\2\2\2\u0146\u012f"+ + "\3\2\2\2\u0146\u0130\3\2\2\2\u0146\u0131\3\2\2\2\u0146\u0132\3\2\2\2\u0146"+ + "\u0133\3\2\2\2\u0146\u0134\3\2\2\2\u0146\u0135\3\2\2\2\u0146\u0136\3\2"+ + "\2\2\u0146\u0137\3\2\2\2\u0146\u0138\3\2\2\2\u0146\u0139\3\2\2\2\u0146"+ + "\u013a\3\2\2\2\u0146\u013b\3\2\2\2\u0146\u013c\3\2\2\2\u0146\u013d\3\2"+ + "\2\2\u0146\u013e\3\2\2\2\u0147\7\3\2\2\2\u0148\u014a\7$\2\2\u0149\u0148"+ + "\3\2\2\2\u014a\u014b\3\2\2\2\u014b\u0149\3\2\2\2\u014b\u014c\3\2\2\2\u014c"+ + "\t\3\2\2\2\u014d\u014f\5\f\7\2\u014e\u014d\3\2\2\2\u014f\u0152\3\2\2\2"+ + "\u0150\u014e\3\2\2\2\u0150\u0151\3\2\2\2\u0151\u0154\3\2\2\2\u0152\u0150"+ + "\3\2\2\2\u0153\u0155\5\16\b\2\u0154\u0153\3\2\2\2\u0155\u0156\3\2\2\2"+ + "\u0156\u0154\3\2\2\2\u0156\u0157\3\2\2\2\u0157\13\3\2\2\2\u0158\u0159"+ + "\7Y\2\2\u0159\u015a\7i\2\2\u015a\u015b\5\u00d0i\2\u015b\u015c\7\u00de"+ + "\2\2\u015c\r\3\2\2\2\u015d\u0165\58\35\2\u015e\u0165\5\20\t\2\u015f\u0165"+ + "\5\26\f\2\u0160\u0165\5\32\16\2\u0161\u0165\5\34\17\2\u0162\u0165\5\u009c"+ + "O\2\u0163\u0165\5\u009eP\2\u0164\u015d\3\2\2\2\u0164\u015e\3\2\2\2\u0164"+ + "\u015f\3\2\2\2\u0164\u0160\3\2\2\2\u0164\u0161\3\2\2\2\u0164\u0162\3\2"+ + "\2\2\u0164\u0163\3\2\2\2\u0165\17\3\2\2\2\u0166\u0168\7\u0082\2\2\u0167"+ + "\u0169\t\2\2\2\u0168\u0167\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a\3\2"+ + "\2\2\u016a\u016b\5\22\n\2\u016b\u016c\7\u00de\2\2\u016c\21\3\2\2\2\u016d"+ + "\u016f\7\u00c4\2\2\u016e\u016d\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0170"+ + "\3\2\2\2\u0170\u0178\5\24\13\2\u0171\u0173\7\u00dc\2\2\u0172\u0174\7\u00c4"+ + "\2\2\u0173\u0172\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0175\3\2\2\2\u0175"+ + "\u0177\5\24\13\2\u0176\u0171\3\2\2\2\u0177\u017a\3\2\2\2\u0178\u0176\3"+ + "\2\2\2\u0178\u0179\3\2\2\2\u0179\23\3\2\2\2\u017a\u0178\3\2\2\2\u017b"+ + "\u017c\5\u00d0i\2\u017c\25\3\2\2\2\u017d\u018c\7i\2\2\u017e\u0180\5\u00d0"+ + "i\2\u017f\u017e\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0181\3\2\2\2\u0181"+ + "\u0185\7\u00da\2\2\u0182\u0184\5\30\r\2\u0183\u0182\3\2\2\2\u0184\u0187"+ + "\3\2\2\2\u0185\u0183\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u0188\3\2\2\2\u0187"+ + "\u0185\3\2\2\2\u0188\u018d\7\u00db\2\2\u0189\u018a\5\u00d0i\2\u018a\u018b"+ + "\7\u00de\2\2\u018b\u018d\3\2\2\2\u018c\u017f\3\2\2\2\u018c\u0189\3\2\2"+ + "\2\u018d\27\3\2\2\2\u018e\u0194\58\35\2\u018f\u0194\5\20\t\2\u0190\u0194"+ + "\5\32\16\2\u0191\u0194\5\34\17\2\u0192\u0194\5\u009cO\2\u0193\u018e\3"+ + "\2\2\2\u0193\u018f\3\2\2\2\u0193\u0190\3\2\2\2\u0193\u0191\3\2\2\2\u0193"+ + "\u0192\3\2\2\2\u0194\31\3\2\2\2\u0195\u0197\5.\30\2\u0196\u0195\3\2\2"+ + "\2\u0196\u0197\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u019a\7T\2\2\u0199\u019b"+ + "\7\u00c8\2\2\u019a\u0199\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019c\3\2\2"+ + "\2\u019c\u019e\5\u010a\u0086\2\u019d\u019f\5\"\22\2\u019e\u019d\3\2\2"+ + "\2\u019e\u019f\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1\7\u00d6\2\2\u01a1"+ + "\u01a2\5t;\2\u01a2\u01a8\7\u00d7\2\2\u01a3\u01a5\7\u00dd\2\2\u01a4\u01a6"+ + "\7\u00d5\2\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01a7\3\2\2"+ + "\2\u01a7\u01a9\5x=\2\u01a8\u01a3\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01aa"+ + "\3\2\2\2\u01aa\u01ab\5<\37\2\u01ab\33\3\2\2\2\u01ac\u01ae\5.\30\2\u01ad"+ + "\u01ac\3\2\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01b0\3\2\2\2\u01af\u01b1\7p"+ + "\2\2\u01b0\u01af\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b3\3\2\2\2\u01b2"+ + "\u01b4\5\u0108\u0085\2\u01b3\u01b2\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4\u01b6"+ + "\3\2\2\2\u01b5\u01b7\7n\2\2\u01b6\u01b5\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7"+ + "\u01ce\3\2\2\2\u01b8\u01b9\5\36\20\2\u01b9\u01bb\5\u010a\u0086\2\u01ba"+ + "\u01bc\5\"\22\2\u01bb\u01ba\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\u01bf\3"+ + "\2\2\2\u01bd\u01be\7N\2\2\u01be\u01c0\5\u00c6d\2\u01bf\u01bd\3\2\2\2\u01bf"+ + "\u01c0\3\2\2\2\u01c0\u01c3\3\2\2\2\u01c1\u01c2\7X\2\2\u01c2\u01c4\5 \21"+ + "\2\u01c3\u01c1\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01cf\3\2\2\2\u01c5\u01c6"+ + "\7b\2\2\u01c6\u01c8\5\u010a\u0086\2\u01c7\u01c9\5\"\22\2\u01c8\u01c7\3"+ + "\2\2\2\u01c8\u01c9\3\2\2\2\u01c9\u01cc\3\2\2\2\u01ca\u01cb\7N\2\2\u01cb"+ + "\u01cd\5 \21\2\u01cc\u01ca\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01cf\3\2"+ + "\2\2\u01ce\u01b8\3\2\2\2\u01ce\u01c5\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0"+ + "\u01d4\7\u00da\2\2\u01d1\u01d3\5\u0082B\2\u01d2\u01d1\3\2\2\2\u01d3\u01d6"+ + "\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d4\u01d5\3\2\2\2\u01d5\u01d7\3\2\2\2\u01d6"+ + "\u01d4\3\2\2\2\u01d7\u01d8\7\u00db\2\2\u01d8\35\3\2\2\2\u01d9\u01da\t"+ + "\3\2\2\u01da\37\3\2\2\2\u01db\u01e0\5\u00c6d\2\u01dc\u01dd\7\u00dc\2\2"+ + "\u01dd\u01df\5\u00c6d\2\u01de\u01dc\3\2\2\2\u01df\u01e2\3\2\2\2\u01e0"+ + "\u01de\3\2\2\2\u01e0\u01e1\3\2\2\2\u01e1!\3\2\2\2\u01e2\u01e0\3\2\2\2"+ + "\u01e3\u01e4\7\u00a4\2\2\u01e4\u01e5\5$\23\2\u01e5\u01e6\7\u00a5\2\2\u01e6"+ + "\u01f2\3\2\2\2\u01e7\u01e8\7\u00a4\2\2\u01e8\u01e9\5&\24\2\u01e9\u01ea"+ + "\7\u00a5\2\2\u01ea\u01f2\3\2\2\2\u01eb\u01ec\7\u00a4\2\2\u01ec\u01ed\5"+ + "$\23\2\u01ed\u01ee\7\u00dc\2\2\u01ee\u01ef\5&\24\2\u01ef\u01f0\7\u00a5"+ + "\2\2\u01f0\u01f2\3\2\2\2\u01f1\u01e3\3\2\2\2\u01f1\u01e7\3\2\2\2\u01f1"+ + "\u01eb\3\2\2\2\u01f2#\3\2\2\2\u01f3\u01f8\5(\25\2\u01f4\u01f5\7\u00dc"+ + "\2\2\u01f5\u01f7\5(\25\2\u01f6\u01f4\3\2\2\2\u01f7\u01fa\3\2\2\2\u01f8"+ + "\u01f6\3\2\2\2\u01f8\u01f9\3\2\2\2\u01f9%\3\2\2\2\u01fa\u01f8\3\2\2\2"+ + "\u01fb\u0200\5*\26\2\u01fc\u01fd\7\u00dc\2\2\u01fd\u01ff\5*\26\2\u01fe"+ + "\u01fc\3\2\2\2\u01ff\u0202\3\2\2\2\u0200\u01fe\3\2\2\2\u0200\u0201\3\2"+ + "\2\2\u0201\'\3\2\2\2\u0202\u0200\3\2\2\2\u0203\u0205\5.\30\2\u0204\u0203"+ + "\3\2\2\2\u0204\u0205\3\2\2\2\u0205\u0206\3\2\2\2\u0206\u0207\5\u010a\u0086"+ + "\2\u0207)\3\2\2\2\u0208\u020a\5.\30\2\u0209\u0208\3\2\2\2\u0209\u020a"+ + "\3\2\2\2\u020a\u020b\3\2\2\2\u020b\u020c\5\u010a\u0086\2\u020c\u020f\7"+ + "\u00df\2\2\u020d\u0210\5\u00c6d\2\u020e\u0210\5\u0112\u008a\2\u020f\u020d"+ + "\3\2\2\2\u020f\u020e\3\2\2\2\u0210+\3\2\2\2\u0211\u0212\7\u00a4\2\2\u0212"+ + "\u0217\5\u00c8e\2\u0213\u0214\7\u00dc\2\2\u0214\u0216\5\u00c8e\2\u0215"+ + "\u0213\3\2\2\2\u0216\u0219\3\2\2\2\u0217\u0215\3\2\2\2\u0217\u0218\3\2"+ + "\2\2\u0218\u021a\3\2\2\2\u0219\u0217\3\2\2\2\u021a\u021b\7\u00a5\2\2\u021b"+ + "-\3\2\2\2\u021c\u021e\5\60\31\2\u021d\u021c\3\2\2\2\u021e\u021f\3\2\2"+ + "\2\u021f\u021d\3\2\2\2\u021f\u0220\3\2\2\2\u0220/\3\2\2\2\u0221\u0225"+ + "\7-\2\2\u0222\u0223\5\u010a\u0086\2\u0223\u0224\7\u00dd\2\2\u0224\u0226"+ + "\3\2\2\2\u0225\u0222\3\2\2\2\u0225\u0226\3\2\2\2\u0226\u0227\3\2\2\2\u0227"+ + "\u022c\5\62\32\2\u0228\u0229\7\u00dc\2\2\u0229\u022b\5\62\32\2\u022a\u0228"+ + "\3\2\2\2\u022b\u022e\3\2\2\2\u022c\u022a\3\2\2\2\u022c\u022d\3\2\2\2\u022d"+ + "\u022f\3\2\2\2\u022e\u022c\3\2\2\2\u022f\u0230\7\u00d9\2\2\u0230\61\3"+ + "\2\2\2\u0231\u0233\5\u00ceh\2\u0232\u0234\5\u00d6l\2\u0233\u0232\3\2\2"+ + "\2\u0233\u0234\3\2\2\2\u0234\63\3\2\2\2\u0235\u0237\5\66\34\2\u0236\u0235"+ + "\3\2\2\2\u0237\u023a\3\2\2\2\u0238\u0236\3\2\2\2\u0238\u0239\3\2\2\2\u0239"+ + "\65\3\2\2\2\u023a\u0238\3\2\2\2\u023b\u023f\58\35\2\u023c\u023f\5\32\16"+ + "\2\u023d\u023f\5\34\17\2\u023e\u023b\3\2\2\2\u023e\u023c\3\2\2\2\u023e"+ + "\u023d\3\2\2\2\u023f\67\3\2\2\2\u0240\u0241\5\u010a\u0086\2\u0241\u0242"+ + "\7\u00dd\2\2\u0242\u025c\3\2\2\2\u0243\u025c\5<\37\2\u0244\u025c\5> \2"+ + "\u0245\u025c\5H%\2\u0246\u025c\5J&\2\u0247\u025c\5L\'\2\u0248\u025c\5"+ + "R*\2\u0249\u025c\5V,\2\u024a\u025c\5X-\2\u024b\u025c\5Z.\2\u024c\u024d"+ + "\5\u00bc_\2\u024d\u024e\7\u00de\2\2\u024e\u025c\3\2\2\2\u024f\u025c\5"+ + "z>\2\u0250\u025c\5\u0080A\2\u0251\u025c\5~@\2\u0252\u025c\5\\/\2\u0253"+ + "\u025c\5^\60\2\u0254\u025c\5`\61\2\u0255\u025c\5b\62\2\u0256\u025c\5h"+ + "\65\2\u0257\u025c\5j\66\2\u0258\u025c\5l\67\2\u0259\u025c\5:\36\2\u025a"+ + "\u025c\5n8\2\u025b\u0240\3\2\2\2\u025b\u0243\3\2\2\2\u025b\u0244\3\2\2"+ + "\2\u025b\u0245\3\2\2\2\u025b\u0246\3\2\2\2\u025b\u0247\3\2\2\2\u025b\u0248"+ + "\3\2\2\2\u025b\u0249\3\2\2\2\u025b\u024a\3\2\2\2\u025b\u024b\3\2\2\2\u025b"+ + "\u024c\3\2\2\2\u025b\u024f\3\2\2\2\u025b\u0250\3\2\2\2\u025b\u0251\3\2"+ + "\2\2\u025b\u0252\3\2\2\2\u025b\u0253\3\2\2\2\u025b\u0254\3\2\2\2\u025b"+ + "\u0255\3\2\2\2\u025b\u0256\3\2\2\2\u025b\u0257\3\2\2\2\u025b\u0258\3\2"+ + "\2\2\u025b\u0259\3\2\2\2\u025b\u025a\3\2\2\2\u025c9\3\2\2\2\u025d\u025e"+ + "\7\u00de\2\2\u025e;\3\2\2\2\u025f\u0260\7\u00da\2\2\u0260\u0261\5\64\33"+ + "\2\u0261\u0262\7\u00db\2\2\u0262=\3\2\2\2\u0263\u0264\7W\2\2\u0264\u0265"+ + "\5\u00a4S\2\u0265\u0269\58\35\2\u0266\u0268\5@!\2\u0267\u0266\3\2\2\2"+ + "\u0268\u026b\3\2\2\2\u0269\u0267\3\2\2\2\u0269\u026a\3\2\2\2\u026a\u026d"+ + "\3\2\2\2\u026b\u0269\3\2\2\2\u026c\u026e\5D#\2\u026d\u026c\3\2\2\2\u026d"+ + "\u026e\3\2\2\2\u026e\u0280\3\2\2\2\u026f\u0270\7W\2\2\u0270\u0271\5\u00a4"+ + "S\2\u0271\u0272\7\u00dd\2\2\u0272\u0276\5\64\33\2\u0273\u0275\5B\"\2\u0274"+ + "\u0273\3\2\2\2\u0275\u0278\3\2\2\2\u0276\u0274\3\2\2\2\u0276\u0277\3\2"+ + "\2\2\u0277\u027a\3\2\2\2\u0278\u0276\3\2\2\2\u0279\u027b\5F$\2\u027a\u0279"+ + "\3\2\2\2\u027a\u027b\3\2\2\2\u027b\u027c\3\2\2\2\u027c\u027d\7I\2\2\u027d"+ + "\u027e\7\u00de\2\2\u027e\u0280\3\2\2\2\u027f\u0263\3\2\2\2\u027f\u026f"+ + "\3\2\2\2\u0280?\3\2\2\2\u0281\u0282\7C\2\2\u0282\u0283\5\u00a4S\2\u0283"+ + "\u0284\58\35\2\u0284A\3\2\2\2\u0285\u0286\7C\2\2\u0286\u0287\5\u00a4S"+ + "\2\u0287\u0288\7\u00dd\2\2\u0288\u0289\5\64\33\2\u0289C\3\2\2\2\u028a"+ + "\u028b\7B\2\2\u028b\u028c\58\35\2\u028cE\3\2\2\2\u028d\u028e\7B\2\2\u028e"+ + "\u028f\7\u00dd\2\2\u028f\u0290\5\64\33\2\u0290G\3\2\2\2\u0291\u0292\7"+ + "\u0084\2\2\u0292\u0299\5\u00a4S\2\u0293\u029a\58\35\2\u0294\u0295\7\u00dd"+ + "\2\2\u0295\u0296\5\64\33\2\u0296\u0297\7K\2\2\u0297\u0298\7\u00de\2\2"+ + "\u0298\u029a\3\2\2\2\u0299\u0293\3\2\2\2\u0299\u0294\3\2\2\2\u029aI\3"+ + "\2\2\2\u029b\u029c\7>\2\2\u029c\u029d\58\35\2\u029d\u029e\7\u0084\2\2"+ + "\u029e\u029f\5\u00a4S\2\u029f\u02a0\7\u00de\2\2\u02a0K\3\2\2\2\u02a1\u02a2"+ + "\7R\2\2\u02a2\u02a4\7\u00d6\2\2\u02a3\u02a5\5N(\2\u02a4\u02a3\3\2\2\2"+ + "\u02a4\u02a5\3\2\2\2\u02a5\u02a6\3\2\2\2\u02a6\u02a8\7\u00de\2\2\u02a7"+ + "\u02a9\5\u00a2R\2\u02a8\u02a7\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9\u02aa"+ + "\3\2\2\2\u02aa\u02ac\7\u00de\2\2\u02ab\u02ad\5P)\2\u02ac\u02ab\3\2\2\2"+ + "\u02ac\u02ad\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02b5\7\u00d7\2\2\u02af"+ + "\u02b6\58\35\2\u02b0\u02b1\7\u00dd\2\2\u02b1\u02b2\5\64\33\2\u02b2\u02b3"+ + "\7G\2\2\u02b3\u02b4\7\u00de\2\2\u02b4\u02b6\3\2\2\2\u02b5\u02af\3\2\2"+ + "\2\u02b5\u02b0\3\2\2\2\u02b6M\3\2\2\2\u02b7\u02b8\5\u00a2R\2\u02b8O\3"+ + "\2\2\2\u02b9\u02ba\5\u00a2R\2\u02baQ\3\2\2\2\u02bb\u02bc\7z\2\2\u02bc"+ + "\u02d4\5\u00a4S\2\u02bd\u02bf\7\u00da\2\2\u02be\u02c0\7\u00de\2\2\u02bf"+ + "\u02be\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0\u02c4\3\2\2\2\u02c1\u02c3\5T"+ + "+\2\u02c2\u02c1\3\2\2\2\u02c3\u02c6\3\2\2\2\u02c4\u02c2\3\2\2\2\u02c4"+ + "\u02c5\3\2\2\2\u02c5\u02c7\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c7\u02d5\7\u00db"+ + "\2\2\u02c8\u02ca\7\u00dd\2\2\u02c9\u02cb\7\u00de\2\2\u02ca\u02c9\3\2\2"+ + "\2\u02ca\u02cb\3\2\2\2\u02cb\u02cf\3\2\2\2\u02cc\u02ce\5T+\2\u02cd\u02cc"+ + "\3\2\2\2\u02ce\u02d1\3\2\2\2\u02cf\u02cd\3\2\2\2\u02cf\u02d0\3\2\2\2\u02d0"+ + "\u02d2\3\2\2\2\u02d1\u02cf\3\2\2\2\u02d2\u02d3\7J\2\2\u02d3\u02d5\7\u00de"+ + "\2\2\u02d4\u02bd\3\2\2\2\u02d4\u02c8\3\2\2\2\u02d5S\3\2\2\2\u02d6\u02d7"+ + "\7\66\2\2\u02d7\u02da\5\u00a6T\2\u02d8\u02da\7=\2\2\u02d9\u02d6\3\2\2"+ + "\2\u02d9\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\t\4\2\2\u02dc\u02d9"+ + "\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02dc\3\2\2\2\u02de\u02df\3\2\2\2\u02df"+ + "\u02e0\3\2\2\2\u02e0\u02e1\5\64\33\2\u02e1U\3\2\2\2\u02e2\u02e4\7\64\2"+ + "\2\u02e3\u02e5\5\u00a6T\2\u02e4\u02e3\3\2\2\2\u02e4\u02e5\3\2\2\2\u02e5"+ + "\u02e6\3\2\2\2\u02e6\u02e7\7\u00de\2\2\u02e7W\3\2\2\2\u02e8\u02ea\7;\2"+ + "\2\u02e9\u02eb\5\u00a6T\2\u02ea\u02e9\3\2\2\2\u02ea\u02eb\3\2\2\2\u02eb"+ + "\u02ec\3\2\2\2\u02ec\u02ed\7\u00de\2\2\u02edY\3\2\2\2\u02ee\u02f0\7w\2"+ + "\2\u02ef\u02f1\5\u00a6T\2\u02f0\u02ef\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1"+ + "\u02f2\3\2\2\2\u02f2\u02f3\7\u00de\2\2\u02f3[\3\2\2\2\u02f4\u02f5\5\u00a6"+ + "T\2\u02f5\u02f6\7\u00de\2\2\u02f6]\3\2\2\2\u02f7\u02f8\7\u0081\2\2\u02f8"+ + "\u02f9\7\u00d6\2\2\u02f9\u02fa\5\u00ecw\2\u02fa\u02fb\7\u00d7\2\2\u02fb"+ + "\u02fc\7\u00de\2\2\u02fc_\3\2\2\2\u02fd\u032a\7S\2\2\u02fe\u02ff\7\u00d6"+ + "\2\2\u02ff\u0300\5\u00a6T\2\u0300\u0301\7\60\2\2\u0301\u0302\5\u00acW"+ + "\2\u0302\u0303\7\u00d7\2\2\u0303\u032b\3\2\2\2\u0304\u0305\7\u00d6\2\2"+ + "\u0305\u0306\5\u00eex\2\u0306\u0308\7\60\2\2\u0307\u0309\7\u00c8\2\2\u0308"+ + "\u0307\3\2\2\2\u0308\u0309\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u0310\5\u00a8"+ + "U\2\u030b\u030d\7\u00a6\2\2\u030c\u030e\7\u00c8\2\2\u030d\u030c\3\2\2"+ + "\2\u030d\u030e\3\2\2\2\u030e\u030f\3\2\2\2\u030f\u0311\5\u00eex\2\u0310"+ + "\u030b\3\2\2\2\u0310\u0311\3\2\2\2\u0311\u0312\3\2\2\2\u0312\u0313\7\u00d7"+ + "\2\2\u0313\u032b\3\2\2\2\u0314\u0315\7\u00d6\2\2\u0315\u0316\5\u00a6T"+ + "\2\u0316\u0317\7\60\2\2\u0317\u031d\5\u00a8U\2\u0318\u031a\7\u00a6\2\2"+ + "\u0319\u031b\7\u00c8\2\2\u031a\u0319\3\2\2\2\u031a\u031b\3\2\2\2\u031b"+ + "\u031c\3\2\2\2\u031c\u031e\5\u00eex\2\u031d\u0318\3\2\2\2\u031d\u031e"+ + "\3\2\2\2\u031e\u031f\3\2\2\2\u031f\u0320\7\u00d7\2\2\u0320\u032b\3\2\2"+ + "\2\u0321\u0322\7\u00d6\2\2\u0322\u0323\5\u00eex\2\u0323\u0324\7\60\2\2"+ + "\u0324\u0325\7d\2\2\u0325\u0326\7\u00d6\2\2\u0326\u0327\5\u0104\u0083"+ + "\2\u0327\u0328\7\u00d7\2\2\u0328\u0329\7\u00d7\2\2\u0329\u032b\3\2\2\2"+ + "\u032a\u02fe\3\2\2\2\u032a\u0304\3\2\2\2\u032a\u0314\3\2\2\2\u032a\u0321"+ + "\3\2\2\2\u032b\u0332\3\2\2\2\u032c\u0333\58\35\2\u032d\u032e\7\u00dd\2"+ + "\2\u032e\u032f\5\64\33\2\u032f\u0330\7H\2\2\u0330\u0331\7\u00de\2\2\u0331"+ + "\u0333\3\2\2\2\u0332\u032c\3\2\2\2\u0332\u032d\3\2\2\2\u0333a\3\2\2\2"+ + "\u0334\u0335\7}\2\2\u0335\u0345\5<\37\2\u0336\u0338\5d\63\2\u0337\u0336"+ + "\3\2\2\2\u0338\u0339\3\2\2\2\u0339\u0337\3\2\2\2\u0339\u033a\3\2\2\2\u033a"+ + "\u033c\3\2\2\2\u033b\u033d\5f\64\2\u033c\u033b\3\2\2\2\u033c\u033d\3\2"+ + "\2\2\u033d\u0346\3\2\2\2\u033e\u0340\5d\63\2\u033f\u033e\3\2\2\2\u0340"+ + "\u0343\3\2\2\2\u0341\u033f\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0344\3\2"+ + "\2\2\u0343\u0341\3\2\2\2\u0344\u0346\5f\64\2\u0345\u0337\3\2\2\2\u0345"+ + "\u0341\3\2\2\2\u0346c\3\2\2\2\u0347\u0348\7\67\2\2\u0348\u0349\7\u00d6"+ + "\2\2\u0349\u034e\5\u00c6d\2\u034a\u034b\7\u00c9\2\2\u034b\u034d\5\u00c6"+ + "d\2\u034c\u034a\3\2\2\2\u034d\u0350\3\2\2\2\u034e\u034c\3\2\2\2\u034e"+ + "\u034f\3\2\2\2\u034f\u0352\3\2\2\2\u0350\u034e\3\2\2\2\u0351\u0353\7\u00e2"+ + "\2\2\u0352\u0351\3\2\2\2\u0352\u0353\3\2\2\2\u0353\u0354\3\2\2\2\u0354"+ + "\u0355\7\u00d7\2\2\u0355\u0356\5<\37\2\u0356e\3\2\2\2\u0357\u0358\7P\2"+ + "\2\u0358\u0359\5<\37\2\u0359g\3\2\2\2\u035a\u035b\7{\2\2\u035b\u035c\5"+ + "\u00a6T\2\u035c\u035d\7\u00de\2\2\u035di\3\2\2\2\u035e\u035f\7V\2\2\u035f"+ + "\u0360\5\u010a\u0086\2\u0360\u0361\7\u00de\2\2\u0361k\3\2\2\2\u0362\u0363"+ + "\7<\2\2\u0363\u0364\7\u00d6\2\2\u0364\u0365\5p9\2\u0365\u036c\7\u00d7"+ + "\2\2\u0366\u036d\58\35\2\u0367\u0368\7\u00dd\2\2\u0368\u0369\5\64\33\2"+ + "\u0369\u036a\7F\2\2\u036a\u036b\7\u00de\2\2\u036b\u036d\3\2\2\2\u036c"+ + "\u0366\3\2\2\2\u036c\u0367\3\2\2\2\u036dm\3\2\2\2\u036e\u0370\5\4\3\2"+ + "\u036f\u036e\3\2\2\2\u0370\u0371\3\2\2\2\u0371\u036f\3\2\2\2\u0371\u0372"+ + "\3\2\2\2\u0372o\3\2\2\2\u0373\u0378\5r:\2\u0374\u0375\7\u00dc\2\2\u0375"+ + "\u0377\5r:\2\u0376\u0374\3\2\2\2\u0377\u037a\3\2\2\2\u0378\u0376\3\2\2"+ + "\2\u0378\u0379\3\2\2\2\u0379q\3\2\2\2\u037a\u0378\3\2\2\2\u037b\u037c"+ + "\7\u0088\2\2\u037c\u037f\7\u00df\2\2\u037d\u0380\5\u00e2r\2\u037e\u0380"+ + "\7\u00e6\2\2\u037f\u037d\3\2\2\2\u037f\u037e\3\2\2\2\u0380\u0388\3\2\2"+ + "\2\u0381\u0382\7\u0089\2\2\u0382\u0383\7\u00df\2\2\u0383\u0388\7\u00ea"+ + "\2\2\u0384\u0385\7\u008a\2\2\u0385\u0386\7\u00df\2\2\u0386\u0388\5\u00e2"+ + "r\2\u0387\u037b\3\2\2\2\u0387\u0381\3\2\2\2\u0387\u0384\3\2\2\2\u0388"+ + "s\3\2\2\2\u0389\u038b\5v<\2\u038a\u0389\3\2\2\2\u038a\u038b\3\2\2\2\u038b"+ + "\u0390\3\2\2\2\u038c\u038d\7\u00dc\2\2\u038d\u038f\5v<\2\u038e\u038c\3"+ + "\2\2\2\u038f\u0392\3\2\2\2\u0390\u038e\3\2\2\2\u0390\u0391\3\2\2\2\u0391"+ + "\u0394\3\2\2\2\u0392\u0390\3\2\2\2\u0393\u0395\7\u00dc\2\2\u0394\u0393"+ + "\3\2\2\2\u0394\u0395\3\2\2\2\u0395u\3\2\2\2\u0396\u0398\5.\30\2\u0397"+ + "\u0396\3\2\2\2\u0397\u0398\3\2\2\2\u0398\u039c\3\2\2\2\u0399\u039b\5\u010c"+ + "\u0087\2\u039a\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c"+ + "\u039d\3\2\2\2\u039d\u03a0\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a1\7\u00d5"+ + "\2\2\u03a0\u039f\3\2\2\2\u03a0\u03a1\3\2\2\2\u03a1\u03a3\3\2\2\2\u03a2"+ + "\u03a4\5x=\2\u03a3\u03a2\3\2\2\2\u03a3\u03a4\3\2\2\2\u03a4\u03a6\3\2\2"+ + "\2\u03a5\u03a7\7\u00c8\2\2\u03a6\u03a5\3\2\2\2\u03a6\u03a7\3\2\2\2\u03a7"+ + "\u03a9\3\2\2\2\u03a8\u03aa\7\u00c5\2\2\u03a9\u03a8\3\2\2\2\u03a9\u03aa"+ + "\3\2\2\2\u03aa\u03ab\3\2\2\2\u03ab\u03ac\5\u0098M\2\u03acw\3\2\2\2\u03ad"+ + "\u03ae\b=\1\2\u03ae\u03b2\5\u00c6d\2\u03af\u03b2\7\65\2\2\u03b0\u03b2"+ + "\5\u0112\u008a\2\u03b1\u03ad\3\2\2\2\u03b1\u03af\3\2\2\2\u03b1\u03b0\3"+ + "\2\2\2\u03b2\u03b8\3\2\2\2\u03b3\u03b4\f\3\2\2\u03b4\u03b5\7\u00c9\2\2"+ + "\u03b5\u03b7\5x=\4\u03b6\u03b3\3\2\2\2\u03b7\u03ba\3\2\2\2\u03b8\u03b6"+ + "\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9y\3\2\2\2\u03ba\u03b8\3\2\2\2\u03bb"+ + "\u03bc\7U\2\2\u03bc\u03c1\5|?\2\u03bd\u03be\7\u00dc\2\2\u03be\u03c0\5"+ + "|?\2\u03bf\u03bd\3\2\2\2\u03c0\u03c3\3\2\2\2\u03c1\u03bf\3\2\2\2\u03c1"+ + "\u03c2\3\2\2\2\u03c2\u03c4\3\2\2\2\u03c3\u03c1\3\2\2\2\u03c4\u03c5\7\u00de"+ + "\2\2\u03c5{\3\2\2\2\u03c6\u03cf\7\u00e2\2\2\u03c7\u03c8\7\u00d3\2\2\u03c8"+ + "\u03cf\5\u00eex\2\u03c9\u03ca\7\u00d3\2\2\u03ca\u03cb\7\u00da\2\2\u03cb"+ + "\u03cc\5\u00a6T\2\u03cc\u03cd\7\u00db\2\2\u03cd\u03cf\3\2\2\2\u03ce\u03c6"+ + "\3\2\2\2\u03ce\u03c7\3\2\2\2\u03ce\u03c9\3\2\2\2\u03cf}\3\2\2\2\u03d0"+ + "\u03d1\7A\2\2\u03d1\u03d2\5\u00a2R\2\u03d2\u03d3\7\u00de\2\2\u03d3\177"+ + "\3\2\2\2\u03d4\u03d5\7x\2\2\u03d5\u03da\5\u0098M\2\u03d6\u03d7\7\u00dc"+ + "\2\2\u03d7\u03d9\5\u0098M\2\u03d8\u03d6\3\2\2\2\u03d9\u03dc\3\2\2\2\u03da"+ + "\u03d8\3\2\2\2\u03da\u03db\3\2\2\2\u03db\u03dd\3\2\2\2\u03dc\u03da\3\2"+ + "\2\2\u03dd\u03de\7\u00de\2\2\u03de\u0081\3\2\2\2\u03df\u03e1\5.\30\2\u03e0"+ + "\u03df\3\2\2\2\u03e0\u03e1\3\2\2\2\u03e1\u0414\3\2\2\2\u03e2\u03e4\5\u0094"+ + "K\2\u03e3\u03e5\5x=\2\u03e4\u03e3\3\2\2\2\u03e4\u03e5\3\2\2\2\u03e5\u03e6"+ + "\3\2\2\2\u03e6\u03eb\5\u0098M\2\u03e7\u03e8\7\u00dc\2\2\u03e8\u03ea\5"+ + "\u0098M\2\u03e9\u03e7\3\2\2\2\u03ea\u03ed\3\2\2\2\u03eb\u03e9\3\2\2\2"+ + "\u03eb\u03ec\3\2\2\2\u03ec\u03ee\3\2\2\2\u03ed\u03eb\3\2\2\2\u03ee\u03ef"+ + "\7\u00de\2\2\u03ef\u0415\3\2\2\2\u03f0\u03f2\5\u0096L\2\u03f1\u03f0\3"+ + "\2\2\2\u03f1\u03f2\3\2\2\2\u03f2\u0412\3\2\2\2\u03f3\u03f5\7:\2\2\u03f4"+ + "\u03f6\5x=\2\u03f5\u03f4\3\2\2\2\u03f5\u03f6\3\2\2\2\u03f6\u03f7\3\2\2"+ + "\2\u03f7\u03fc\5\u009aN\2\u03f8\u03f9\7\u00dc\2\2\u03f9\u03fb\5\u009a"+ + "N\2\u03fa\u03f8\3\2\2\2\u03fb\u03fe\3\2\2\2\u03fc\u03fa\3\2\2\2\u03fc"+ + "\u03fd\3\2\2\2\u03fd\u03ff\3\2\2\2\u03fe\u03fc\3\2\2\2\u03ff\u0400\7\u00de"+ + "\2\2\u0400\u0413\3\2\2\2\u0401\u0403\7T\2\2\u0402\u0404\7\u00c8\2\2\u0403"+ + "\u0402\3\2\2\2\u0403\u0404\3\2\2\2\u0404\u0405\3\2\2\2\u0405\u0407\5\u010a"+ + "\u0086\2\u0406\u0408\5\"\22\2\u0407\u0406\3\2\2\2\u0407\u0408\3\2\2\2"+ + "\u0408\u0409\3\2\2\2\u0409\u040a\7\u00d6\2\2\u040a\u040b\5t;\2\u040b\u040e"+ + "\7\u00d7\2\2\u040c\u040f\5\u008eH\2\u040d\u040f\5\u0090I\2\u040e\u040c"+ + "\3\2\2\2\u040e\u040d\3\2\2\2\u040e\u040f\3\2\2\2\u040f\u0410\3\2\2\2\u0410"+ + "\u0411\5\u0092J\2\u0411\u0413\3\2\2\2\u0412\u03f3\3\2\2\2\u0412\u0401"+ + "\3\2\2\2\u0413\u0415\3\2\2\2\u0414\u03e2\3\2\2\2\u0414\u03f1\3\2\2\2\u0415"+ + "\u041b\3\2\2\2\u0416\u0417\7\u0082\2\2\u0417\u0418\5\u00d4k\2\u0418\u0419"+ + "\5\u0084C\2\u0419\u041b\3\2\2\2\u041a\u03e0\3\2\2\2\u041a\u0416\3\2\2"+ + "\2\u041b\u0083\3\2\2\2\u041c\u0426\7\u00de\2\2\u041d\u0421\7\u00da\2\2"+ + "\u041e\u0420\5\u0086D\2\u041f\u041e\3\2\2\2\u0420\u0423\3\2\2\2\u0421"+ + "\u041f\3\2\2\2\u0421\u0422\3\2\2\2\u0422\u0424\3\2\2\2\u0423\u0421\3\2"+ + "\2\2\u0424\u0426\7\u00db\2\2\u0425\u041c\3\2\2\2\u0425\u041d\3\2\2\2\u0426"+ + "\u0085\3\2\2\2\u0427\u042a\5\u0088E\2\u0428\u042a\5\u008aF\2\u0429\u0427"+ + "\3\2\2\2\u0429\u0428\3\2\2\2\u042a\u0087\3\2\2\2\u042b\u042c\5\u00ceh"+ + "\2\u042c\u042d\7\u00c2\2\2\u042d\u042e\5\u010a\u0086\2\u042e\u042f\7]"+ + "\2\2\u042f\u0430\5\u00d4k\2\u0430\u0431\7\u00de\2\2\u0431\u0089\3\2\2"+ + "\2\u0432\u0433\5\u008cG\2\u0433\u0439\7\60\2\2\u0434\u043a\5\u010c\u0087"+ + "\2\u0435\u0437\5\u010c\u0087\2\u0436\u0435\3\2\2\2\u0436\u0437\3\2\2\2"+ + "\u0437\u0438\3\2\2\2\u0438\u043a\5\u010a\u0086\2\u0439\u0434\3\2\2\2\u0439"+ + "\u0436\3\2\2\2\u043a\u043b\3\2\2\2\u043b\u043c\7\u00de\2\2\u043c\u008b"+ + "\3\2\2\2\u043d\u043e\5\u00ceh\2\u043e\u043f\7\u00c2\2\2\u043f\u0441\3"+ + "\2\2\2\u0440\u043d\3\2\2\2\u0440\u0441\3\2\2\2\u0441\u0442\3\2\2\2\u0442"+ + "\u0443\5\u010a\u0086\2\u0443\u008d\3\2\2\2\u0444\u0445\7\u00dd\2\2\u0445"+ + "\u0447\5\u010a\u0086\2\u0446\u0448\5\u00d6l\2\u0447\u0446\3\2\2\2\u0447"+ + "\u0448\3\2\2\2\u0448\u008f\3\2\2\2\u0449\u044b\7\u00dd\2\2\u044a\u044c"+ + "\7\u00d5\2\2\u044b\u044a\3\2\2\2\u044b\u044c\3\2\2\2\u044c\u044d\3\2\2"+ + "\2\u044d\u044e\5x=\2\u044e\u0091\3\2\2\2\u044f\u0452\7\u00de\2\2\u0450"+ + "\u0452\5<\37\2\u0451\u044f\3\2\2\2\u0451\u0450\3\2\2\2\u0452\u0093\3\2"+ + "\2\2\u0453\u0456\5\u0096L\2\u0454\u0456\7\u0083\2\2\u0455\u0453\3\2\2"+ + "\2\u0455\u0454\3\2\2\2\u0456\u0095\3\2\2\2\u0457\u0459\5\u010c\u0087\2"+ + "\u0458\u0457\3\2\2\2\u0459\u045a\3\2\2\2\u045a\u0458\3\2\2\2\u045a\u045b"+ + "\3\2\2\2\u045b\u0097\3\2\2\2\u045c\u045f\7\u00e2\2\2\u045d\u045e\7\u00df"+ + "\2\2\u045e\u0460\5\u00dco\2\u045f\u045d\3\2\2\2\u045f\u0460\3\2\2\2\u0460"+ + "\u0099\3\2\2\2\u0461\u0462\5\u010a\u0086\2\u0462\u0463\7\u00df\2\2\u0463"+ + "\u0464\5\u00dco\2\u0464\u009b\3\2\2\2\u0465\u0467\5.\30\2\u0466\u0465"+ + "\3\2\2\2\u0466\u0467\3\2\2\2\u0467\u0468\3\2\2\2\u0468\u0469\7:\2\2\u0469"+ + "\u046e\5\u009aN\2\u046a\u046b\7\u00dc\2\2\u046b\u046d\5\u009aN\2\u046c"+ + "\u046a\3\2\2\2\u046d\u0470\3\2\2\2\u046e\u046c\3\2\2\2\u046e\u046f\3\2"+ + "\2\2\u046f\u0471\3\2\2\2\u0470\u046e\3\2\2\2\u0471\u0472\7\u00de\2\2\u0472"+ + "\u009d\3\2\2\2\u0473\u0474\7E\2\2\u0474\u0477\5\u010a\u0086\2\u0475\u0476"+ + "\7\u00dd\2\2\u0476\u0478\t\5\2\2\u0477\u0475\3\2\2\2\u0477\u0478\3\2\2"+ + "\2\u0478\u047b\3\2\2\2\u0479\u047a\7X\2\2\u047a\u047c\5 \21\2\u047b\u0479"+ + "\3\2\2\2\u047b\u047c\3\2\2\2\u047c\u047d\3\2\2\2\u047d\u0481\7\u00da\2"+ + "\2\u047e\u0480\5\u00a0Q\2\u047f\u047e\3\2\2\2\u0480\u0483\3\2\2\2\u0481"+ + "\u047f\3\2\2\2\u0481\u0482\3\2\2\2\u0482\u0484\3\2\2\2\u0483\u0481\3\2"+ + "\2\2\u0484\u0485\7\u00db\2\2\u0485\u009f\3\2\2\2\u0486\u0487\7\66\2\2"+ + "\u0487\u048a\5\u010a\u0086\2\u0488\u0489\7\u00df\2\2\u0489\u048b\5\u00a6"+ + "T\2\u048a\u0488\3\2\2\2\u048a\u048b\3\2\2\2\u048b\u048c\3\2\2\2\u048c"+ + "\u048d\7\u00de\2\2\u048d\u0497\3\2\2\2\u048e\u0490\5\u0096L\2\u048f\u048e"+ + "\3\2\2\2\u048f\u0490\3\2\2\2\u0490\u0491\3\2\2\2\u0491\u0497\5\32\16\2"+ + "\u0492\u0493\7\u0082\2\2\u0493\u0494\5\u00d4k\2\u0494\u0495\5\u0084C\2"+ + "\u0495\u0497\3\2\2\2\u0496\u0486\3\2\2\2\u0496\u048f\3\2\2\2\u0496\u0492"+ + "\3\2\2\2\u0497\u00a1\3\2\2\2\u0498\u049d\5\u00a6T\2\u0499\u049a\7\u00dc"+ + "\2\2\u049a\u049c\5\u00a6T\2\u049b\u0499\3\2\2\2\u049c\u049f\3\2\2\2\u049d"+ + "\u049b\3\2\2\2\u049d\u049e\3\2\2\2\u049e\u00a3\3\2\2\2\u049f\u049d\3\2"+ + "\2\2\u04a0\u04a3\7\u00d6\2\2\u04a1\u04a4\5\u00a6T\2\u04a2\u04a4\5\u00bc"+ + "_\2\u04a3\u04a1\3\2\2\2\u04a3\u04a2\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5"+ + "\u04a6\7\u00d7\2\2\u04a6\u00a5\3\2\2\2\u04a7\u04a8\bT\1\2\u04a8\u04a9"+ + "\79\2\2\u04a9\u0502\5\u00a6T\62\u04aa\u04ab\7\u00d6\2\2\u04ab\u04ac\5"+ + "\u0114\u008b\2\u04ac\u04ad\7\u00d7\2\2\u04ad\u04ae\5\u00a6T/\u04ae\u0502"+ + "\3\2\2\2\u04af\u04b0\t\6\2\2\u04b0\u0502\5\u00a6T.\u04b1\u04b2\t\7\2\2"+ + "\u04b2\u0502\5\u00a6T-\u04b3\u04b4\7o\2\2\u04b4\u0502\5\u00a6T*\u04b5"+ + "\u04b6\7d\2\2\u04b6\u04b7\7\u00d6\2\2\u04b7\u04b8\5\u0104\u0083\2\u04b8"+ + "\u04b9\7\u00d7\2\2\u04b9\u04ba\7\u00df\2\2\u04ba\u04bb\5\u00a6T!\u04bb"+ + "\u0502\3\2\2\2\u04bc\u04bd\t\b\2\2\u04bd\u0502\5\u00a6T\34\u04be\u04bf"+ + "\t\t\2\2\u04bf\u0502\5\u00a6T\33\u04c0\u04c1\7{\2\2\u04c1\u0502\5\u00a6"+ + "T\t\u04c2\u04c3\5\u00acW\2\u04c3\u04c4\7\u00df\2\2\u04c4\u04c5\5\u00a6"+ + "T\b\u04c5\u0502\3\2\2\2\u04c6\u04c7\5\u00a8U\2\u04c7\u04c9\5\u00ba^\2"+ + "\u04c8\u04ca\5.\30\2\u04c9\u04c8\3\2\2\2\u04c9\u04ca\3\2\2\2\u04ca\u04cb"+ + "\3\2\2\2\u04cb\u04cc\5\u00a6T\7\u04cc\u0502\3\2\2\2\u04cd\u0502\5\u00b8"+ + "]\2\u04ce\u04cf\5\u00e6t\2\u04cf\u04d0\7\u00d8\2\2\u04d0\u04d1\5\u00a6"+ + "T\2\u04d1\u04d2\7\u00d9\2\2\u04d2\u0502\3\2\2\2\u04d3\u04d4\t\n\2\2\u04d4"+ + "\u0502\5\u00eex\2\u04d5\u04d6\5\u00eex\2\u04d6\u04d7\t\n\2\2\u04d7\u0502"+ + "\3\2\2\2\u04d8\u0502\5\u00aaV\2\u04d9\u0502\5\u00eex\2\u04da\u0502\5\u00de"+ + "p\2\u04db\u0502\5\u00e8u\2\u04dc\u0502\7\u00e3\2\2\u04dd\u0502\7\u00e9"+ + "\2\2\u04de\u0502\5\u00a4S\2\u04df\u0502\7\u0085\2\2\u04e0\u04e1\7c\2\2"+ + "\u04e1\u04e2\7\u00d6\2\2\u04e2\u04e3\5\u00ecw\2\u04e3\u04e4\7\u00d7\2"+ + "\2\u04e4\u0502\3\2\2\2\u04e5\u04e6\7D\2\2\u04e6\u04e7\7\u00d6\2\2\u04e7"+ + "\u04e8\5\u00eex\2\u04e8\u04e9\7\u00d7\2\2\u04e9\u0502\3\2\2\2\u04ea\u04eb"+ + "\7L\2\2\u04eb\u04ec\7\u00d6\2\2\u04ec\u04ed\5\u00a6T\2\u04ed\u04ee\7\u00d7"+ + "\2\2\u04ee\u0502\3\2\2\2\u04ef\u04f3\7M\2\2\u04f0\u04f1\7\u00d6\2\2\u04f1"+ + "\u04f4\7\u00d7\2\2\u04f2\u04f4\5\u00a4S\2\u04f3\u04f0\3\2\2\2\u04f3\u04f2"+ + "\3\2\2\2\u04f3\u04f4\3\2\2\2\u04f4\u0502\3\2\2\2\u04f5\u0502\5\u00b2Z"+ + "\2\u04f6\u0502\5\u00b4[\2\u04f7\u04f8\5\u00a8U\2\u04f8\u04fa\7\u00df\2"+ + "\2\u04f9\u04fb\5.\30\2\u04fa\u04f9\3\2\2\2\u04fa\u04fb\3\2\2\2\u04fb\u04fc"+ + "\3\2\2\2\u04fc\u04ff\7\u00c8\2\2\u04fd\u0500\5\u00eex\2\u04fe\u0500\5"+ + "\u00b8]\2\u04ff\u04fd\3\2\2\2\u04ff\u04fe\3\2\2\2\u0500\u0502\3\2\2\2"+ + "\u0501\u04a7\3\2\2\2\u0501\u04aa\3\2\2\2\u0501\u04af\3\2\2\2\u0501\u04b1"+ + "\3\2\2\2\u0501\u04b3\3\2\2\2\u0501\u04b5\3\2\2\2\u0501\u04bc\3\2\2\2\u0501"+ + "\u04be\3\2\2\2\u0501\u04c0\3\2\2\2\u0501\u04c2\3\2\2\2\u0501\u04c6\3\2"+ + "\2\2\u0501\u04cd\3\2\2\2\u0501\u04ce\3\2\2\2\u0501\u04d3\3\2\2\2\u0501"+ + "\u04d5\3\2\2\2\u0501\u04d8\3\2\2\2\u0501\u04d9\3\2\2\2\u0501\u04da\3\2"+ + "\2\2\u0501\u04db\3\2\2\2\u0501\u04dc\3\2\2\2\u0501\u04dd\3\2\2\2\u0501"+ + "\u04de\3\2\2\2\u0501\u04df\3\2\2\2\u0501\u04e0\3\2\2\2\u0501\u04e5\3\2"+ + "\2\2\u0501\u04ea\3\2\2\2\u0501\u04ef\3\2\2\2\u0501\u04f5\3\2\2\2\u0501"+ + "\u04f6\3\2\2\2\u0501\u04f7\3\2\2\2\u0502\u053f\3\2\2\2\u0503\u0504\f\30"+ + "\2\2\u0504\u0505\7\u00b2\2\2\u0505\u053e\5\u00a6T\30\u0506\u0507\f\26"+ + "\2\2\u0507\u0508\t\13\2\2\u0508\u053e\5\u00a6T\27\u0509\u050a\f\25\2\2"+ + "\u050a\u050b\t\f\2\2\u050b\u053e\5\u00a6T\26\u050c\u050d\f\24\2\2\u050d"+ + "\u050e\t\r\2\2\u050e\u053e\5\u00a6T\25\u050f\u0510\f\23\2\2\u0510\u0511"+ + "\t\16\2\2\u0511\u053e\5\u00a6T\24\u0512\u0513\f\22\2\2\u0513\u0514\t\17"+ + "\2\2\u0514\u053e\5\u00a6T\23\u0515\u0516\f\21\2\2\u0516\u0517\7\u00c8"+ + "\2\2\u0517\u053e\5\u00a6T\22\u0518\u0519\f\20\2\2\u0519\u051a\7\u00cb"+ + "\2\2\u051a\u053e\5\u00a6T\21\u051b\u051c\f\17\2\2\u051c\u051d\7\u00c9"+ + "\2\2\u051d\u053e\5\u00a6T\20\u051e\u051f\f\16\2\2\u051f\u0520\7\u00bd"+ + "\2\2\u0520\u053e\5\u00a6T\17\u0521\u0522\f\r\2\2\u0522\u0523\7\u00bc\2"+ + "\2\u0523\u053e\5\u00a6T\16\u0524\u0525\f\f\2\2\u0525\u0527\7\u00d5\2\2"+ + "\u0526\u0528\5\u00a6T\2\u0527\u0526\3\2\2\2\u0527\u0528\3\2\2\2\u0528"+ + "\u0529\3\2\2\2\u0529\u052a\7\u00dd\2\2\u052a\u053e\5\u00a6T\r\u052b\u052c"+ + "\f\13\2\2\u052c\u052d\7\u00be\2\2\u052d\u053e\5\u00a6T\f\u052e\u052f\f"+ + "\n\2\2\u052f\u0530\7\u00a3\2\2\u0530\u053e\5\u00a6T\13\u0531\u0532\f\5"+ + "\2\2\u0532\u0533\7e\2\2\u0533\u053e\5\u00a6T\6\u0534\u0535\f\4\2\2\u0535"+ + "\u0536\7g\2\2\u0536\u053e\5\u00a6T\5\u0537\u0538\f\3\2\2\u0538\u0539\7"+ + "f\2\2\u0539\u053e\5\u00a6T\4\u053a\u053b\f\27\2\2\u053b\u053c\7\\\2\2"+ + "\u053c\u053e\5\u00c8e\2\u053d\u0503\3\2\2\2\u053d\u0506\3\2\2\2\u053d"+ + "\u0509\3\2\2\2\u053d\u050c\3\2\2\2\u053d\u050f\3\2\2\2\u053d\u0512\3\2"+ + "\2\2\u053d\u0515\3\2\2\2\u053d\u0518\3\2\2\2\u053d\u051b\3\2\2\2\u053d"+ + "\u051e\3\2\2\2\u053d\u0521\3\2\2\2\u053d\u0524\3\2\2\2\u053d\u052b\3\2"+ + "\2\2\u053d\u052e\3\2\2\2\u053d\u0531\3\2\2\2\u053d\u0534\3\2\2\2\u053d"+ + "\u0537\3\2\2\2\u053d\u053a\3\2\2\2\u053e\u0541\3\2\2\2\u053f\u053d\3\2"+ + "\2\2\u053f\u0540\3\2\2\2\u0540\u00a7\3\2\2\2\u0541\u053f\3\2\2\2\u0542"+ + "\u0545\5\u00eex\2\u0543\u0545\5\u00aaV\2\u0544\u0542\3\2\2\2\u0544\u0543"+ + "\3\2\2\2\u0545\u00a9\3\2\2\2\u0546\u0547\7/\2\2\u0547\u0549\7\u00d6\2"+ + "\2\u0548\u054a\5\u00be`\2\u0549\u0548\3\2\2\2\u0549\u054a\3\2\2\2\u054a"+ + "\u054b\3\2\2\2\u054b\u0552\7\u00d7\2\2\u054c\u054e\7\u00d8\2\2\u054d\u054f"+ + "\5\u00be`\2\u054e\u054d\3\2\2\2\u054e\u054f\3\2\2\2\u054f\u0550\3\2\2"+ + "\2\u0550\u0552\7\u00d9\2\2\u0551\u0546\3\2\2\2\u0551\u054c\3\2\2\2\u0552"+ + "\u0557\3\2\2\2\u0553\u0554\7\u00d8\2\2\u0554\u0555\5\u00a6T\2\u0555\u0556"+ + "\7\u00d9\2\2\u0556\u0558\3\2\2\2\u0557\u0553\3\2\2\2\u0557\u0558\3\2\2"+ + "\2\u0558\u00ab\3\2\2\2\u0559\u055d\7\u00d8\2\2\u055a\u055c\7\u00dc\2\2"+ + "\u055b\u055a\3\2\2\2\u055c\u055f\3\2\2\2\u055d\u055b\3\2\2\2\u055d\u055e"+ + "\3\2\2\2\u055e\u0560\3\2\2\2\u055f\u055d\3\2\2\2\u0560\u0569\5\u00aeX"+ + "\2\u0561\u0563\7\u00dc\2\2\u0562\u0561\3\2\2\2\u0563\u0564\3\2\2\2\u0564"+ + "\u0562\3\2\2\2\u0564\u0565\3\2\2\2\u0565\u0566\3\2\2\2\u0566\u0568\5\u00ae"+ + "X\2\u0567\u0562\3\2\2\2\u0568\u056b\3\2\2\2\u0569\u0567\3\2\2\2\u0569"+ + "\u056a\3\2\2\2\u056a\u056f\3\2\2\2\u056b\u0569\3\2\2\2\u056c\u056e\7\u00dc"+ + "\2\2\u056d\u056c\3\2\2\2\u056e\u0571\3\2\2\2\u056f\u056d\3\2\2\2\u056f"+ + "\u0570\3\2\2\2\u0570\u0572\3\2\2\2\u0571\u056f\3\2\2\2\u0572\u0573\7\u00d9"+ + "\2\2\u0573\u0587\3\2\2\2\u0574\u0575\7\u00d8\2\2\u0575\u057e\5\u00b0Y"+ + "\2\u0576\u0578\7\u00dc\2\2\u0577\u0576\3\2\2\2\u0578\u0579\3\2\2\2\u0579"+ + "\u0577\3\2\2\2\u0579\u057a\3\2\2\2\u057a\u057b\3\2\2\2\u057b\u057d\5\u00b0"+ + "Y\2\u057c\u0577\3\2\2\2\u057d\u0580\3\2\2\2\u057e\u057c\3\2\2\2\u057e"+ + "\u057f\3\2\2\2\u057f\u0582\3\2\2\2\u0580\u057e\3\2\2\2\u0581\u0583\7\u00dc"+ + "\2\2\u0582\u0581\3\2\2\2\u0582\u0583\3\2\2\2\u0583\u0584\3\2\2\2\u0584"+ + "\u0585\7\u00d9\2\2\u0585\u0587\3\2\2\2\u0586\u0559\3\2\2\2\u0586\u0574"+ + "\3\2\2\2\u0587\u00ad\3\2\2\2\u0588\u058a\7\u00c8\2\2\u0589\u0588\3\2\2"+ + "\2\u0589\u058a\3\2\2\2\u058a\u058b\3\2\2\2\u058b\u058c\5\u00eex\2\u058c"+ + "\u00af\3\2\2\2\u058d\u058e\5\u00a6T\2\u058e\u058f\7\u00a6\2\2\u058f\u0591"+ + "\3\2\2\2\u0590\u058d\3\2\2\2\u0590\u0591\3\2\2\2\u0591\u0593\3\2\2\2\u0592"+ + "\u0594\7\u00c8\2\2\u0593\u0592\3\2\2\2\u0593\u0594\3\2\2\2\u0594\u0595"+ + "\3\2\2\2\u0595\u0596\5\u00eex\2\u0596\u00b1\3\2\2\2\u0597\u0599\7x\2\2"+ + "\u0598\u0597\3\2\2\2\u0598\u0599\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c"+ + "\7T\2\2\u059b\u059d\7\u00c8\2\2\u059c\u059b\3\2\2\2\u059c\u059d\3\2\2"+ + "\2\u059d\u059e\3\2\2\2\u059e\u059f\7\u00d6\2\2\u059f\u05a0\5t;\2\u05a0"+ + "\u05a2\7\u00d7\2\2\u05a1\u05a3\5\u00c2b\2\u05a2\u05a1\3\2\2\2\u05a2\u05a3"+ + "\3\2\2\2\u05a3\u05a6\3\2\2\2\u05a4\u05a5\7\u00dd\2\2\u05a5\u05a7\5x=\2"+ + "\u05a6\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a8\3\2\2\2\u05a8\u05a9"+ + "\5<\37\2\u05a9\u05b2\3\2\2\2\u05aa\u05ab\7\u0087\2\2\u05ab\u05ac\7\u00d6"+ + "\2\2\u05ac\u05ad\5t;\2\u05ad\u05ae\7\u00d7\2\2\u05ae\u05af\7\u00a6\2\2"+ + "\u05af\u05b0\5\u00a6T\2\u05b0\u05b2\3\2\2\2\u05b1\u0598\3\2\2\2\u05b1"+ + "\u05aa\3\2\2\2\u05b2\u00b3\3\2\2\2\u05b3\u05b4\7h\2\2\u05b4\u05b5\7\u00d6"+ + "\2\2\u05b5\u05b6\5\u00a6T\2\u05b6\u05b7\7\u00d7\2\2\u05b7\u05b8\7\u00da"+ + "\2\2\u05b8\u05bd\5\u00b6\\\2\u05b9\u05ba\7\u00dc\2\2\u05ba\u05bc\5\u00b6"+ + "\\\2\u05bb\u05b9\3\2\2\2\u05bc\u05bf\3\2\2\2\u05bd\u05bb\3\2\2\2\u05bd"+ + "\u05be\3\2\2\2\u05be\u05c1\3\2\2\2\u05bf\u05bd\3\2\2\2\u05c0\u05c2\7\u00dc"+ + "\2\2\u05c1\u05c0\3\2\2\2\u05c1\u05c2\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3"+ + "\u05c4\7\u00db\2\2\u05c4\u00b5\3\2\2\2\u05c5\u05ca\5\u00a6T\2\u05c6\u05c7"+ + "\7\u00dc\2\2\u05c7\u05c9\5\u00a6T\2\u05c8\u05c6\3\2\2\2\u05c9\u05cc\3"+ + "\2\2\2\u05ca\u05c8\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05cd\3\2\2\2\u05cc"+ + "\u05ca\3\2\2\2\u05cd\u05ce\7\u00a6\2\2\u05ce\u05cf\5\u00a6T\2\u05cf\u00b7"+ + "\3\2\2\2\u05d0\u05d1\7j\2\2\u05d1\u05d3\5\u00c8e\2\u05d2\u05d4\5\u00d6"+ + "l\2\u05d3\u05d2\3\2\2\2\u05d3\u05d4\3\2\2\2\u05d4\u00b9\3\2\2\2\u05d5"+ + "\u05d6\t\20\2\2\u05d6\u00bb\3\2\2\2\u05d7\u05df\7\u0085\2\2\u05d8\u05db"+ + "\5\u00a6T\2\u05d9\u05da\7\u00a6\2\2\u05da\u05dc\5\u00a6T\2\u05db\u05d9"+ + "\3\2\2\2\u05db\u05dc\3\2\2\2\u05dc\u05e0\3\2\2\2\u05dd\u05de\7\u0086\2"+ + "\2\u05de\u05e0\5\u00a6T\2\u05df\u05d8\3\2\2\2\u05df\u05dd\3\2\2\2\u05e0"+ + "\u00bd\3\2\2\2\u05e1\u05e6\5\u00c0a\2\u05e2\u05e3\7\u00dc\2\2\u05e3\u05e5"+ + "\5\u00c0a\2\u05e4\u05e2\3\2\2\2\u05e5\u05e8\3\2\2\2\u05e6\u05e4\3\2\2"+ + "\2\u05e6\u05e7\3\2\2\2\u05e7\u05ea\3\2\2\2\u05e8\u05e6\3\2\2\2\u05e9\u05eb"+ + "\7\u00dc\2\2\u05ea\u05e9\3\2\2\2\u05ea\u05eb\3\2\2\2\u05eb\u00bf\3\2\2"+ + "\2\u05ec\u05ef\5\u00a6T\2\u05ed\u05ee\7\u00a6\2\2\u05ee\u05f0\5\u00a6"+ + "T\2\u05ef\u05ed\3\2\2\2\u05ef\u05f0\3\2\2\2\u05f0\u05f9\3\2\2\2\u05f1"+ + "\u05f2\5\u00a6T\2\u05f2\u05f3\7\u00a6\2\2\u05f3\u05f5\3\2\2\2\u05f4\u05f1"+ + "\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5\u05f6\3\2\2\2\u05f6\u05f7\7\u00c8\2"+ + "\2\u05f7\u05f9\5\u00eex\2\u05f8\u05ec\3\2\2\2\u05f8\u05f4\3\2\2\2\u05f9"+ + "\u00c1\3\2\2\2\u05fa\u05fb\7\u0082\2\2\u05fb\u05fc\7\u00d6\2\2\u05fc\u0601"+ + "\5\u00c4c\2\u05fd\u05fe\7\u00dc\2\2\u05fe\u0600\5\u00c4c\2\u05ff\u05fd"+ + "\3\2\2\2\u0600\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602"+ + "\u0604\3\2\2\2\u0603\u0601\3\2\2\2\u0604\u0605\7\u00d7\2\2\u0605\u00c3"+ + "\3\2\2\2\u0606\u0608\7\u00c8\2\2\u0607\u0606\3\2\2\2\u0607\u0608\3\2\2"+ + "\2\u0608\u0609\3\2\2\2\u0609\u060a\7\u00e2\2\2\u060a\u00c5\3\2\2\2\u060b"+ + "\u060d\5\u00ceh\2\u060c\u060e\5,\27\2\u060d\u060c\3\2\2\2\u060d\u060e"+ + "\3\2\2\2\u060e\u0611\3\2\2\2\u060f\u0611\7x\2\2\u0610\u060b\3\2\2\2\u0610"+ + "\u060f\3\2\2\2\u0611\u00c7\3\2\2\2\u0612\u0615\5\u00ceh\2\u0613\u0615"+ + "\5\u00ccg\2\u0614\u0612\3\2\2\2\u0614\u0613\3\2\2\2\u0615\u0617\3\2\2"+ + "\2\u0616\u0618\5,\27\2\u0617\u0616\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u061d"+ + "\3\2\2\2\u0619\u061d\5\u0112\u008a\2\u061a\u061d\7x\2\2\u061b\u061d\5"+ + "\u00caf\2\u061c\u0614\3\2\2\2\u061c\u0619\3\2\2\2\u061c\u061a\3\2\2\2"+ + "\u061c\u061b\3\2\2\2\u061d\u00c9\3\2\2\2\u061e\u0620\5.\30\2\u061f\u061e"+ + "\3\2\2\2\u061f\u0620\3\2\2\2\u0620\u0622\3\2\2\2\u0621\u0623\7p\2\2\u0622"+ + "\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2\2\2\u0624\u0626\5\u0108"+ + "\u0085\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626\u0628\3\2\2\2\u0627"+ + "\u0629\7n\2\2\u0628\u0627\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u063f\3\2"+ + "\2\2\u062a\u062c\5\36\20\2\u062b\u062d\5\"\22\2\u062c\u062b\3\2\2\2\u062c"+ + "\u062d\3\2\2\2\u062d\u0630\3\2\2\2\u062e\u062f\7N\2\2\u062f\u0631\5\u00c6"+ + "d\2\u0630\u062e\3\2\2\2\u0630\u0631\3\2\2\2\u0631\u0634\3\2\2\2\u0632"+ + "\u0633\7X\2\2\u0633\u0635\5 \21\2\u0634\u0632\3\2\2\2\u0634\u0635\3\2"+ + "\2\2\u0635\u0640\3\2\2\2\u0636\u0637\7b\2\2\u0637\u0639\5\u010a\u0086"+ + "\2\u0638\u063a\5\"\22\2\u0639\u0638\3\2\2\2\u0639\u063a\3\2\2\2\u063a"+ + "\u063d\3\2\2\2\u063b\u063c\7N\2\2\u063c\u063e\5 \21\2\u063d\u063b\3\2"+ + "\2\2\u063d\u063e\3\2\2\2\u063e\u0640\3\2\2\2\u063f\u062a\3\2\2\2\u063f"+ + "\u0636\3\2\2\2\u0640\u0641\3\2\2\2\u0641\u0645\7\u00da\2\2\u0642\u0644"+ + "\5\u0082B\2\u0643\u0642\3\2\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2"+ + "\2\u0645\u0646\3\2\2\2\u0646\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649"+ + "\7\u00db\2\2\u0649\u00cb\3\2\2\2\u064a\u064f\5\u00fa~\2\u064b\u064c\7"+ + "\u00c3\2\2\u064c\u064e\5\u00fc\177\2\u064d\u064b\3\2\2\2\u064e\u0651\3"+ + "\2\2\2\u064f\u064d\3\2\2\2\u064f\u0650\3\2\2\2\u0650\u00cd\3\2\2\2\u0651"+ + "\u064f\3\2\2\2\u0652\u0654\7i\2\2\u0653\u0652\3\2\2\2\u0653\u0654\3\2"+ + "\2\2\u0654\u0656\3\2\2\2\u0655\u0657\7\u00c4\2\2\u0656\u0655\3\2\2\2\u0656"+ + "\u0657\3\2\2\2\u0657\u0658\3\2\2\2\u0658\u0659\5\u00d0i\2\u0659\u00cf"+ + "\3\2\2\2\u065a\u0668\5\u010a\u0086\2\u065b\u0660\5\u010a\u0086\2\u065c"+ + "\u065d\7\u00c4\2\2\u065d\u065f\5\u010a\u0086\2\u065e\u065c\3\2\2\2\u065f"+ + "\u0662\3\2\2\2\u0660\u065e\3\2\2\2\u0660\u0661\3\2\2\2\u0661\u0665\3\2"+ + "\2\2\u0662\u0660\3\2\2\2\u0663\u0664\7\u00c4\2\2\u0664\u0666\5\u00d2j"+ + "\2\u0665\u0663\3\2\2\2\u0665\u0666\3\2\2\2\u0666\u0668\3\2\2\2\u0667\u065a"+ + "\3\2\2\2\u0667\u065b\3\2\2\2\u0668\u00d1\3\2\2\2\u0669\u066c\5\u010a\u0086"+ + "\2\u066a\u066b\7\60\2\2\u066b\u066d\5\u010a\u0086\2\u066c\u066a\3\2\2"+ + "\2\u066c\u066d\3\2\2\2\u066d\u067d\3\2\2\2\u066e\u066f\7\u00da\2\2\u066f"+ + "\u0674\5\u00d2j\2\u0670\u0671\7\u00dc\2\2\u0671\u0673\5\u00d2j\2\u0672"+ + "\u0670\3\2\2\2\u0673\u0676\3\2\2\2\u0674\u0672\3\2\2\2\u0674\u0675\3\2"+ + "\2\2\u0675\u0678\3\2\2\2\u0676\u0674\3\2\2\2\u0677\u0679\7\u00dc\2\2\u0678"+ + "\u0677\3\2\2\2\u0678\u0679\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067b\7\u00db"+ + "\2\2\u067b\u067d\3\2\2\2\u067c\u0669\3\2\2\2\u067c\u066e\3\2\2\2\u067d"+ + "\u00d3\3\2\2\2\u067e\u0683\5\u00ceh\2\u067f\u0680\7\u00dc\2\2\u0680\u0682"+ + "\5\u00ceh\2\u0681\u067f\3\2\2\2\u0682\u0685\3\2\2\2\u0683\u0681\3\2\2"+ + "\2\u0683\u0684\3\2\2\2\u0684\u00d5\3\2\2\2\u0685\u0683\3\2\2\2\u0686\u0690"+ + "\7\u00d6\2\2\u0687\u068c\5\u00d8m\2\u0688\u0689\7\u00dc\2\2\u0689\u068b"+ + "\5\u00d8m\2\u068a\u0688\3\2\2\2\u068b\u068e\3\2\2\2\u068c\u068a\3\2\2"+ + "\2\u068c\u068d\3\2\2\2\u068d\u0691\3\2\2\2\u068e\u068c\3\2\2\2\u068f\u0691"+ + "\5\u00bc_\2\u0690\u0687\3\2\2\2\u0690\u068f\3\2\2\2\u0690\u0691\3\2\2"+ + "\2\u0691\u0693\3\2\2\2\u0692\u0694\7\u00dc\2\2\u0693\u0692\3\2\2\2\u0693"+ + "\u0694\3\2\2\2\u0694\u0695\3\2\2\2\u0695\u0696\7\u00d7\2\2\u0696\u00d7"+ + "\3\2\2\2\u0697\u0699\5\u00dan\2\u0698\u0697\3\2\2\2\u0698\u0699\3\2\2"+ + "\2\u0699\u069b\3\2\2\2\u069a\u069c\7\u00c5\2\2\u069b\u069a\3\2\2\2\u069b"+ + "\u069c\3\2\2\2\u069c\u069d\3\2\2\2\u069d\u06a1\5\u00a6T\2\u069e\u069f"+ + "\7\u00c8\2\2\u069f\u06a1\5\u00eex\2\u06a0\u0698\3\2\2\2\u06a0\u069e\3"+ + "\2\2\2\u06a1\u00d9\3\2\2\2\u06a2\u06a3\5\u010a\u0086\2\u06a3\u06a4\7\u00dd"+ + "\2\2\u06a4\u00db\3\2\2\2\u06a5\u06c9\5\u00dep\2\u06a6\u06c9\5\u00e8u\2"+ + "\u06a7\u06a8\7/\2\2\u06a8\u06ad\7\u00d6\2\2\u06a9\u06ab\5\u00be`\2\u06aa"+ + "\u06ac\7\u00dc\2\2\u06ab\u06aa\3\2\2\2\u06ab\u06ac\3\2\2\2\u06ac\u06ae"+ + "\3\2\2\2\u06ad\u06a9\3\2\2\2\u06ad\u06ae\3\2\2\2\u06ae\u06af\3\2\2\2\u06af"+ + "\u06c9\7\u00d7\2\2\u06b0\u06b5\7\u00d8\2\2\u06b1\u06b3\5\u00be`\2\u06b2"+ + "\u06b4\7\u00dc\2\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4\u06b6"+ + "\3\2\2\2\u06b5\u06b1\3\2\2\2\u06b5\u06b6\3\2\2\2\u06b6\u06b7\3\2\2\2\u06b7"+ + "\u06c9\7\u00d9\2\2\u06b8\u06b9\t\21\2\2\u06b9\u06c9\5\u00dco\2\u06ba\u06bd"+ + "\5\u00e8u\2\u06bb\u06bd\5\u00dep\2\u06bc\u06ba\3\2\2\2\u06bc\u06bb\3\2"+ + "\2\2\u06bd\u06c5\3\2\2\2\u06be\u06c1\7\u00d4\2\2\u06bf\u06c2\5\u00e8u"+ + "\2\u06c0\u06c2\5\u00dep\2\u06c1\u06bf\3\2\2\2\u06c1\u06c0\3\2\2\2\u06c2"+ + "\u06c4\3\2\2\2\u06c3\u06be\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2"+ + "\2\2\u06c5\u06c6\3\2\2\2\u06c6\u06c9\3\2\2\2\u06c7\u06c5\3\2\2\2\u06c8"+ + "\u06a5\3\2\2\2\u06c8\u06a6\3\2\2\2\u06c8\u06a7\3\2\2\2\u06c8\u06b0\3\2"+ + "\2\2\u06c8\u06b8\3\2\2\2\u06c8\u06bc\3\2\2\2\u06c9\u00dd\3\2\2\2\u06ca"+ + "\u06d0\7k\2\2\u06cb\u06d0\5\u00e0q\2\u06cc\u06d0\5\u010e\u0088\2\u06cd"+ + "\u06d0\5\u00e4s\2\u06ce\u06d0\5\u00ceh\2\u06cf\u06ca\3\2\2\2\u06cf\u06cb"+ + "\3\2\2\2\u06cf\u06cc\3\2\2\2\u06cf\u06cd\3\2\2\2\u06cf\u06ce\3\2\2\2\u06d0"+ + "\u00df\3\2\2\2\u06d1\u06d6\7\u00e6\2\2\u06d2\u06d6\7\63\2\2\u06d3\u06d6"+ + "\5\u00e2r\2\u06d4\u06d6\5\u00e6t\2\u06d5\u06d1\3\2\2\2\u06d5\u06d2\3\2"+ + "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d4\3\2\2\2\u06d6\u00e1\3\2\2\2\u06d7"+ + "\u06d8\t\22\2\2\u06d8\u00e3\3\2\2\2\u06d9\u06da\t\23\2\2\u06da\u06df\7"+ + "\u00c2\2\2\u06db\u06e0\5\u010a\u0086\2\u06dc\u06e0\7\u008f\2\2\u06dd\u06e0"+ + "\7\u008b\2\2\u06de\u06e0\7\u008c\2\2\u06df\u06db\3\2\2\2\u06df\u06dc\3"+ + "\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06de\3\2\2\2\u06e0\u06ec\3\2\2\2\u06e1"+ + "\u06e5\5\u00c6d\2\u06e2\u06e5\5\u0100\u0081\2\u06e3\u06e5\5\u00e8u\2\u06e4"+ + "\u06e1\3\2\2\2\u06e4\u06e2\3\2\2\2\u06e4\u06e3\3\2\2\2\u06e5\u06e6\3\2"+ + "\2\2\u06e6\u06e9\7\u00c2\2\2\u06e7\u06ea\5\u010a\u0086\2\u06e8\u06ea\5"+ + "\u0100\u0081\2\u06e9\u06e7\3\2\2\2\u06e9\u06e8\3\2\2\2\u06ea\u06ec\3\2"+ + "\2\2\u06eb\u06d9\3\2\2\2\u06eb\u06e4\3\2\2\2\u06ec\u00e5\3\2\2\2\u06ed"+ + "\u06ee\7\u00e3\2\2\u06ee\u00e7\3\2\2\2\u06ef\u06f1\7\u00ed\2\2\u06f0\u06f2"+ + "\7\u00f5\2\2\u06f1\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f1\3\2\2"+ + "\2\u06f3\u06f4\3\2\2\2\u06f4\u0705\3\2\2\2\u06f5\u06f7\7\u00ec\2\2\u06f6"+ + "\u06f8\7\u00f5\2\2\u06f7\u06f6\3\2\2\2\u06f8\u06f9\3\2\2\2\u06f9\u06f7"+ + "\3\2\2\2\u06f9\u06fa\3\2\2\2\u06fa\u0705\3\2\2\2\u06fb\u0705\7\u00ea\2"+ + "\2\u06fc\u0700\7\u00eb\2\2\u06fd\u06ff\5\u00eav\2\u06fe\u06fd\3\2\2\2"+ + "\u06ff\u0702\3\2\2\2\u0700\u06fe\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u0703"+ + "\3\2\2\2\u0702\u0700\3\2\2\2\u0703\u0705\7\u00eb\2\2\u0704\u06ef\3\2\2"+ + "\2\u0704\u06f5\3\2\2\2\u0704\u06fb\3\2\2\2\u0704\u06fc\3\2\2\2\u0705\u00e9"+ + "\3\2\2\2\u0706\u070a\7\u00f1\2\2\u0707\u070a\7\u00f0\2\2\u0708\u070a\5"+ + "\u00eex\2\u0709\u0706\3\2\2\2\u0709\u0707\3\2\2\2\u0709\u0708\3\2\2\2"+ + "\u070a\u00eb\3\2\2\2\u070b\u0710\5\u00eex\2\u070c\u070d\7\u00dc\2\2\u070d"+ + "\u070f\5\u00eex\2\u070e\u070c\3\2\2\2\u070f\u0712\3\2\2\2\u0710\u070e"+ + "\3\2\2\2\u0710\u0711\3\2\2\2\u0711\u00ed\3\2\2\2\u0712\u0710\3\2\2\2\u0713"+ + "\u0717\5\u00f0y\2\u0714\u0716\5\u00f2z\2\u0715\u0714\3\2\2\2\u0716\u0719"+ + "\3\2\2\2\u0717\u0715\3\2\2\2\u0717\u0718\3\2\2\2\u0718\u00ef\3\2\2\2\u0719"+ + "\u0717\3\2\2\2\u071a\u0721\5\u00fa~\2\u071b\u0721\5\u00f4{\2\u071c\u071d"+ + "\7\u00d6\2\2\u071d\u071e\5\u00b8]\2\u071e\u071f\7\u00d7\2\2\u071f\u0721"+ + "\3\2\2\2\u0720\u071a\3\2\2\2\u0720\u071b\3\2\2\2\u0720\u071c\3\2\2\2\u0721"+ + "\u00f1\3\2\2\2\u0722\u0723\7\u00c3\2\2\u0723\u0725\5\u00fc\177\2\u0724"+ + "\u0726\5\u00f8}\2\u0725\u0724\3\2\2\2\u0725\u0726\3\2\2\2\u0726\u00f3"+ + "\3\2\2\2\u0727\u0728\5\u00f6|\2\u0728\u0729\5\u00f8}\2\u0729\u00f5\3\2"+ + "\2\2\u072a\u072f\5\u00ceh\2\u072b\u072f\5\u00e4s\2\u072c\u072f\5\u00fa"+ + "~\2\u072d\u072f\5\u00a4S\2\u072e\u072a\3\2\2\2\u072e\u072b\3\2\2\2\u072e"+ + "\u072c\3\2\2\2\u072e\u072d\3\2\2\2\u072f\u00f7\3\2\2\2\u0730\u0732\5,"+ + "\27\2\u0731\u0730\3\2\2\2\u0731\u0732\3\2\2\2\u0732\u0734\3\2\2\2\u0733"+ + "\u0735\5\u00d6l\2\u0734\u0733\3\2\2\2\u0735\u0736\3\2\2\2\u0736\u0734"+ + "\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u073b\3\2\2\2\u0738\u073a\5\u0102\u0082"+ + "\2\u0739\u0738\3\2\2\2\u073a\u073d\3\2\2\2\u073b\u0739\3\2\2\2\u073b\u073c"+ + "\3\2\2\2\u073c\u00f9\3\2\2\2\u073d\u073b\3\2\2\2\u073e\u0741\5\u0100\u0081"+ + "\2\u073f\u0740\7\u00c2\2\2\u0740\u0742\5\u0100\u0081\2\u0741\u073f\3\2"+ + "\2\2\u0741\u0742\3\2\2\2\u0742\u0748\3\2\2\2\u0743\u0744\5\u00c6d\2\u0744"+ + "\u0745\7\u00c2\2\2\u0745\u0746\5\u0100\u0081\2\u0746\u0748\3\2\2\2\u0747"+ + "\u073e\3\2\2\2\u0747\u0743\3\2\2\2\u0748\u00fb\3\2\2\2\u0749\u074c\5\u00fe"+ + "\u0080\2\u074a\u074c\5\u0100\u0081\2\u074b\u0749\3\2\2\2\u074b\u074a\3"+ + "\2\2\2\u074c\u00fd\3\2\2\2\u074d\u0753\5\u010a\u0086\2\u074e\u074f\7\u00da"+ + "\2\2\u074f\u0750\5\u00a6T\2\u0750\u0751\7\u00db\2\2\u0751\u0753\3\2\2"+ + "\2\u0752\u074d\3\2\2\2\u0752\u074e\3\2\2\2\u0753\u0757\3\2\2\2\u0754\u0756"+ + "\5\u0102\u0082\2\u0755\u0754\3\2\2\2\u0756\u0759\3\2\2\2\u0757\u0755\3"+ + "\2\2\2\u0757\u0758\3\2\2\2\u0758\u00ff\3\2\2\2\u0759\u0757\3\2\2\2\u075a"+ + "\u075c\7\u00d3\2\2\u075b\u075a\3\2\2\2\u075c\u075f\3\2\2\2\u075d\u075b"+ + "\3\2\2\2\u075d\u075e\3\2\2\2\u075e\u0766\3\2\2\2\u075f\u075d\3\2\2\2\u0760"+ + "\u0767\7\u00e2\2\2\u0761\u0762\7\u00d3\2\2\u0762\u0763\7\u00da\2\2\u0763"+ + "\u0764\5\u00a6T\2\u0764\u0765\7\u00db\2\2\u0765\u0767\3\2\2\2\u0766\u0760"+ + "\3\2\2\2\u0766\u0761\3\2\2\2\u0767\u076b\3\2\2\2\u0768\u076a\5\u0102\u0082"+ + "\2\u0769\u0768\3\2\2\2\u076a\u076d\3\2\2\2\u076b\u0769\3\2\2\2\u076b\u076c"+ + "\3\2\2\2\u076c\u0101\3\2\2\2\u076d\u076b\3\2\2\2\u076e\u0770\7\u00d8\2"+ + "\2\u076f\u0771\5\u00a6T\2\u0770\u076f\3\2\2\2\u0770\u0771\3\2\2\2\u0771"+ + "\u0772\3\2\2\2\u0772\u0778\7\u00d9\2\2\u0773\u0774\7\u00da\2\2\u0774\u0775"+ + "\5\u00a6T\2\u0775\u0776\7\u00db\2\2\u0776\u0778\3\2\2\2\u0777\u076e\3"+ + "\2\2\2\u0777\u0773\3\2\2\2\u0778\u0103\3\2\2\2\u0779\u077b\5\u0106\u0084"+ + "\2\u077a\u0779\3\2\2\2\u077a\u077b\3\2\2\2\u077b\u0782\3\2\2\2\u077c\u077e"+ + "\7\u00dc\2\2\u077d\u077f\5\u0106\u0084\2\u077e\u077d\3\2\2\2\u077e\u077f"+ + "\3\2\2\2\u077f\u0781\3\2\2\2\u0780\u077c\3\2\2\2\u0781\u0784\3\2\2\2\u0782"+ + "\u0780\3\2\2\2\u0782\u0783\3\2\2\2\u0783\u0105\3\2\2\2\u0784\u0782\3\2"+ + "\2\2\u0785\u078d\5\u00eex\2\u0786\u0787\7d\2\2\u0787\u0788\7\u00d6\2\2"+ + "\u0788\u0789\5\u0104\u0083\2\u0789\u078a\7\u00d7\2\2\u078a\u078d\3\2\2"+ + "\2\u078b\u078d\5\u00c0a\2\u078c\u0785\3\2\2\2\u078c\u0786\3\2\2\2\u078c"+ + "\u078b\3\2\2\2\u078d\u0107\3\2\2\2\u078e\u078f\t\24\2\2\u078f\u0109\3"+ + "\2\2\2\u0790\u0791\t\25\2\2\u0791\u010b\3\2\2\2\u0792\u0793\t\26\2\2\u0793"+ + "\u010d\3\2\2\2\u0794\u0795\t\27\2\2\u0795\u010f\3\2\2\2\u0796\u0797\t"+ + "\30\2\2\u0797\u0111\3\2\2\2\u0798\u0799\t\31\2\2\u0799\u0113\3\2\2\2\u079a"+ + "\u079b\t\32\2\2\u079b\u0115\3\2\2\2\u00fe\u0117\u011b\u011d\u0125\u0128"+ + "\u0142\u0146\u014b\u0150\u0156\u0164\u0168\u016e\u0173\u0178\u017f\u0185"+ + "\u018c\u0193\u0196\u019a\u019e\u01a5\u01a8\u01ad\u01b0\u01b3\u01b6\u01bb"+ + "\u01bf\u01c3\u01c8\u01cc\u01ce\u01d4\u01e0\u01f1\u01f8\u0200\u0204\u0209"+ + "\u020f\u0217\u021f\u0225\u022c\u0233\u0238\u023e\u025b\u0269\u026d\u0276"+ + "\u027a\u027f\u0299\u02a4\u02a8\u02ac\u02b5\u02bf\u02c4\u02ca\u02cf\u02d4"+ + "\u02d9\u02de\u02e4\u02ea\u02f0\u0308\u030d\u0310\u031a\u031d\u032a\u0332"+ + "\u0339\u033c\u0341\u0345\u034e\u0352\u036c\u0371\u0378\u037f\u0387\u038a"+ + "\u0390\u0394\u0397\u039c\u03a0\u03a3\u03a6\u03a9\u03b1\u03b8\u03c1\u03ce"+ + "\u03da\u03e0\u03e4\u03eb\u03f1\u03f5\u03fc\u0403\u0407\u040e\u0412\u0414"+ + "\u041a\u0421\u0425\u0429\u0436\u0439\u0440\u0447\u044b\u0451\u0455\u045a"+ + "\u045f\u0466\u046e\u0477\u047b\u0481\u048a\u048f\u0496\u049d\u04a3\u04c9"+ + "\u04f3\u04fa\u04ff\u0501\u0527\u053d\u053f\u0544\u0549\u054e\u0551\u0557"+ + "\u055d\u0564\u0569\u056f\u0579\u057e\u0582\u0586\u0589\u0590\u0593\u0598"+ + "\u059c\u05a2\u05a6\u05b1\u05bd\u05c1\u05ca\u05d3\u05db\u05df\u05e6\u05ea"+ + "\u05ef\u05f4\u05f8\u0601\u0607\u060d\u0610\u0614\u0617\u061c\u061f\u0622"+ + "\u0625\u0628\u062c\u0630\u0634\u0639\u063d\u063f\u0645\u064f\u0653\u0656"+ + "\u0660\u0665\u0667\u066c\u0674\u0678\u067c\u0683\u068c\u0690\u0693\u0698"+ + "\u069b\u06a0\u06ab\u06ad\u06b3\u06b5\u06bc\u06c1\u06c5\u06c8\u06cf\u06d5"+ + "\u06df\u06e4\u06e9\u06eb\u06f3\u06f9\u0700\u0704\u0709\u0710\u0717\u0720"+ + "\u0725\u072e\u0731\u0736\u073b\u0741\u0747\u074b\u0752\u0757\u075d\u0766"+ + "\u076b\u0770\u0777\u077a\u077e\u0782\u078c"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/app/src/main/java/antlr/PhpParser.tokens b/app/src/main/java/antlr/PhpParser.tokens new file mode 100644 index 0000000000000000000000000000000000000000..67693cc29a5a6fd4e9d85800def2113c4253c5ab --- /dev/null +++ b/app/src/main/java/antlr/PhpParser.tokens @@ -0,0 +1,416 @@ +SeaWhitespace=1 +HtmlText=2 +XmlStart=3 +PHPStart=4 +HtmlScriptOpen=5 +HtmlStyleOpen=6 +HtmlComment=7 +HtmlDtd=8 +HtmlOpen=9 +Shebang=10 +Error=11 +XmlText=12 +XmlClose=13 +PHPStartInside=14 +HtmlClose=15 +HtmlSlashClose=16 +HtmlSlash=17 +HtmlEquals=18 +HtmlStartQuoteString=19 +HtmlStartDoubleQuoteString=20 +HtmlHex=21 +HtmlDecimal=22 +HtmlSpace=23 +HtmlName=24 +ErrorInside=25 +PHPStartInsideQuoteString=26 +HtmlEndQuoteString=27 +HtmlQuoteString=28 +ErrorHtmlQuote=29 +PHPStartDoubleQuoteString=30 +HtmlEndDoubleQuoteString=31 +HtmlDoubleQuoteString=32 +ErrorHtmlDoubleQuote=33 +ScriptText=34 +HtmlScriptClose=35 +PHPStartInsideScript=36 +StyleBody=37 +PHPEnd=38 +Whitespace=39 +MultiLineComment=40 +SingleLineComment=41 +ShellStyleComment=42 +AttributeStart=43 +Abstract=44 +Array=45 +As=46 +BinaryCast=47 +BoolType=48 +BooleanConstant=49 +Break=50 +Callable=51 +Case=52 +Catch=53 +Class=54 +Clone=55 +Const=56 +Continue=57 +Declare=58 +Default=59 +Do=60 +DoubleCast=61 +DoubleType=62 +Echo=63 +Else=64 +ElseIf=65 +Empty=66 +Enum_=67 +EndDeclare=68 +EndFor=69 +EndForeach=70 +EndIf=71 +EndSwitch=72 +EndWhile=73 +Eval=74 +Exit=75 +Extends=76 +Final=77 +Finally=78 +FloatCast=79 +For=80 +Foreach=81 +Function_=82 +Global=83 +Goto=84 +If=85 +Implements=86 +Import=87 +Include=88 +IncludeOnce=89 +InstanceOf=90 +InsteadOf=91 +Int8Cast=92 +Int16Cast=93 +Int64Type=94 +IntType=95 +Interface=96 +IsSet=97 +List=98 +LogicalAnd=99 +LogicalOr=100 +LogicalXor=101 +Match_=102 +Namespace=103 +New=104 +Null=105 +ObjectType=106 +Parent_=107 +Partial=108 +Print=109 +Private=110 +Protected=111 +Public=112 +Readonly=113 +Require=114 +RequireOnce=115 +Resource=116 +Return=117 +Static=118 +StringType=119 +Switch=120 +Throw=121 +Trait=122 +Try=123 +Typeof=124 +UintCast=125 +UnicodeCast=126 +Unset=127 +Use=128 +Var=129 +While=130 +Yield=131 +From=132 +LambdaFn=133 +Ticks=134 +Encoding=135 +StrictTypes=136 +Get=137 +Set=138 +Call=139 +CallStatic=140 +Constructor=141 +Destruct=142 +Wakeup=143 +Sleep=144 +Autoload=145 +IsSet__=146 +Unset__=147 +ToString__=148 +Invoke=149 +SetState=150 +Clone__=151 +DebugInfo=152 +Namespace__=153 +Class__=154 +Traic__=155 +Function__=156 +Method__=157 +Line__=158 +File__=159 +Dir__=160 +Spaceship=161 +Lgeneric=162 +Rgeneric=163 +DoubleArrow=164 +Inc=165 +Dec=166 +IsIdentical=167 +IsNoidentical=168 +IsEqual=169 +IsNotEq=170 +IsSmallerOrEqual=171 +IsGreaterOrEqual=172 +PlusEqual=173 +MinusEqual=174 +MulEqual=175 +Pow=176 +PowEqual=177 +DivEqual=178 +Concaequal=179 +ModEqual=180 +ShiftLeftEqual=181 +ShiftRightEqual=182 +AndEqual=183 +OrEqual=184 +XorEqual=185 +BooleanOr=186 +BooleanAnd=187 +NullCoalescing=188 +NullCoalescingEqual=189 +ShiftLeft=190 +ShiftRight=191 +DoubleColon=192 +ObjectOperator=193 +NamespaceSeparator=194 +Ellipsis=195 +Less=196 +Greater=197 +Ampersand=198 +Pipe=199 +Bang=200 +Caret=201 +Plus=202 +Minus=203 +Asterisk=204 +Percent=205 +Divide=206 +Tilde=207 +SuppressWarnings=208 +Dollar=209 +Dot=210 +QuestionMark=211 +OpenRoundBracket=212 +CloseRoundBracket=213 +OpenSquareBracket=214 +CloseSquareBracket=215 +OpenCurlyBracket=216 +CloseCurlyBracket=217 +Comma=218 +Colon=219 +SemiColon=220 +Eq=221 +Quote=222 +BackQuote=223 +VarName=224 +Label=225 +Octal=226 +Decimal=227 +Real=228 +Hex=229 +Binary=230 +BackQuoteString=231 +SingleQuoteString=232 +DoubleQuote=233 +StartNowDoc=234 +StartHereDoc=235 +ErrorPhp=236 +CurlyDollar=237 +UnicodeEscape=238 +StringPart=239 +Comment=240 +PHPEndSingleLineComment=241 +CommentEnd=242 +HereDocText=243 +XmlText2=244 +'<?xml'=3 +'?>'=13 +'/>'=16 +'#['=43 +'abstract'=44 +'array'=45 +'as'=46 +'binary'=47 +'break'=50 +'callable'=51 +'case'=52 +'catch'=53 +'class'=54 +'clone'=55 +'const'=56 +'continue'=57 +'declare'=58 +'default'=59 +'do'=60 +'real'=61 +'double'=62 +'echo'=63 +'else'=64 +'elseif'=65 +'empty'=66 +'enum'=67 +'enddeclare'=68 +'endfor'=69 +'endforeach'=70 +'endif'=71 +'endswitch'=72 +'endwhile'=73 +'eval'=74 +'die'=75 +'extends'=76 +'final'=77 +'finally'=78 +'float'=79 +'for'=80 +'foreach'=81 +'function'=82 +'global'=83 +'goto'=84 +'if'=85 +'implements'=86 +'import'=87 +'include'=88 +'include_once'=89 +'instanceof'=90 +'insteadof'=91 +'int8'=92 +'int16'=93 +'int64'=94 +'interface'=96 +'isset'=97 +'list'=98 +'and'=99 +'or'=100 +'xor'=101 +'match'=102 +'namespace'=103 +'new'=104 +'null'=105 +'object'=106 +'parent'=107 +'partial'=108 +'print'=109 +'private'=110 +'protected'=111 +'public'=112 +'readonly'=113 +'require'=114 +'require_once'=115 +'resource'=116 +'return'=117 +'static'=118 +'string'=119 +'switch'=120 +'throw'=121 +'trait'=122 +'try'=123 +'clrtypeof'=124 +'unicode'=126 +'unset'=127 +'use'=128 +'var'=129 +'while'=130 +'yield'=131 +'from'=132 +'fn'=133 +'ticks'=134 +'encoding'=135 +'strict_types'=136 +'__get'=137 +'__set'=138 +'__call'=139 +'__callstatic'=140 +'__construct'=141 +'__destruct'=142 +'__wakeup'=143 +'__sleep'=144 +'__autoload'=145 +'__isset'=146 +'__unset'=147 +'__tostring'=148 +'__invoke'=149 +'__set_state'=150 +'__clone'=151 +'__debuginfo'=152 +'__namespace__'=153 +'__class__'=154 +'__trait__'=155 +'__function__'=156 +'__method__'=157 +'__line__'=158 +'__file__'=159 +'__dir__'=160 +'<=>'=161 +'<:'=162 +':>'=163 +'=>'=164 +'++'=165 +'--'=166 +'==='=167 +'!=='=168 +'=='=169 +'<='=171 +'>='=172 +'+='=173 +'-='=174 +'*='=175 +'**'=176 +'**='=177 +'/='=178 +'.='=179 +'%='=180 +'<<='=181 +'>>='=182 +'&='=183 +'|='=184 +'^='=185 +'||'=186 +'&&'=187 +'??'=188 +'??='=189 +'<<'=190 +'>>'=191 +'::'=192 +'->'=193 +'\\'=194 +'...'=195 +'&'=198 +'|'=199 +'!'=200 +'^'=201 +'+'=202 +'-'=203 +'*'=204 +'%'=205 +'~'=207 +'@'=208 +'.'=210 +'('=212 +')'=213 +'['=214 +']'=215 +'}'=217 +','=218 +':'=219 +';'=220 +'\''=222 +'`'=223 diff --git a/app/src/main/java/antlr/PhpParserBaseListener.java b/app/src/main/java/antlr/PhpParserBaseListener.java new file mode 100644 index 0000000000000000000000000000000000000000..5df905600e7cc30817e70c996a20cec8aa187dca --- /dev/null +++ b/app/src/main/java/antlr/PhpParserBaseListener.java @@ -0,0 +1,1997 @@ +package antlr; + +// Generated from PhpParser.g4 by ANTLR 4.5 + +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.misc.NotNull; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * This class provides an empty implementation of {@link PhpParserListener}, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +public class PhpParserBaseListener implements PhpParserListener { + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterHtmlDocument(PhpParser.HtmlDocumentContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitHtmlDocument(PhpParser.HtmlDocumentContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterInlineHtml(PhpParser.InlineHtmlContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitInlineHtml(PhpParser.InlineHtmlContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterHtmlElement(PhpParser.HtmlElementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitHtmlElement(PhpParser.HtmlElementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterScriptText(PhpParser.ScriptTextContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitScriptText(PhpParser.ScriptTextContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterPhpBlock(PhpParser.PhpBlockContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitPhpBlock(PhpParser.PhpBlockContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterImportStatement(PhpParser.ImportStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitImportStatement(PhpParser.ImportStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTopStatement(PhpParser.TopStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTopStatement(PhpParser.TopStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterUseDeclaration(PhpParser.UseDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitUseDeclaration(PhpParser.UseDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterUseDeclarationContentList(PhpParser.UseDeclarationContentListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitUseDeclarationContentList(PhpParser.UseDeclarationContentListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterUseDeclarationContent(PhpParser.UseDeclarationContentContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitUseDeclarationContent(PhpParser.UseDeclarationContentContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterNamespaceDeclaration(PhpParser.NamespaceDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitNamespaceDeclaration(PhpParser.NamespaceDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterNamespaceStatement(PhpParser.NamespaceStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitNamespaceStatement(PhpParser.NamespaceStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterFunctionDeclaration(PhpParser.FunctionDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitFunctionDeclaration(PhpParser.FunctionDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterClassDeclaration(PhpParser.ClassDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitClassDeclaration(PhpParser.ClassDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterClassEntryType(PhpParser.ClassEntryTypeContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitClassEntryType(PhpParser.ClassEntryTypeContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterInterfaceList(PhpParser.InterfaceListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitInterfaceList(PhpParser.InterfaceListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTypeParameterListInBrackets(PhpParser.TypeParameterListInBracketsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTypeParameterListInBrackets(PhpParser.TypeParameterListInBracketsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTypeParameterList(PhpParser.TypeParameterListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTypeParameterList(PhpParser.TypeParameterListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTypeParameterWithDefaultsList(PhpParser.TypeParameterWithDefaultsListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTypeParameterWithDefaultsList(PhpParser.TypeParameterWithDefaultsListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTypeParameterDecl(PhpParser.TypeParameterDeclContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTypeParameterDecl(PhpParser.TypeParameterDeclContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTypeParameterWithDefaultDecl(PhpParser.TypeParameterWithDefaultDeclContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTypeParameterWithDefaultDecl(PhpParser.TypeParameterWithDefaultDeclContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterGenericDynamicArgs(PhpParser.GenericDynamicArgsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitGenericDynamicArgs(PhpParser.GenericDynamicArgsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterAttributes(PhpParser.AttributesContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitAttributes(PhpParser.AttributesContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterAttributeGroup(PhpParser.AttributeGroupContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitAttributeGroup(PhpParser.AttributeGroupContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterAttribute(PhpParser.AttributeContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitAttribute(PhpParser.AttributeContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterInnerStatementList(PhpParser.InnerStatementListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitInnerStatementList(PhpParser.InnerStatementListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterInnerStatement(PhpParser.InnerStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitInnerStatement(PhpParser.InnerStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterStatement(PhpParser.StatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitStatement(PhpParser.StatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterEmptyStatement_(PhpParser.EmptyStatement_Context ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitEmptyStatement_(PhpParser.EmptyStatement_Context ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterBlockStatement(PhpParser.BlockStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitBlockStatement(PhpParser.BlockStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterIfStatement(PhpParser.IfStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitIfStatement(PhpParser.IfStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterElseIfStatement(PhpParser.ElseIfStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitElseIfStatement(PhpParser.ElseIfStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterElseIfColonStatement(PhpParser.ElseIfColonStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitElseIfColonStatement(PhpParser.ElseIfColonStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterElseStatement(PhpParser.ElseStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitElseStatement(PhpParser.ElseStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterElseColonStatement(PhpParser.ElseColonStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitElseColonStatement(PhpParser.ElseColonStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterWhileStatement(PhpParser.WhileStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitWhileStatement(PhpParser.WhileStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterDoWhileStatement(PhpParser.DoWhileStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitDoWhileStatement(PhpParser.DoWhileStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterForStatement(PhpParser.ForStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitForStatement(PhpParser.ForStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterForInit(PhpParser.ForInitContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitForInit(PhpParser.ForInitContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterForUpdate(PhpParser.ForUpdateContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitForUpdate(PhpParser.ForUpdateContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterSwitchStatement(PhpParser.SwitchStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitSwitchStatement(PhpParser.SwitchStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterSwitchBlock(PhpParser.SwitchBlockContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitSwitchBlock(PhpParser.SwitchBlockContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterBreakStatement(PhpParser.BreakStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitBreakStatement(PhpParser.BreakStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterContinueStatement(PhpParser.ContinueStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitContinueStatement(PhpParser.ContinueStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterReturnStatement(PhpParser.ReturnStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitReturnStatement(PhpParser.ReturnStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterExpressionStatement(PhpParser.ExpressionStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitExpressionStatement(PhpParser.ExpressionStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterUnsetStatement(PhpParser.UnsetStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitUnsetStatement(PhpParser.UnsetStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterForeachStatement(PhpParser.ForeachStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitForeachStatement(PhpParser.ForeachStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTryCatchFinally(PhpParser.TryCatchFinallyContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTryCatchFinally(PhpParser.TryCatchFinallyContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterCatchClause(PhpParser.CatchClauseContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitCatchClause(PhpParser.CatchClauseContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterFinallyStatement(PhpParser.FinallyStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitFinallyStatement(PhpParser.FinallyStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterThrowStatement(PhpParser.ThrowStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitThrowStatement(PhpParser.ThrowStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterGotoStatement(PhpParser.GotoStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitGotoStatement(PhpParser.GotoStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterDeclareStatement(PhpParser.DeclareStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitDeclareStatement(PhpParser.DeclareStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterInlineHtmlStatement(PhpParser.InlineHtmlStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitInlineHtmlStatement(PhpParser.InlineHtmlStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterDeclareList(PhpParser.DeclareListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitDeclareList(PhpParser.DeclareListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterDirective(PhpParser.DirectiveContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitDirective(PhpParser.DirectiveContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterFormalParameterList(PhpParser.FormalParameterListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitFormalParameterList(PhpParser.FormalParameterListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterFormalParameter(PhpParser.FormalParameterContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitFormalParameter(PhpParser.FormalParameterContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTypeHint(PhpParser.TypeHintContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTypeHint(PhpParser.TypeHintContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterGlobalStatement(PhpParser.GlobalStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitGlobalStatement(PhpParser.GlobalStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterGlobalVar(PhpParser.GlobalVarContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitGlobalVar(PhpParser.GlobalVarContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterEchoStatement(PhpParser.EchoStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitEchoStatement(PhpParser.EchoStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterStaticVariableStatement(PhpParser.StaticVariableStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitStaticVariableStatement(PhpParser.StaticVariableStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterClassStatement(PhpParser.ClassStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitClassStatement(PhpParser.ClassStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTraitAdaptations(PhpParser.TraitAdaptationsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTraitAdaptations(PhpParser.TraitAdaptationsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTraitAdaptationStatement(PhpParser.TraitAdaptationStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTraitAdaptationStatement(PhpParser.TraitAdaptationStatementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTraitPrecedence(PhpParser.TraitPrecedenceContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTraitPrecedence(PhpParser.TraitPrecedenceContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTraitAlias(PhpParser.TraitAliasContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTraitAlias(PhpParser.TraitAliasContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTraitMethodReference(PhpParser.TraitMethodReferenceContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTraitMethodReference(PhpParser.TraitMethodReferenceContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterBaseCtorCall(PhpParser.BaseCtorCallContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitBaseCtorCall(PhpParser.BaseCtorCallContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterReturnTypeDecl(PhpParser.ReturnTypeDeclContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitReturnTypeDecl(PhpParser.ReturnTypeDeclContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterMethodBody(PhpParser.MethodBodyContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitMethodBody(PhpParser.MethodBodyContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterPropertyModifiers(PhpParser.PropertyModifiersContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitPropertyModifiers(PhpParser.PropertyModifiersContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterMemberModifiers(PhpParser.MemberModifiersContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitMemberModifiers(PhpParser.MemberModifiersContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterVariableInitializer(PhpParser.VariableInitializerContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitVariableInitializer(PhpParser.VariableInitializerContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterIdentifierInitializer(PhpParser.IdentifierInitializerContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitIdentifierInitializer(PhpParser.IdentifierInitializerContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterGlobalConstantDeclaration(PhpParser.GlobalConstantDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitGlobalConstantDeclaration(PhpParser.GlobalConstantDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterEnumDeclaration(PhpParser.EnumDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitEnumDeclaration(PhpParser.EnumDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterEnumItem(PhpParser.EnumItemContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitEnumItem(PhpParser.EnumItemContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterExpressionList(PhpParser.ExpressionListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitExpressionList(PhpParser.ExpressionListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterParentheses(PhpParser.ParenthesesContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitParentheses(PhpParser.ParenthesesContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterChainExpression(PhpParser.ChainExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitChainExpression(PhpParser.ChainExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterSpecialWordExpression(PhpParser.SpecialWordExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitSpecialWordExpression(PhpParser.SpecialWordExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterArrayCreationExpression(PhpParser.ArrayCreationExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitArrayCreationExpression(PhpParser.ArrayCreationExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterBackQuoteStringExpression(PhpParser.BackQuoteStringExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitBackQuoteStringExpression(PhpParser.BackQuoteStringExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterMatchExpression(PhpParser.MatchExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitMatchExpression(PhpParser.MatchExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterLogicalExpression(PhpParser.LogicalExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitLogicalExpression(PhpParser.LogicalExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterPrintExpression(PhpParser.PrintExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitPrintExpression(PhpParser.PrintExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterAssignmentExpression(PhpParser.AssignmentExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitAssignmentExpression(PhpParser.AssignmentExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterPostfixIncDecExpression(PhpParser.PostfixIncDecExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitPostfixIncDecExpression(PhpParser.PostfixIncDecExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterCloneExpression(PhpParser.CloneExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitCloneExpression(PhpParser.CloneExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterUnaryOperatorExpression(PhpParser.UnaryOperatorExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitUnaryOperatorExpression(PhpParser.UnaryOperatorExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterNewExpression(PhpParser.NewExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitNewExpression(PhpParser.NewExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterParenthesisExpression(PhpParser.ParenthesisExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitParenthesisExpression(PhpParser.ParenthesisExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterSpaceshipExpression(PhpParser.SpaceshipExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitSpaceshipExpression(PhpParser.SpaceshipExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterConditionalExpression(PhpParser.ConditionalExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitConditionalExpression(PhpParser.ConditionalExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterNullCoalescingExpression(PhpParser.NullCoalescingExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitNullCoalescingExpression(PhpParser.NullCoalescingExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterArithmeticExpression(PhpParser.ArithmeticExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitArithmeticExpression(PhpParser.ArithmeticExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterIndexerExpression(PhpParser.IndexerExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitIndexerExpression(PhpParser.IndexerExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterScalarExpression(PhpParser.ScalarExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitScalarExpression(PhpParser.ScalarExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterPrefixIncDecExpression(PhpParser.PrefixIncDecExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitPrefixIncDecExpression(PhpParser.PrefixIncDecExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterComparisonExpression(PhpParser.ComparisonExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitComparisonExpression(PhpParser.ComparisonExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterCastExpression(PhpParser.CastExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitCastExpression(PhpParser.CastExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterInstanceOfExpression(PhpParser.InstanceOfExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitInstanceOfExpression(PhpParser.InstanceOfExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterArrayDestructExpression(PhpParser.ArrayDestructExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitArrayDestructExpression(PhpParser.ArrayDestructExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterLambdaFunctionExpression(PhpParser.LambdaFunctionExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitLambdaFunctionExpression(PhpParser.LambdaFunctionExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterBitwiseExpression(PhpParser.BitwiseExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitBitwiseExpression(PhpParser.BitwiseExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterAssignable(PhpParser.AssignableContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitAssignable(PhpParser.AssignableContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterArrayCreation(PhpParser.ArrayCreationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitArrayCreation(PhpParser.ArrayCreationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterArrayDestructuring(PhpParser.ArrayDestructuringContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitArrayDestructuring(PhpParser.ArrayDestructuringContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterIndexedDestructItem(PhpParser.IndexedDestructItemContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitIndexedDestructItem(PhpParser.IndexedDestructItemContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterKeyedDestructItem(PhpParser.KeyedDestructItemContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitKeyedDestructItem(PhpParser.KeyedDestructItemContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterLambdaFunctionExpr(PhpParser.LambdaFunctionExprContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitLambdaFunctionExpr(PhpParser.LambdaFunctionExprContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterMatchExpr(PhpParser.MatchExprContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitMatchExpr(PhpParser.MatchExprContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterMatchItem(PhpParser.MatchItemContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitMatchItem(PhpParser.MatchItemContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterNewExpr(PhpParser.NewExprContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitNewExpr(PhpParser.NewExprContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterAssignmentOperator(PhpParser.AssignmentOperatorContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitAssignmentOperator(PhpParser.AssignmentOperatorContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterYieldExpression(PhpParser.YieldExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitYieldExpression(PhpParser.YieldExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterArrayItemList(PhpParser.ArrayItemListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitArrayItemList(PhpParser.ArrayItemListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterArrayItem(PhpParser.ArrayItemContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitArrayItem(PhpParser.ArrayItemContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterLambdaFunctionUseVars(PhpParser.LambdaFunctionUseVarsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitLambdaFunctionUseVars(PhpParser.LambdaFunctionUseVarsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterLambdaFunctionUseVar(PhpParser.LambdaFunctionUseVarContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitLambdaFunctionUseVar(PhpParser.LambdaFunctionUseVarContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterQualifiedStaticTypeRef(PhpParser.QualifiedStaticTypeRefContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitQualifiedStaticTypeRef(PhpParser.QualifiedStaticTypeRefContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterTypeRef(PhpParser.TypeRefContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitTypeRef(PhpParser.TypeRefContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterAnonymousClass(PhpParser.AnonymousClassContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitAnonymousClass(PhpParser.AnonymousClassContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterIndirectTypeRef(PhpParser.IndirectTypeRefContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitIndirectTypeRef(PhpParser.IndirectTypeRefContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterQualifiedNamespaceName(PhpParser.QualifiedNamespaceNameContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitQualifiedNamespaceName(PhpParser.QualifiedNamespaceNameContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterNamespaceNameList(PhpParser.NamespaceNameListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitNamespaceNameList(PhpParser.NamespaceNameListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterNamespaceNameTail(PhpParser.NamespaceNameTailContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitNamespaceNameTail(PhpParser.NamespaceNameTailContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterQualifiedNamespaceNameList(PhpParser.QualifiedNamespaceNameListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitQualifiedNamespaceNameList(PhpParser.QualifiedNamespaceNameListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterArguments(PhpParser.ArgumentsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitArguments(PhpParser.ArgumentsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterActualArgument(PhpParser.ActualArgumentContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitActualArgument(PhpParser.ActualArgumentContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterArgumentName(PhpParser.ArgumentNameContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitArgumentName(PhpParser.ArgumentNameContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterConstantInitializer(PhpParser.ConstantInitializerContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitConstantInitializer(PhpParser.ConstantInitializerContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterConstant(PhpParser.ConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitConstant(PhpParser.ConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterLiteralConstant(PhpParser.LiteralConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitLiteralConstant(PhpParser.LiteralConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterNumericConstant(PhpParser.NumericConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitNumericConstant(PhpParser.NumericConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterClassConstant(PhpParser.ClassConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitClassConstant(PhpParser.ClassConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterStringConstant(PhpParser.StringConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitStringConstant(PhpParser.StringConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterString(PhpParser.StringContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitString(PhpParser.StringContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterInterpolatedStringPart(PhpParser.InterpolatedStringPartContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitInterpolatedStringPart(PhpParser.InterpolatedStringPartContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterChainList(PhpParser.ChainListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitChainList(PhpParser.ChainListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterChain(PhpParser.ChainContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitChain(PhpParser.ChainContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterChainOrigin(PhpParser.ChainOriginContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitChainOrigin(PhpParser.ChainOriginContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterMemberAccess(PhpParser.MemberAccessContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitMemberAccess(PhpParser.MemberAccessContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterFunctionCall(PhpParser.FunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitFunctionCall(PhpParser.FunctionCallContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterFunctionCallName(PhpParser.FunctionCallNameContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitFunctionCallName(PhpParser.FunctionCallNameContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterActualArguments(PhpParser.ActualArgumentsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitActualArguments(PhpParser.ActualArgumentsContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterChainBase(PhpParser.ChainBaseContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitChainBase(PhpParser.ChainBaseContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterKeyedFieldName(PhpParser.KeyedFieldNameContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitKeyedFieldName(PhpParser.KeyedFieldNameContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterKeyedSimpleFieldName(PhpParser.KeyedSimpleFieldNameContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitKeyedSimpleFieldName(PhpParser.KeyedSimpleFieldNameContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterKeyedVariable(PhpParser.KeyedVariableContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitKeyedVariable(PhpParser.KeyedVariableContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterSquareCurlyExpression(PhpParser.SquareCurlyExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitSquareCurlyExpression(PhpParser.SquareCurlyExpressionContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterAssignmentList(PhpParser.AssignmentListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitAssignmentList(PhpParser.AssignmentListContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterAssignmentListElement(PhpParser.AssignmentListElementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitAssignmentListElement(PhpParser.AssignmentListElementContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterModifier(PhpParser.ModifierContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitModifier(PhpParser.ModifierContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterIdentifier(PhpParser.IdentifierContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitIdentifier(PhpParser.IdentifierContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterMemberModifier(PhpParser.MemberModifierContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitMemberModifier(PhpParser.MemberModifierContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterMagicConstant(PhpParser.MagicConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitMagicConstant(PhpParser.MagicConstantContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterMagicMethod(PhpParser.MagicMethodContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitMagicMethod(PhpParser.MagicMethodContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterPrimitiveType(PhpParser.PrimitiveTypeContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitPrimitiveType(PhpParser.PrimitiveTypeContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterCastOperation(PhpParser.CastOperationContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitCastOperation(PhpParser.CastOperationContext ctx) { } + + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void enterEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void exitEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void visitTerminal(TerminalNode node) { } + /** + * {@inheritDoc} + * + * <p>The default implementation does nothing.</p> + */ + @Override public void visitErrorNode(ErrorNode node) { } +} \ No newline at end of file diff --git a/app/src/main/java/antlr/PhpParserListener.java b/app/src/main/java/antlr/PhpParserListener.java new file mode 100644 index 0000000000000000000000000000000000000000..98ba3a0bbbf46cdaccc6d72cbb58bca4650c70fa --- /dev/null +++ b/app/src/main/java/antlr/PhpParserListener.java @@ -0,0 +1,1694 @@ +package antlr; + +// Generated from PhpParser.g4 by ANTLR 4.5 +import org.antlr.v4.runtime.misc.NotNull; +import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** + * This interface defines a complete listener for a parse tree produced by + * {@link PhpParser}. + */ +public interface PhpParserListener extends ParseTreeListener { + /** + * Enter a parse tree produced by {@link PhpParser#htmlDocument}. + * @param ctx the parse tree + */ + void enterHtmlDocument(PhpParser.HtmlDocumentContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#htmlDocument}. + * @param ctx the parse tree + */ + void exitHtmlDocument(PhpParser.HtmlDocumentContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#inlineHtml}. + * @param ctx the parse tree + */ + void enterInlineHtml(PhpParser.InlineHtmlContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#inlineHtml}. + * @param ctx the parse tree + */ + void exitInlineHtml(PhpParser.InlineHtmlContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#htmlElement}. + * @param ctx the parse tree + */ + void enterHtmlElement(PhpParser.HtmlElementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#htmlElement}. + * @param ctx the parse tree + */ + void exitHtmlElement(PhpParser.HtmlElementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#scriptText}. + * @param ctx the parse tree + */ + void enterScriptText(PhpParser.ScriptTextContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#scriptText}. + * @param ctx the parse tree + */ + void exitScriptText(PhpParser.ScriptTextContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#phpBlock}. + * @param ctx the parse tree + */ + void enterPhpBlock(PhpParser.PhpBlockContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#phpBlock}. + * @param ctx the parse tree + */ + void exitPhpBlock(PhpParser.PhpBlockContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#importStatement}. + * @param ctx the parse tree + */ + void enterImportStatement(PhpParser.ImportStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#importStatement}. + * @param ctx the parse tree + */ + void exitImportStatement(PhpParser.ImportStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#topStatement}. + * @param ctx the parse tree + */ + void enterTopStatement(PhpParser.TopStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#topStatement}. + * @param ctx the parse tree + */ + void exitTopStatement(PhpParser.TopStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#useDeclaration}. + * @param ctx the parse tree + */ + void enterUseDeclaration(PhpParser.UseDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#useDeclaration}. + * @param ctx the parse tree + */ + void exitUseDeclaration(PhpParser.UseDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#useDeclarationContentList}. + * @param ctx the parse tree + */ + void enterUseDeclarationContentList(PhpParser.UseDeclarationContentListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#useDeclarationContentList}. + * @param ctx the parse tree + */ + void exitUseDeclarationContentList(PhpParser.UseDeclarationContentListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#useDeclarationContent}. + * @param ctx the parse tree + */ + void enterUseDeclarationContent(PhpParser.UseDeclarationContentContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#useDeclarationContent}. + * @param ctx the parse tree + */ + void exitUseDeclarationContent(PhpParser.UseDeclarationContentContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#namespaceDeclaration}. + * @param ctx the parse tree + */ + void enterNamespaceDeclaration(PhpParser.NamespaceDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#namespaceDeclaration}. + * @param ctx the parse tree + */ + void exitNamespaceDeclaration(PhpParser.NamespaceDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#namespaceStatement}. + * @param ctx the parse tree + */ + void enterNamespaceStatement(PhpParser.NamespaceStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#namespaceStatement}. + * @param ctx the parse tree + */ + void exitNamespaceStatement(PhpParser.NamespaceStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#functionDeclaration}. + * @param ctx the parse tree + */ + void enterFunctionDeclaration(PhpParser.FunctionDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#functionDeclaration}. + * @param ctx the parse tree + */ + void exitFunctionDeclaration(PhpParser.FunctionDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#classDeclaration}. + * @param ctx the parse tree + */ + void enterClassDeclaration(PhpParser.ClassDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#classDeclaration}. + * @param ctx the parse tree + */ + void exitClassDeclaration(PhpParser.ClassDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#classEntryType}. + * @param ctx the parse tree + */ + void enterClassEntryType(PhpParser.ClassEntryTypeContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#classEntryType}. + * @param ctx the parse tree + */ + void exitClassEntryType(PhpParser.ClassEntryTypeContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#interfaceList}. + * @param ctx the parse tree + */ + void enterInterfaceList(PhpParser.InterfaceListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#interfaceList}. + * @param ctx the parse tree + */ + void exitInterfaceList(PhpParser.InterfaceListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#typeParameterListInBrackets}. + * @param ctx the parse tree + */ + void enterTypeParameterListInBrackets(PhpParser.TypeParameterListInBracketsContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#typeParameterListInBrackets}. + * @param ctx the parse tree + */ + void exitTypeParameterListInBrackets(PhpParser.TypeParameterListInBracketsContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#typeParameterList}. + * @param ctx the parse tree + */ + void enterTypeParameterList(PhpParser.TypeParameterListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#typeParameterList}. + * @param ctx the parse tree + */ + void exitTypeParameterList(PhpParser.TypeParameterListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#typeParameterWithDefaultsList}. + * @param ctx the parse tree + */ + void enterTypeParameterWithDefaultsList(PhpParser.TypeParameterWithDefaultsListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#typeParameterWithDefaultsList}. + * @param ctx the parse tree + */ + void exitTypeParameterWithDefaultsList(PhpParser.TypeParameterWithDefaultsListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#typeParameterDecl}. + * @param ctx the parse tree + */ + void enterTypeParameterDecl(PhpParser.TypeParameterDeclContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#typeParameterDecl}. + * @param ctx the parse tree + */ + void exitTypeParameterDecl(PhpParser.TypeParameterDeclContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#typeParameterWithDefaultDecl}. + * @param ctx the parse tree + */ + void enterTypeParameterWithDefaultDecl(PhpParser.TypeParameterWithDefaultDeclContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#typeParameterWithDefaultDecl}. + * @param ctx the parse tree + */ + void exitTypeParameterWithDefaultDecl(PhpParser.TypeParameterWithDefaultDeclContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#genericDynamicArgs}. + * @param ctx the parse tree + */ + void enterGenericDynamicArgs(PhpParser.GenericDynamicArgsContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#genericDynamicArgs}. + * @param ctx the parse tree + */ + void exitGenericDynamicArgs(PhpParser.GenericDynamicArgsContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#attributes}. + * @param ctx the parse tree + */ + void enterAttributes(PhpParser.AttributesContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#attributes}. + * @param ctx the parse tree + */ + void exitAttributes(PhpParser.AttributesContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#attributeGroup}. + * @param ctx the parse tree + */ + void enterAttributeGroup(PhpParser.AttributeGroupContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#attributeGroup}. + * @param ctx the parse tree + */ + void exitAttributeGroup(PhpParser.AttributeGroupContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#attribute}. + * @param ctx the parse tree + */ + void enterAttribute(PhpParser.AttributeContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#attribute}. + * @param ctx the parse tree + */ + void exitAttribute(PhpParser.AttributeContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#innerStatementList}. + * @param ctx the parse tree + */ + void enterInnerStatementList(PhpParser.InnerStatementListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#innerStatementList}. + * @param ctx the parse tree + */ + void exitInnerStatementList(PhpParser.InnerStatementListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#innerStatement}. + * @param ctx the parse tree + */ + void enterInnerStatement(PhpParser.InnerStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#innerStatement}. + * @param ctx the parse tree + */ + void exitInnerStatement(PhpParser.InnerStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#statement}. + * @param ctx the parse tree + */ + void enterStatement(PhpParser.StatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#statement}. + * @param ctx the parse tree + */ + void exitStatement(PhpParser.StatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#emptyStatement_}. + * @param ctx the parse tree + */ + void enterEmptyStatement_(PhpParser.EmptyStatement_Context ctx); + /** + * Exit a parse tree produced by {@link PhpParser#emptyStatement_}. + * @param ctx the parse tree + */ + void exitEmptyStatement_(PhpParser.EmptyStatement_Context ctx); + /** + * Enter a parse tree produced by {@link PhpParser#blockStatement}. + * @param ctx the parse tree + */ + void enterBlockStatement(PhpParser.BlockStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#blockStatement}. + * @param ctx the parse tree + */ + void exitBlockStatement(PhpParser.BlockStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#ifStatement}. + * @param ctx the parse tree + */ + void enterIfStatement(PhpParser.IfStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#ifStatement}. + * @param ctx the parse tree + */ + void exitIfStatement(PhpParser.IfStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#elseIfStatement}. + * @param ctx the parse tree + */ + void enterElseIfStatement(PhpParser.ElseIfStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#elseIfStatement}. + * @param ctx the parse tree + */ + void exitElseIfStatement(PhpParser.ElseIfStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#elseIfColonStatement}. + * @param ctx the parse tree + */ + void enterElseIfColonStatement(PhpParser.ElseIfColonStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#elseIfColonStatement}. + * @param ctx the parse tree + */ + void exitElseIfColonStatement(PhpParser.ElseIfColonStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#elseStatement}. + * @param ctx the parse tree + */ + void enterElseStatement(PhpParser.ElseStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#elseStatement}. + * @param ctx the parse tree + */ + void exitElseStatement(PhpParser.ElseStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#elseColonStatement}. + * @param ctx the parse tree + */ + void enterElseColonStatement(PhpParser.ElseColonStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#elseColonStatement}. + * @param ctx the parse tree + */ + void exitElseColonStatement(PhpParser.ElseColonStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#whileStatement}. + * @param ctx the parse tree + */ + void enterWhileStatement(PhpParser.WhileStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#whileStatement}. + * @param ctx the parse tree + */ + void exitWhileStatement(PhpParser.WhileStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#doWhileStatement}. + * @param ctx the parse tree + */ + void enterDoWhileStatement(PhpParser.DoWhileStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#doWhileStatement}. + * @param ctx the parse tree + */ + void exitDoWhileStatement(PhpParser.DoWhileStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#forStatement}. + * @param ctx the parse tree + */ + void enterForStatement(PhpParser.ForStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#forStatement}. + * @param ctx the parse tree + */ + void exitForStatement(PhpParser.ForStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#forInit}. + * @param ctx the parse tree + */ + void enterForInit(PhpParser.ForInitContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#forInit}. + * @param ctx the parse tree + */ + void exitForInit(PhpParser.ForInitContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#forUpdate}. + * @param ctx the parse tree + */ + void enterForUpdate(PhpParser.ForUpdateContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#forUpdate}. + * @param ctx the parse tree + */ + void exitForUpdate(PhpParser.ForUpdateContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#switchStatement}. + * @param ctx the parse tree + */ + void enterSwitchStatement(PhpParser.SwitchStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#switchStatement}. + * @param ctx the parse tree + */ + void exitSwitchStatement(PhpParser.SwitchStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#switchBlock}. + * @param ctx the parse tree + */ + void enterSwitchBlock(PhpParser.SwitchBlockContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#switchBlock}. + * @param ctx the parse tree + */ + void exitSwitchBlock(PhpParser.SwitchBlockContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#breakStatement}. + * @param ctx the parse tree + */ + void enterBreakStatement(PhpParser.BreakStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#breakStatement}. + * @param ctx the parse tree + */ + void exitBreakStatement(PhpParser.BreakStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#continueStatement}. + * @param ctx the parse tree + */ + void enterContinueStatement(PhpParser.ContinueStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#continueStatement}. + * @param ctx the parse tree + */ + void exitContinueStatement(PhpParser.ContinueStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#returnStatement}. + * @param ctx the parse tree + */ + void enterReturnStatement(PhpParser.ReturnStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#returnStatement}. + * @param ctx the parse tree + */ + void exitReturnStatement(PhpParser.ReturnStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#expressionStatement}. + * @param ctx the parse tree + */ + void enterExpressionStatement(PhpParser.ExpressionStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#expressionStatement}. + * @param ctx the parse tree + */ + void exitExpressionStatement(PhpParser.ExpressionStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#unsetStatement}. + * @param ctx the parse tree + */ + void enterUnsetStatement(PhpParser.UnsetStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#unsetStatement}. + * @param ctx the parse tree + */ + void exitUnsetStatement(PhpParser.UnsetStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#foreachStatement}. + * @param ctx the parse tree + */ + void enterForeachStatement(PhpParser.ForeachStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#foreachStatement}. + * @param ctx the parse tree + */ + void exitForeachStatement(PhpParser.ForeachStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#tryCatchFinally}. + * @param ctx the parse tree + */ + void enterTryCatchFinally(PhpParser.TryCatchFinallyContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#tryCatchFinally}. + * @param ctx the parse tree + */ + void exitTryCatchFinally(PhpParser.TryCatchFinallyContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#catchClause}. + * @param ctx the parse tree + */ + void enterCatchClause(PhpParser.CatchClauseContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#catchClause}. + * @param ctx the parse tree + */ + void exitCatchClause(PhpParser.CatchClauseContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#finallyStatement}. + * @param ctx the parse tree + */ + void enterFinallyStatement(PhpParser.FinallyStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#finallyStatement}. + * @param ctx the parse tree + */ + void exitFinallyStatement(PhpParser.FinallyStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#throwStatement}. + * @param ctx the parse tree + */ + void enterThrowStatement(PhpParser.ThrowStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#throwStatement}. + * @param ctx the parse tree + */ + void exitThrowStatement(PhpParser.ThrowStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#gotoStatement}. + * @param ctx the parse tree + */ + void enterGotoStatement(PhpParser.GotoStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#gotoStatement}. + * @param ctx the parse tree + */ + void exitGotoStatement(PhpParser.GotoStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#declareStatement}. + * @param ctx the parse tree + */ + void enterDeclareStatement(PhpParser.DeclareStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#declareStatement}. + * @param ctx the parse tree + */ + void exitDeclareStatement(PhpParser.DeclareStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#inlineHtmlStatement}. + * @param ctx the parse tree + */ + void enterInlineHtmlStatement(PhpParser.InlineHtmlStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#inlineHtmlStatement}. + * @param ctx the parse tree + */ + void exitInlineHtmlStatement(PhpParser.InlineHtmlStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#declareList}. + * @param ctx the parse tree + */ + void enterDeclareList(PhpParser.DeclareListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#declareList}. + * @param ctx the parse tree + */ + void exitDeclareList(PhpParser.DeclareListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#directive}. + * @param ctx the parse tree + */ + void enterDirective(PhpParser.DirectiveContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#directive}. + * @param ctx the parse tree + */ + void exitDirective(PhpParser.DirectiveContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#formalParameterList}. + * @param ctx the parse tree + */ + void enterFormalParameterList(PhpParser.FormalParameterListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#formalParameterList}. + * @param ctx the parse tree + */ + void exitFormalParameterList(PhpParser.FormalParameterListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#formalParameter}. + * @param ctx the parse tree + */ + void enterFormalParameter(PhpParser.FormalParameterContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#formalParameter}. + * @param ctx the parse tree + */ + void exitFormalParameter(PhpParser.FormalParameterContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#typeHint}. + * @param ctx the parse tree + */ + void enterTypeHint(PhpParser.TypeHintContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#typeHint}. + * @param ctx the parse tree + */ + void exitTypeHint(PhpParser.TypeHintContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#globalStatement}. + * @param ctx the parse tree + */ + void enterGlobalStatement(PhpParser.GlobalStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#globalStatement}. + * @param ctx the parse tree + */ + void exitGlobalStatement(PhpParser.GlobalStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#globalVar}. + * @param ctx the parse tree + */ + void enterGlobalVar(PhpParser.GlobalVarContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#globalVar}. + * @param ctx the parse tree + */ + void exitGlobalVar(PhpParser.GlobalVarContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#echoStatement}. + * @param ctx the parse tree + */ + void enterEchoStatement(PhpParser.EchoStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#echoStatement}. + * @param ctx the parse tree + */ + void exitEchoStatement(PhpParser.EchoStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#staticVariableStatement}. + * @param ctx the parse tree + */ + void enterStaticVariableStatement(PhpParser.StaticVariableStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#staticVariableStatement}. + * @param ctx the parse tree + */ + void exitStaticVariableStatement(PhpParser.StaticVariableStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#classStatement}. + * @param ctx the parse tree + */ + void enterClassStatement(PhpParser.ClassStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#classStatement}. + * @param ctx the parse tree + */ + void exitClassStatement(PhpParser.ClassStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#traitAdaptations}. + * @param ctx the parse tree + */ + void enterTraitAdaptations(PhpParser.TraitAdaptationsContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#traitAdaptations}. + * @param ctx the parse tree + */ + void exitTraitAdaptations(PhpParser.TraitAdaptationsContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#traitAdaptationStatement}. + * @param ctx the parse tree + */ + void enterTraitAdaptationStatement(PhpParser.TraitAdaptationStatementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#traitAdaptationStatement}. + * @param ctx the parse tree + */ + void exitTraitAdaptationStatement(PhpParser.TraitAdaptationStatementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#traitPrecedence}. + * @param ctx the parse tree + */ + void enterTraitPrecedence(PhpParser.TraitPrecedenceContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#traitPrecedence}. + * @param ctx the parse tree + */ + void exitTraitPrecedence(PhpParser.TraitPrecedenceContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#traitAlias}. + * @param ctx the parse tree + */ + void enterTraitAlias(PhpParser.TraitAliasContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#traitAlias}. + * @param ctx the parse tree + */ + void exitTraitAlias(PhpParser.TraitAliasContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#traitMethodReference}. + * @param ctx the parse tree + */ + void enterTraitMethodReference(PhpParser.TraitMethodReferenceContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#traitMethodReference}. + * @param ctx the parse tree + */ + void exitTraitMethodReference(PhpParser.TraitMethodReferenceContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#baseCtorCall}. + * @param ctx the parse tree + */ + void enterBaseCtorCall(PhpParser.BaseCtorCallContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#baseCtorCall}. + * @param ctx the parse tree + */ + void exitBaseCtorCall(PhpParser.BaseCtorCallContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#returnTypeDecl}. + * @param ctx the parse tree + */ + void enterReturnTypeDecl(PhpParser.ReturnTypeDeclContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#returnTypeDecl}. + * @param ctx the parse tree + */ + void exitReturnTypeDecl(PhpParser.ReturnTypeDeclContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#methodBody}. + * @param ctx the parse tree + */ + void enterMethodBody(PhpParser.MethodBodyContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#methodBody}. + * @param ctx the parse tree + */ + void exitMethodBody(PhpParser.MethodBodyContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#propertyModifiers}. + * @param ctx the parse tree + */ + void enterPropertyModifiers(PhpParser.PropertyModifiersContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#propertyModifiers}. + * @param ctx the parse tree + */ + void exitPropertyModifiers(PhpParser.PropertyModifiersContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#memberModifiers}. + * @param ctx the parse tree + */ + void enterMemberModifiers(PhpParser.MemberModifiersContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#memberModifiers}. + * @param ctx the parse tree + */ + void exitMemberModifiers(PhpParser.MemberModifiersContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#variableInitializer}. + * @param ctx the parse tree + */ + void enterVariableInitializer(PhpParser.VariableInitializerContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#variableInitializer}. + * @param ctx the parse tree + */ + void exitVariableInitializer(PhpParser.VariableInitializerContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#identifierInitializer}. + * @param ctx the parse tree + */ + void enterIdentifierInitializer(PhpParser.IdentifierInitializerContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#identifierInitializer}. + * @param ctx the parse tree + */ + void exitIdentifierInitializer(PhpParser.IdentifierInitializerContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#globalConstantDeclaration}. + * @param ctx the parse tree + */ + void enterGlobalConstantDeclaration(PhpParser.GlobalConstantDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#globalConstantDeclaration}. + * @param ctx the parse tree + */ + void exitGlobalConstantDeclaration(PhpParser.GlobalConstantDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#enumDeclaration}. + * @param ctx the parse tree + */ + void enterEnumDeclaration(PhpParser.EnumDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#enumDeclaration}. + * @param ctx the parse tree + */ + void exitEnumDeclaration(PhpParser.EnumDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#enumItem}. + * @param ctx the parse tree + */ + void enterEnumItem(PhpParser.EnumItemContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#enumItem}. + * @param ctx the parse tree + */ + void exitEnumItem(PhpParser.EnumItemContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#expressionList}. + * @param ctx the parse tree + */ + void enterExpressionList(PhpParser.ExpressionListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#expressionList}. + * @param ctx the parse tree + */ + void exitExpressionList(PhpParser.ExpressionListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#parentheses}. + * @param ctx the parse tree + */ + void enterParentheses(PhpParser.ParenthesesContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#parentheses}. + * @param ctx the parse tree + */ + void exitParentheses(PhpParser.ParenthesesContext ctx); + /** + * Enter a parse tree produced by the {@code ChainExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterChainExpression(PhpParser.ChainExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ChainExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitChainExpression(PhpParser.ChainExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code SpecialWordExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterSpecialWordExpression(PhpParser.SpecialWordExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code SpecialWordExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitSpecialWordExpression(PhpParser.SpecialWordExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ArrayCreationExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterArrayCreationExpression(PhpParser.ArrayCreationExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ArrayCreationExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitArrayCreationExpression(PhpParser.ArrayCreationExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code BackQuoteStringExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterBackQuoteStringExpression(PhpParser.BackQuoteStringExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code BackQuoteStringExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitBackQuoteStringExpression(PhpParser.BackQuoteStringExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code MatchExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterMatchExpression(PhpParser.MatchExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code MatchExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitMatchExpression(PhpParser.MatchExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code LogicalExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterLogicalExpression(PhpParser.LogicalExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code LogicalExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitLogicalExpression(PhpParser.LogicalExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code PrintExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterPrintExpression(PhpParser.PrintExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code PrintExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitPrintExpression(PhpParser.PrintExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code AssignmentExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterAssignmentExpression(PhpParser.AssignmentExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code AssignmentExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitAssignmentExpression(PhpParser.AssignmentExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code PostfixIncDecExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterPostfixIncDecExpression(PhpParser.PostfixIncDecExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code PostfixIncDecExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitPostfixIncDecExpression(PhpParser.PostfixIncDecExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code CloneExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterCloneExpression(PhpParser.CloneExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code CloneExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitCloneExpression(PhpParser.CloneExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code UnaryOperatorExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterUnaryOperatorExpression(PhpParser.UnaryOperatorExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code UnaryOperatorExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitUnaryOperatorExpression(PhpParser.UnaryOperatorExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code NewExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterNewExpression(PhpParser.NewExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code NewExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitNewExpression(PhpParser.NewExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ParenthesisExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterParenthesisExpression(PhpParser.ParenthesisExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ParenthesisExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitParenthesisExpression(PhpParser.ParenthesisExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code SpaceshipExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterSpaceshipExpression(PhpParser.SpaceshipExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code SpaceshipExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitSpaceshipExpression(PhpParser.SpaceshipExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ConditionalExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterConditionalExpression(PhpParser.ConditionalExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ConditionalExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitConditionalExpression(PhpParser.ConditionalExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code NullCoalescingExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterNullCoalescingExpression(PhpParser.NullCoalescingExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code NullCoalescingExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitNullCoalescingExpression(PhpParser.NullCoalescingExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ArithmeticExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterArithmeticExpression(PhpParser.ArithmeticExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ArithmeticExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitArithmeticExpression(PhpParser.ArithmeticExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code IndexerExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterIndexerExpression(PhpParser.IndexerExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code IndexerExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitIndexerExpression(PhpParser.IndexerExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ScalarExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterScalarExpression(PhpParser.ScalarExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ScalarExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitScalarExpression(PhpParser.ScalarExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code PrefixIncDecExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterPrefixIncDecExpression(PhpParser.PrefixIncDecExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code PrefixIncDecExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitPrefixIncDecExpression(PhpParser.PrefixIncDecExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ComparisonExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterComparisonExpression(PhpParser.ComparisonExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ComparisonExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitComparisonExpression(PhpParser.ComparisonExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code CastExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterCastExpression(PhpParser.CastExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code CastExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitCastExpression(PhpParser.CastExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code InstanceOfExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterInstanceOfExpression(PhpParser.InstanceOfExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code InstanceOfExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitInstanceOfExpression(PhpParser.InstanceOfExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code ArrayDestructExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterArrayDestructExpression(PhpParser.ArrayDestructExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code ArrayDestructExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitArrayDestructExpression(PhpParser.ArrayDestructExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code LambdaFunctionExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterLambdaFunctionExpression(PhpParser.LambdaFunctionExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code LambdaFunctionExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitLambdaFunctionExpression(PhpParser.LambdaFunctionExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code BitwiseExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void enterBitwiseExpression(PhpParser.BitwiseExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code BitwiseExpression} + * labeled alternative in {@link PhpParser#expression}. + * @param ctx the parse tree + */ + void exitBitwiseExpression(PhpParser.BitwiseExpressionContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#assignable}. + * @param ctx the parse tree + */ + void enterAssignable(PhpParser.AssignableContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#assignable}. + * @param ctx the parse tree + */ + void exitAssignable(PhpParser.AssignableContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#arrayCreation}. + * @param ctx the parse tree + */ + void enterArrayCreation(PhpParser.ArrayCreationContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#arrayCreation}. + * @param ctx the parse tree + */ + void exitArrayCreation(PhpParser.ArrayCreationContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#arrayDestructuring}. + * @param ctx the parse tree + */ + void enterArrayDestructuring(PhpParser.ArrayDestructuringContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#arrayDestructuring}. + * @param ctx the parse tree + */ + void exitArrayDestructuring(PhpParser.ArrayDestructuringContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#indexedDestructItem}. + * @param ctx the parse tree + */ + void enterIndexedDestructItem(PhpParser.IndexedDestructItemContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#indexedDestructItem}. + * @param ctx the parse tree + */ + void exitIndexedDestructItem(PhpParser.IndexedDestructItemContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#keyedDestructItem}. + * @param ctx the parse tree + */ + void enterKeyedDestructItem(PhpParser.KeyedDestructItemContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#keyedDestructItem}. + * @param ctx the parse tree + */ + void exitKeyedDestructItem(PhpParser.KeyedDestructItemContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#lambdaFunctionExpr}. + * @param ctx the parse tree + */ + void enterLambdaFunctionExpr(PhpParser.LambdaFunctionExprContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#lambdaFunctionExpr}. + * @param ctx the parse tree + */ + void exitLambdaFunctionExpr(PhpParser.LambdaFunctionExprContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#matchExpr}. + * @param ctx the parse tree + */ + void enterMatchExpr(PhpParser.MatchExprContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#matchExpr}. + * @param ctx the parse tree + */ + void exitMatchExpr(PhpParser.MatchExprContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#matchItem}. + * @param ctx the parse tree + */ + void enterMatchItem(PhpParser.MatchItemContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#matchItem}. + * @param ctx the parse tree + */ + void exitMatchItem(PhpParser.MatchItemContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#newExpr}. + * @param ctx the parse tree + */ + void enterNewExpr(PhpParser.NewExprContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#newExpr}. + * @param ctx the parse tree + */ + void exitNewExpr(PhpParser.NewExprContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#assignmentOperator}. + * @param ctx the parse tree + */ + void enterAssignmentOperator(PhpParser.AssignmentOperatorContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#assignmentOperator}. + * @param ctx the parse tree + */ + void exitAssignmentOperator(PhpParser.AssignmentOperatorContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#yieldExpression}. + * @param ctx the parse tree + */ + void enterYieldExpression(PhpParser.YieldExpressionContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#yieldExpression}. + * @param ctx the parse tree + */ + void exitYieldExpression(PhpParser.YieldExpressionContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#arrayItemList}. + * @param ctx the parse tree + */ + void enterArrayItemList(PhpParser.ArrayItemListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#arrayItemList}. + * @param ctx the parse tree + */ + void exitArrayItemList(PhpParser.ArrayItemListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#arrayItem}. + * @param ctx the parse tree + */ + void enterArrayItem(PhpParser.ArrayItemContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#arrayItem}. + * @param ctx the parse tree + */ + void exitArrayItem(PhpParser.ArrayItemContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#lambdaFunctionUseVars}. + * @param ctx the parse tree + */ + void enterLambdaFunctionUseVars(PhpParser.LambdaFunctionUseVarsContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#lambdaFunctionUseVars}. + * @param ctx the parse tree + */ + void exitLambdaFunctionUseVars(PhpParser.LambdaFunctionUseVarsContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#lambdaFunctionUseVar}. + * @param ctx the parse tree + */ + void enterLambdaFunctionUseVar(PhpParser.LambdaFunctionUseVarContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#lambdaFunctionUseVar}. + * @param ctx the parse tree + */ + void exitLambdaFunctionUseVar(PhpParser.LambdaFunctionUseVarContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#qualifiedStaticTypeRef}. + * @param ctx the parse tree + */ + void enterQualifiedStaticTypeRef(PhpParser.QualifiedStaticTypeRefContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#qualifiedStaticTypeRef}. + * @param ctx the parse tree + */ + void exitQualifiedStaticTypeRef(PhpParser.QualifiedStaticTypeRefContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#typeRef}. + * @param ctx the parse tree + */ + void enterTypeRef(PhpParser.TypeRefContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#typeRef}. + * @param ctx the parse tree + */ + void exitTypeRef(PhpParser.TypeRefContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#anonymousClass}. + * @param ctx the parse tree + */ + void enterAnonymousClass(PhpParser.AnonymousClassContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#anonymousClass}. + * @param ctx the parse tree + */ + void exitAnonymousClass(PhpParser.AnonymousClassContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#indirectTypeRef}. + * @param ctx the parse tree + */ + void enterIndirectTypeRef(PhpParser.IndirectTypeRefContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#indirectTypeRef}. + * @param ctx the parse tree + */ + void exitIndirectTypeRef(PhpParser.IndirectTypeRefContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#qualifiedNamespaceName}. + * @param ctx the parse tree + */ + void enterQualifiedNamespaceName(PhpParser.QualifiedNamespaceNameContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#qualifiedNamespaceName}. + * @param ctx the parse tree + */ + void exitQualifiedNamespaceName(PhpParser.QualifiedNamespaceNameContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#namespaceNameList}. + * @param ctx the parse tree + */ + void enterNamespaceNameList(PhpParser.NamespaceNameListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#namespaceNameList}. + * @param ctx the parse tree + */ + void exitNamespaceNameList(PhpParser.NamespaceNameListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#namespaceNameTail}. + * @param ctx the parse tree + */ + void enterNamespaceNameTail(PhpParser.NamespaceNameTailContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#namespaceNameTail}. + * @param ctx the parse tree + */ + void exitNamespaceNameTail(PhpParser.NamespaceNameTailContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#qualifiedNamespaceNameList}. + * @param ctx the parse tree + */ + void enterQualifiedNamespaceNameList(PhpParser.QualifiedNamespaceNameListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#qualifiedNamespaceNameList}. + * @param ctx the parse tree + */ + void exitQualifiedNamespaceNameList(PhpParser.QualifiedNamespaceNameListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#arguments}. + * @param ctx the parse tree + */ + void enterArguments(PhpParser.ArgumentsContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#arguments}. + * @param ctx the parse tree + */ + void exitArguments(PhpParser.ArgumentsContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#actualArgument}. + * @param ctx the parse tree + */ + void enterActualArgument(PhpParser.ActualArgumentContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#actualArgument}. + * @param ctx the parse tree + */ + void exitActualArgument(PhpParser.ActualArgumentContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#argumentName}. + * @param ctx the parse tree + */ + void enterArgumentName(PhpParser.ArgumentNameContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#argumentName}. + * @param ctx the parse tree + */ + void exitArgumentName(PhpParser.ArgumentNameContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#constantInitializer}. + * @param ctx the parse tree + */ + void enterConstantInitializer(PhpParser.ConstantInitializerContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#constantInitializer}. + * @param ctx the parse tree + */ + void exitConstantInitializer(PhpParser.ConstantInitializerContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#constant}. + * @param ctx the parse tree + */ + void enterConstant(PhpParser.ConstantContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#constant}. + * @param ctx the parse tree + */ + void exitConstant(PhpParser.ConstantContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#literalConstant}. + * @param ctx the parse tree + */ + void enterLiteralConstant(PhpParser.LiteralConstantContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#literalConstant}. + * @param ctx the parse tree + */ + void exitLiteralConstant(PhpParser.LiteralConstantContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#numericConstant}. + * @param ctx the parse tree + */ + void enterNumericConstant(PhpParser.NumericConstantContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#numericConstant}. + * @param ctx the parse tree + */ + void exitNumericConstant(PhpParser.NumericConstantContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#classConstant}. + * @param ctx the parse tree + */ + void enterClassConstant(PhpParser.ClassConstantContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#classConstant}. + * @param ctx the parse tree + */ + void exitClassConstant(PhpParser.ClassConstantContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#stringConstant}. + * @param ctx the parse tree + */ + void enterStringConstant(PhpParser.StringConstantContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#stringConstant}. + * @param ctx the parse tree + */ + void exitStringConstant(PhpParser.StringConstantContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#string}. + * @param ctx the parse tree + */ + void enterString(PhpParser.StringContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#string}. + * @param ctx the parse tree + */ + void exitString(PhpParser.StringContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#interpolatedStringPart}. + * @param ctx the parse tree + */ + void enterInterpolatedStringPart(PhpParser.InterpolatedStringPartContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#interpolatedStringPart}. + * @param ctx the parse tree + */ + void exitInterpolatedStringPart(PhpParser.InterpolatedStringPartContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#chainList}. + * @param ctx the parse tree + */ + void enterChainList(PhpParser.ChainListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#chainList}. + * @param ctx the parse tree + */ + void exitChainList(PhpParser.ChainListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#chain}. + * @param ctx the parse tree + */ + void enterChain(PhpParser.ChainContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#chain}. + * @param ctx the parse tree + */ + void exitChain(PhpParser.ChainContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#chainOrigin}. + * @param ctx the parse tree + */ + void enterChainOrigin(PhpParser.ChainOriginContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#chainOrigin}. + * @param ctx the parse tree + */ + void exitChainOrigin(PhpParser.ChainOriginContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#memberAccess}. + * @param ctx the parse tree + */ + void enterMemberAccess(PhpParser.MemberAccessContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#memberAccess}. + * @param ctx the parse tree + */ + void exitMemberAccess(PhpParser.MemberAccessContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#functionCall}. + * @param ctx the parse tree + */ + void enterFunctionCall(PhpParser.FunctionCallContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#functionCall}. + * @param ctx the parse tree + */ + void exitFunctionCall(PhpParser.FunctionCallContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#functionCallName}. + * @param ctx the parse tree + */ + void enterFunctionCallName(PhpParser.FunctionCallNameContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#functionCallName}. + * @param ctx the parse tree + */ + void exitFunctionCallName(PhpParser.FunctionCallNameContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#actualArguments}. + * @param ctx the parse tree + */ + void enterActualArguments(PhpParser.ActualArgumentsContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#actualArguments}. + * @param ctx the parse tree + */ + void exitActualArguments(PhpParser.ActualArgumentsContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#chainBase}. + * @param ctx the parse tree + */ + void enterChainBase(PhpParser.ChainBaseContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#chainBase}. + * @param ctx the parse tree + */ + void exitChainBase(PhpParser.ChainBaseContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#keyedFieldName}. + * @param ctx the parse tree + */ + void enterKeyedFieldName(PhpParser.KeyedFieldNameContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#keyedFieldName}. + * @param ctx the parse tree + */ + void exitKeyedFieldName(PhpParser.KeyedFieldNameContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#keyedSimpleFieldName}. + * @param ctx the parse tree + */ + void enterKeyedSimpleFieldName(PhpParser.KeyedSimpleFieldNameContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#keyedSimpleFieldName}. + * @param ctx the parse tree + */ + void exitKeyedSimpleFieldName(PhpParser.KeyedSimpleFieldNameContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#keyedVariable}. + * @param ctx the parse tree + */ + void enterKeyedVariable(PhpParser.KeyedVariableContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#keyedVariable}. + * @param ctx the parse tree + */ + void exitKeyedVariable(PhpParser.KeyedVariableContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#squareCurlyExpression}. + * @param ctx the parse tree + */ + void enterSquareCurlyExpression(PhpParser.SquareCurlyExpressionContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#squareCurlyExpression}. + * @param ctx the parse tree + */ + void exitSquareCurlyExpression(PhpParser.SquareCurlyExpressionContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#assignmentList}. + * @param ctx the parse tree + */ + void enterAssignmentList(PhpParser.AssignmentListContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#assignmentList}. + * @param ctx the parse tree + */ + void exitAssignmentList(PhpParser.AssignmentListContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#assignmentListElement}. + * @param ctx the parse tree + */ + void enterAssignmentListElement(PhpParser.AssignmentListElementContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#assignmentListElement}. + * @param ctx the parse tree + */ + void exitAssignmentListElement(PhpParser.AssignmentListElementContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#modifier}. + * @param ctx the parse tree + */ + void enterModifier(PhpParser.ModifierContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#modifier}. + * @param ctx the parse tree + */ + void exitModifier(PhpParser.ModifierContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#identifier}. + * @param ctx the parse tree + */ + void enterIdentifier(PhpParser.IdentifierContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#identifier}. + * @param ctx the parse tree + */ + void exitIdentifier(PhpParser.IdentifierContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#memberModifier}. + * @param ctx the parse tree + */ + void enterMemberModifier(PhpParser.MemberModifierContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#memberModifier}. + * @param ctx the parse tree + */ + void exitMemberModifier(PhpParser.MemberModifierContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#magicConstant}. + * @param ctx the parse tree + */ + void enterMagicConstant(PhpParser.MagicConstantContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#magicConstant}. + * @param ctx the parse tree + */ + void exitMagicConstant(PhpParser.MagicConstantContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#magicMethod}. + * @param ctx the parse tree + */ + void enterMagicMethod(PhpParser.MagicMethodContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#magicMethod}. + * @param ctx the parse tree + */ + void exitMagicMethod(PhpParser.MagicMethodContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#primitiveType}. + * @param ctx the parse tree + */ + void enterPrimitiveType(PhpParser.PrimitiveTypeContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#primitiveType}. + * @param ctx the parse tree + */ + void exitPrimitiveType(PhpParser.PrimitiveTypeContext ctx); + /** + * Enter a parse tree produced by {@link PhpParser#castOperation}. + * @param ctx the parse tree + */ + void enterCastOperation(PhpParser.CastOperationContext ctx); + /** + * Exit a parse tree produced by {@link PhpParser#castOperation}. + * @param ctx the parse tree + */ + void exitCastOperation(PhpParser.CastOperationContext ctx); +} \ No newline at end of file diff --git a/app/src/main/java/githubsqlfinder/App.java b/app/src/main/java/githubsqlfinder/App.java index eb4d9657ff2b79bfdf2e9ea12917d464fb13626a..620358521db1815cd6902355e0119487cb3027d7 100644 --- a/app/src/main/java/githubsqlfinder/App.java +++ b/app/src/main/java/githubsqlfinder/App.java @@ -1,20 +1,14 @@ -/* - * This Java source file was generated by the Gradle 'init' task. - */ package githubsqlfinder; import java.util.ArrayList; -import java.util.Collections; -import java.util.Comparator; import java.util.List; -import java.util.Scanner; -import java.util.UUID; -import java.io.File; -import java.io.IOException; -import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; +import java.util.Map; +import java.util.HashMap; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import org.antlr.v4.runtime.*; import org.antlr.v4.runtime.tree.*; @@ -23,48 +17,136 @@ import com.google.cloud.bigquery.FieldValueList; import com.google.cloud.bigquery.TableResult; import antlr.*; +import antlr.PhpParser.ArithmeticExpressionContext; +import antlr.PhpParser.ChainExpressionContext; +import antlr.PhpParser.StringContext; public class App { + static List<String> stringStatements = new ArrayList<>(); + static Map<String, List<String>> stringStatementsWithParts = new HashMap<>(); + static int paramIndex = 0; + static String query = ""; + static long githubTimeMs = 0; + static long antlrTimeMs = 0; + static long parsingTreeTimeMs = 0; + static int numberOfAddedQueries = 0; + static int numberOfAddedQueriesMySql = 0; + static int numberOfAddedQueriesPlSql = 0; + static int numberOfAddedQueriesPostgreSQL = 0; + static int numberOfAddedQueriesTSql = 0; + static long timeMs = 0; + public static void main(String[] args) throws Exception { - JDBC db = new JDBC(); - Scanner scanner = new Scanner(System.in); - - System.out.println("Do you want to use: "); - System.out.println("1. Example files"); - System.out.println("2. Github files"); - System.out.println("3. See database"); - System.out.println("Please enter option number: "); - - int mode = 0; - while (mode != 1 && mode != 2 && mode != 3) { - mode = scanner.nextInt(); - if (mode != 1 && mode != 2 && mode != 3) { - System.out.println("Invalid input. Please enter a valid number: "); + long sTime = System.nanoTime(); + + int numberOfGithubFilesToSearch = 100; + int batchSize = 100; + int mode = 2; + int offset = 0; + int sample = 1; + + if (args.length > 0) { + //set number of files from github that should be searched + try { + numberOfGithubFilesToSearch = Integer.parseInt(args[0]); + } catch (NumberFormatException e) { + System.err.println("The first parameter (number of files to process) was incorrect"); + return; } + + } + + if (args.length > 1) { + //set the batch size to process + try { + batchSize = Integer.parseInt(args[1]); + } catch (NumberFormatException e) { + System.err.println("The second parameter (the size of the batch) was incorrect"); + return; + } + } + + if (args.length > 2) { + //set the batch size to process + try { + mode = Integer.parseInt(args[2]); + } catch (NumberFormatException e) { + System.err.println("The third parameter (mode) was incorrect"); + return; + } + } + + if (args.length > 3) { + //set the batch size to process + try { + offset = Integer.parseInt(args[3]); + } catch (NumberFormatException e) { + System.err.println("The third parameter (offset) was incorrect"); + return; + } } + if (args.length > 4) { + //set the batch size to process + try { + sample = Integer.parseInt(args[4]); + } catch (NumberFormatException e) { + System.err.println("The fourth parameter (sample data) was incorrect"); + return; + } + } + + // + System.out.println("Number of files to process: " + numberOfGithubFilesToSearch); + System.out.println("Batch size: " + batchSize); + System.out.println("Mode (1 - Example files, 2 - Github, 3 - Clear DB): " + mode); + System.out.println("Data (1 - Sample data, 2 - Real data): " + sample); + System.out.println("offset: " + offset); + + JDBC db = new JDBC(); boolean repeatCycle = true; String input = ""; if (mode == 1) { - for (int i = 0; i < 10; i++) { - String fileName = "example" + (i + 1) + ".txt"; - Path path = Paths.get(App.class.getClassLoader().getResource(fileName).toURI()); + //example files + int maxFile = 3; + + for (int i = 0; i < maxFile; i++) { + String filePath = "example" + (i + 1) + ".txt"; + Path path = Paths.get(App.class.getClassLoader().getResource(filePath).toURI()); input = Files.readString(path); - runAntlr(input, "example", fileName); + runPhpAntlr(input, "example", filePath); + + for (String query : stringStatements) { + if (isValidQuery(query)) { + runAntlr(query.replaceAll("\\\\", ""), "example", filePath); + } + } } } else if (mode == 2) { //github + int step = 0; + int index = 0; + int originalBatchSize = batchSize; + + System.out.println("Processed files / All files"); while (repeatCycle) { GithubFinder githubFinder = new GithubFinder(); - TableResult result = githubFinder.getFilesFromGithub(); + if ((step + 1) * batchSize >= numberOfGithubFilesToSearch) { + batchSize = numberOfGithubFilesToSearch - (step * batchSize); + } + long startTime = System.nanoTime(); + TableResult result = githubFinder.getFilesFromGithub(batchSize, step, originalBatchSize, offset, sample); + long endTime = System.nanoTime(); + + githubTimeMs += (endTime - startTime) / 1_000_000; for (FieldValueList row : result.iterateAll()) { @@ -72,78 +154,187 @@ public class App { String repoName = row.get("repo_name").getStringValue(); String filePath = row.get("path").getStringValue(); - runAntlr(input, repoName, filePath); - } + runPhpAntlr(input, repoName, filePath); - System.out.println("Do you want to parse another 10 github files: "); - System.out.println("1. Yes"); - System.out.println("2. No"); - System.out.println("Please enter option number: "); - mode = 0; - while (mode != 1 && mode != 2) { - mode = scanner.nextInt(); - if (mode != 1 && mode != 2) { - System.out.println("Invalid input. Please enter a valid number: "); + for (String query : stringStatements) { + if (isValidQuery(query)) { + runAntlr(query.replaceAll("\\\\", ""), repoName, filePath); + } } + index++; + System.out.println("" + index + "/" + numberOfGithubFilesToSearch); } - if (mode == 2) { + step++; + if ((step * originalBatchSize) >= numberOfGithubFilesToSearch) { repeatCycle = false; } + } + } else if (mode == 3) { + db.deleteDb(); + } + + db.showPage(0, true); + + long eTime = System.nanoTime(); + + timeMs += (eTime - sTime) / 1_000_000; + + if (mode == 2) { + System.out.println("Github requests time in ms: " + githubTimeMs + "(" + String.format("%.2f", ((double) githubTimeMs / timeMs) * 100) + "%)"); + System.out.println("ANTLR parsing time in ms: " + antlrTimeMs + "(" + String.format("%.2f", ((double) antlrTimeMs / timeMs) * 100) + "%)"); + System.out.println("Parsing tree string finding: " + parsingTreeTimeMs + "(" + String.format("%.2f", ((double) parsingTreeTimeMs / timeMs) * 100) + "%)"); + System.out.println("Whole time: " + timeMs); + System.out.println("Number of all found queries: " + numberOfAddedQueries + "(from " + numberOfGithubFilesToSearch + " files)"); + System.out.println("Number of TSql queries: " + numberOfAddedQueriesTSql); + System.out.println("Number of Postgre SQL queries: " + numberOfAddedQueriesPostgreSQL); + System.out.println("Number of PlSql queries: " + numberOfAddedQueriesPlSql); + System.out.println("Number of MySql queries: " + numberOfAddedQueriesMySql); + System.out.println("New offset to use for query: " + (numberOfGithubFilesToSearch + offset)); + } + } + + public static void runPhpAntlr(String input, String repoName, String filePath) { + ANTLRInputStream phpInputStream = new ANTLRInputStream(input); + + PhpLexer phpLexer = new PhpLexer(phpInputStream); + CommonTokenStream phpTokens = new CommonTokenStream(phpLexer); + PhpParser phpParser = new PhpParser(phpTokens); + + phpLexer.removeErrorListeners(); + phpParser.removeErrorListeners(); - db.showPage(0); - boolean exit = false; - int index = 0; - - while (!exit) { - System.out.println("Do you want to go to (in database): "); - System.out.println("1. Next page"); - System.out.println("2. Previous page"); - System.out.println("3. Exit"); - System.out.println("Please enter option number: "); - mode = 0; - while (mode != 1 && mode != 2 && mode != 3) { - mode = scanner.nextInt(); - if (mode != 1 && mode != 2 && mode != 3) { - System.out.println("Invalid input. Please enter a valid number: "); + stringStatements = new ArrayList<>(); + phpParser.addErrorListener(new DiagnosticErrorListener()); + + long startTime = System.nanoTime(); + ParseTree phpTree = phpParser.phpBlock(); + long endTime = System.nanoTime(); + + antlrTimeMs += (endTime - startTime) / 1_000_000; + + startTime = System.nanoTime(); + parseTree(phpTree, 0); + endTime = System.nanoTime(); + parsingTreeTimeMs += (endTime - startTime) / 1_000_000; + } + + private static void parseTree(ParseTree tree, int index) { + if (tree instanceof StringContext) { + ParseTree parent = tree.getParent(); + ArithmeticExpressionContext arithmeticExpressionContext = null; + + while (parent != null && parent.getText().contains(tree.getText())) { + if (parent instanceof ArithmeticExpressionContext) { + arithmeticExpressionContext = (ArithmeticExpressionContext) parent; } + parent = parent.getParent(); } - - if (mode == 3) { - exit = true; + + if (arithmeticExpressionContext != null ) { + query = ""; + paramIndex = 0; + getParametrizedQuery(arithmeticExpressionContext); + if (!query.equals("") && !stringStatements.contains(query)) { + stringStatements.add(query); + } + arithmeticExpressionContext = null; + } else { + String text = tree.getText(); + text = text.replaceAll("\\\\", ""); + if (((text.startsWith("\'") && text.endsWith("\'")) || (text.startsWith("\"") && text.endsWith("\""))) && text.length() > 1) { + text = text.substring(1, text.length() - 1); + } + text = replacePHPVariables(text); + stringStatements.add(text); } - if (mode == 1) { + + for (int i = 0; i < tree.getChildCount(); i++) { index++; - db.showPage(10 * index); + parseTree(tree.getChild(i), index); } - if (mode == 2 && index != 0) { - index--; - db.showPage(10 * index); - } else if (index == 0 && mode == 2) { - System.out.println("You are on the first page."); + } else { + for (int i = 0; i < tree.getChildCount(); i++) { + index++; + parseTree(tree.getChild(i), index); } } + } + + public static String replacePHPVariables(String sql) { + Pattern pattern = Pattern.compile("(\\$[^\\s]+\\s)|('\\$[^']+')|(\"\\$[^\"]+\")"); + Matcher matcher = pattern.matcher(sql); + StringBuffer result = new StringBuffer(); + int paramIndex = 0; + + while (matcher.find()) { + String replacement = ":p" + paramIndex++ + " "; + matcher.appendReplacement(result, replacement); + } + matcher.appendTail(result); + + return result.toString(); + } - scanner.close(); + public static void getParametrizedQuery(ParseTree tree) { + if (tree instanceof StringContext) { + String text = tree.getText(); + text = text.replaceAll("\\\\", ""); + if (((text.startsWith("\'") && text.endsWith("\'")) || (text.startsWith("\"") && text.endsWith("\""))) && text.length() > 1) { + text = text.substring(1, text.length() - 1); + query += text; + } else { + query += text; + } + } else if (tree instanceof ChainExpressionContext) { + query += ":p" + paramIndex; + paramIndex++; + } else { + for (int i = 0; i < tree.getChildCount(); i++) { + getParametrizedQuery(tree.getChild(i)); + } + } } + public static boolean isValidQuery(String query) { + if (query == null) { + return false; + } + + String trimmedQuery = query.trim(); + + String lowerCaseQuery = trimmedQuery.toLowerCase(); + + if (lowerCaseQuery.matches("^(\"select|\'select|select).*from.*")) { + return true; + } + + if (lowerCaseQuery.matches("^(\"create table|\'create table|create table).*")) { + return true; + } + + return false; + } public static void runAntlr(String input, String repoName, String filePath) { JDBC db = new JDBC(); - boolean added = false; + input = input.toUpperCase(); List<String> plSqlStatements = new ArrayList<>(); List<String> mySqlStatements = new ArrayList<>(); List<String> tSqlStatements = new ArrayList<>(); List<String> postgreSQLStatements = new ArrayList<>(); ANTLRInputStream plSqlInputStream = new ANTLRInputStream(input); + //PLSql PlSqlLexer plSqlLexer = new PlSqlLexer(plSqlInputStream); CommonTokenStream plSqlTokens = new CommonTokenStream(plSqlLexer); PlSqlParser plSqlParser = new PlSqlParser(plSqlTokens); + plSqlLexer.removeErrorListeners(); + plSqlParser.removeErrorListeners(); ParseTree plSqlTree = plSqlParser.sql_script(); PlSqlStatementListener plSqlStatementListener = new PlSqlStatementListener(plSqlStatements::add); @@ -155,6 +346,8 @@ public class App { MySqlLexer mySqlLexer = new MySqlLexer(MySqlInputStream); CommonTokenStream mySqlTokens = new CommonTokenStream(mySqlLexer); MySqlParser mySqlParser = new MySqlParser(mySqlTokens); + mySqlLexer.removeErrorListeners(); + mySqlParser.removeErrorListeners(); ParseTree mySqlTree = mySqlParser.root(); MySqlStatementListener mySqlStatementListener = new MySqlStatementListener(mySqlStatements::add); @@ -166,6 +359,8 @@ public class App { TSqlLexer tSqlLexer = new TSqlLexer(TSqlInputStream); CommonTokenStream tSqlTokens = new CommonTokenStream(tSqlLexer); TSqlParser tSqlParser = new TSqlParser(tSqlTokens); + tSqlLexer.removeErrorListeners(); + tSqlParser.removeErrorListeners(); ParseTree tSqlTree = tSqlParser.tsql_file(); TSqlStatementListener tSqlStatementListener = new TSqlStatementListener(tSqlStatements::add); @@ -177,6 +372,8 @@ public class App { PostgreSQLLexer postgreSQLLexer = new PostgreSQLLexer(PostgreSQLInputStream); CommonTokenStream postgreSQLTokens = new CommonTokenStream(postgreSQLLexer); PostgreSQLParser postgreSQLParser = new PostgreSQLParser(postgreSQLTokens); + postgreSQLLexer.removeErrorListeners(); + postgreSQLParser.removeErrorListeners(); ParseTree postgreSQLTree = postgreSQLParser.root(); PostgreSQLStatementListener postgreSQLStatementListener = new PostgreSQLStatementListener(postgreSQLStatements::add); @@ -185,46 +382,30 @@ public class App { if (postgreSQLParser.getNumberOfSyntaxErrors() == 0) { for (int i = 0; i < postgreSQLStatements.size(); i++) { db.addSqlInfo(postgreSQLStatements.get(i), repoName, filePath, "POSTGRE SQL"); - added = true; + numberOfAddedQueries++; + numberOfAddedQueriesPostgreSQL++; } } } else { for (int i = 0; i < tSqlStatements.size(); i++) { db.addSqlInfo(tSqlStatements.get(i), repoName, filePath, "TSQL"); - added = true; + numberOfAddedQueries++; + numberOfAddedQueriesTSql++; } } } else { for (int i = 0; i < mySqlStatements.size(); i++) { db.addSqlInfo(mySqlStatements.get(i), repoName, filePath, "MYSQL"); - added = true; + numberOfAddedQueries++; + numberOfAddedQueriesMySql++; } } } else { for (int i = 0; i < plSqlStatements.size(); i++) { - db.addSqlInfo(plSqlStatements.get(i), "", "", "PROB PLSQL"); - added = true; - } - } - - if (!added) { - ArrayList<List<String>> lists = new ArrayList<>(); - lists.add(plSqlStatements); - lists.add(mySqlStatements); - lists.add(tSqlStatements); - lists.add(postgreSQLStatements); - - Collections.sort(lists, Comparator.comparingInt(List::size)); - - for (int i = 0; i < lists.get(0).size(); i++) { - db.addSqlInfo(lists.get(0).get(i), repoName, filePath, "NOT KNOWN"); - added = true; + db.addSqlInfo(plSqlStatements.get(i), repoName, filePath, "PLSQL"); + numberOfAddedQueries++; + numberOfAddedQueriesPlSql++; } } - - System.out.println(plSqlStatements.toString()); - System.out.println(mySqlStatements.toString()); - System.out.println(tSqlStatements.toString()); - System.out.println(postgreSQLStatements.toString()); } } \ No newline at end of file diff --git a/app/src/main/java/githubsqlfinder/GithubFinder.java b/app/src/main/java/githubsqlfinder/GithubFinder.java index 50260247e54d878b50673fc998050502b23e3a68..15f54baeea7c91124df32238babf62043735265b 100644 --- a/app/src/main/java/githubsqlfinder/GithubFinder.java +++ b/app/src/main/java/githubsqlfinder/GithubFinder.java @@ -14,38 +14,48 @@ import java.util.UUID; public class GithubFinder { - public TableResult getFilesFromGithub() { + public TableResult getFilesFromGithub(int batchSize, int step, int originalBatchSize, int offset, int sample) { BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService(); + + String sqlFilesQuery = "select sample_files.id, sample_files.path, sample_contents.content, sample_files.repo_name " + + "from bigquery-public-data.github_repos.sample_files as sample_files " + + "join bigquery-public-data.github_repos.sample_contents as sample_contents on sample_files.id = sample_contents.id " + + "where sample_files.path like '%.sql' limit 10;"; + String phpFilesQuery = "select path, repo_name, content " + + "from bigquery-public-data.github_repos.files as files " + + "join bigquery-public-data.github_repos.contents as contents on files.id = contents.id " + + "where files.path like '%.php' " + + "and (contents.content like '%select%from%' or contents.content like '%create table%') order by repo_name limit " + batchSize + " offset " + (offset + (step * originalBatchSize)) +";"; + + if (sample == 1) { + phpFilesQuery = "select path, repo_name, content " + + "from bigquery-public-data.github_repos.sample_files as sample_files " + + "join bigquery-public-data.github_repos.sample_contents as sample_contents on sample_files.id = sample_contents.id " + + "where sample_files.path like '%.php' " + + "and (sample_contents.content like '%select%from%' or sample_contents.content like '%create table%') order by repo_name limit " + batchSize + " offset " + (offset + (step * originalBatchSize)) +";"; + } + + System.out.println("BigQuery: " + phpFilesQuery); + QueryJobConfiguration queryConfig = - QueryJobConfiguration.newBuilder( - "select sample_files.id, sample_files.path, sample_contents.content, sample_files.repo_name " - + "from bigquery-public-data.github_repos.sample_files as sample_files " - + "join bigquery-public-data.github_repos.sample_contents as sample_contents on sample_files.id = sample_contents.id " - + "where sample_files.path like '%.sql' limit 10;") - .build(); + QueryJobConfiguration.newBuilder(phpFilesQuery).build(); - // Create a job ID so that we can safely retry. JobId jobId = JobId.of(UUID.randomUUID().toString()); Job queryJob = bigquery.create(JobInfo.newBuilder(queryConfig).setJobId(jobId).build()); - // Wait for the query to complete. try { queryJob = queryJob.waitFor(); } catch (InterruptedException e) { e.printStackTrace(); } - // Check for errors if (queryJob == null) { throw new RuntimeException("Job no longer exists"); } else if (queryJob.getStatus().getError() != null) { - // You can also look at queryJob.getStatus().getExecutionErrors() for all - // errors, not just the latest one. throw new RuntimeException(queryJob.getStatus().getError().toString()); } - // Get the results. TableResult result; try { result = queryJob.getQueryResults(); @@ -56,17 +66,6 @@ public class GithubFinder { e.printStackTrace(); } - // Print all pages of the results. - return null; - - /*System.out.printf("%nid, extension, content (first 50 characters) %n"); - for (FieldValueList row : result.iterateAll()) { - // String type - String id = row.get("id").getStringValue(); - String content = row.get("content").getStringValue(); - String path1 = row.get("path").getStringValue(); - System.out.printf("%s, %s, %s %n", id, path1.substring(path1.length()-4, path1.length()), content.replaceAll("\\s+", " ").substring(0, 50)); - }*/ } } diff --git a/app/src/main/java/githubsqlfinder/JDBC.java b/app/src/main/java/githubsqlfinder/JDBC.java index f07facf6ec7552ca9cb13d271ad3435acb5afb22..0011243cbaf86d4e2fdd3cde95b4e278423722f9 100644 --- a/app/src/main/java/githubsqlfinder/JDBC.java +++ b/app/src/main/java/githubsqlfinder/JDBC.java @@ -1,6 +1,9 @@ package githubsqlfinder; import java.sql.*; +import java.io.FileWriter; +import java.io.IOException; +import java.util.List; public class JDBC { @@ -11,8 +14,7 @@ public class JDBC { { this.connection = DriverManager.getConnection("jdbc:sqlite:sample.db"); Statement statement = connection.createStatement(); - statement.setQueryTimeout(30); // set timeout to 30 sec. - //statement.executeUpdate("drop table if exists sql_info"); + statement.setQueryTimeout(30); statement.executeUpdate("create table if not exists sql_info (id integer primary key, sql string, repo_name string, file_path string, db_dialect string)"); } catch(SQLException e) @@ -21,9 +23,23 @@ public class JDBC { } } + public void deleteDb() { + if (this.connection == null) { + this.connect(); + } + try { + Statement statement = this.connection.createStatement(); + statement.executeUpdate("drop table if exists sql_info"); + statement.executeUpdate("create table if not exists sql_info (id integer primary key, sql string, repo_name string, file_path string, db_dialect string)"); + } catch (SQLException e) { + e.printStackTrace(System.err); + System.out.printf("%d ||| %s", e.getErrorCode(), e.getMessage()); + } + } + public void addSqlInfo(String sql, String repoName, String filePath, String dbDialect) { - if (sql == "<EOF>" || sql == ";") { + if (sql.equals("<EOF>") || sql.equals(";") || sql.equals("<EOF>;")) { return; } @@ -47,7 +63,7 @@ public class JDBC { } } - public void showPage(int offset) { + public void showPage(int offset, boolean all) { if (this.connection == null) { this.connect(); @@ -55,7 +71,15 @@ public class JDBC { try { Statement statement = this.connection.createStatement(); - ResultSet rs = statement.executeQuery("select * from sql_info limit 10 offset " + offset); + + String sql; + if (all) { + sql = "select * from sql_info"; + } else { + sql = "select * from sql_info limit 100 offset " + offset; + } + + ResultSet rs = statement.executeQuery(sql); System.out.println("Id | Repozitory | File | DB dialect | SQL query"); while(rs.next()) { @@ -66,4 +90,25 @@ public class JDBC { System.out.printf("%d ||| %s", e.getErrorCode(), e.getMessage()); } } + + public static void writeCsvFile(String fileName, List<String[]> data) { + try (FileWriter writer = new FileWriter(fileName)) { + for (String[] row : data) { + writeRow(writer, row); + } + System.out.println("CSV file created: " + fileName); + } catch (IOException e) { + e.printStackTrace(); + } + } + + private static void writeRow(FileWriter writer, String[] row) throws IOException { + for (int i = 0; i < row.length; i++) { + writer.append(row[i]); + if (i < row.length - 1) { + writer.append(","); + } + } + writer.append("\n"); + } } \ No newline at end of file diff --git a/app/src/main/java/githubsqlfinder/notes.md b/app/src/main/java/githubsqlfinder/notes.md deleted file mode 100644 index 636e25521b107808be5a6ca17fdce4d73f7c401a..0000000000000000000000000000000000000000 --- a/app/src/main/java/githubsqlfinder/notes.md +++ /dev/null @@ -1,8 +0,0 @@ -1. ANTLR -- gramatiky pre 4 najväÄÅ¡ie typy SQL databáz https://www.statista.com/statistics/809750/worldwide-popularity-ranking-database-management-systems/ (oracle (pl/sql), mysql, microsoft sql server (tsql), postgresql): skúsiÅ¥ skombinovaÅ¥, ak nie, tak skúšaÅ¥ po jednom dokým sa nenájde -- pozrieÅ¥ handlovanie chýb, ak nenájde sql query -- ako orezaÅ¥ súbor, aby sa prehľadávalo Äo najmenÅ¡ie množstvo dát (zaÄiatoÄné sql slová - nie je ich veľa) -- syntax pre rôzne jazyky - spájanie sql prÃkazov (:p1, @p1, {p1}...) -- pozretie jednotlivých slovnÃkov na https://github.com/antlr/grammars-v4/blob/master/sql/tsql/TSqlLexer.g4 - -2. Ukladanie do DB diff --git a/app/src/main/resources/example1.txt b/app/src/main/resources/example1.txt index 359213a1ef10c56528ba50924a7e5279e65f3168..d390f4b8205e1627d59c04f52b11112770878d50 100644 --- a/app/src/main/resources/example1.txt +++ b/app/src/main/resources/example1.txt @@ -1,11 +1,52 @@ -WITH - my_av ANALYTIC VIEW AS ( - USING sales_av HIERARCHIES (time_hier) - ADD MEASURES ( - lag_sales AS (LAG(sales) OVER (HIERARCHY time_hier OFFSET 1)) - ) - ) -SELECT time_hier.member_name time, sales, lag_sales -FROM my_av HIERARCHIES (time_hier) -WHERE time_hier.level_name = 'YEAR' -ORDER BY time_hier.hier_order; \ No newline at end of file +<?php + +class DatabaseOracle { + var $mInsertId = null; + var $mLastResult = null; + var $lastResult = null; + var $cursor = 0; + var $mAffectedRows; + + var $ignore_DUP_VAL_ON_INDEX = false; + var $sequenceData = null; + + var $defaultCharset = 'AL32UTF8'; + + var $mFieldInfoCache = array(); + + protected function doQuery( $sql ) { + wfDebug( "SQL: [$sql]\n" ); + if ( !mb_check_encoding( $sql ) ) { + throw new MWException( "SQL encoding is invalid\n$sql" ); + } + + // handle some oracle specifics + // remove AS column/table/subquery namings + if( !$this->getFlag( DBO_DDLMODE ) ) { + $sql = preg_replace( '/ as /i', ' ', $sql ); + } + + // Oracle has issues with UNION clause if the statement includes LOB fields + // So we do a UNION ALL and then filter the results array with array_unique + $union_unique = ( preg_match( '/\/\* UNION_UNIQUE \*\/ /', $sql ) != 0 ); + // EXPLAIN syntax in Oracle is EXPLAIN PLAN FOR and it return nothing + // you have to select data from plan table after explain + $explain_id = date( 'dmYHis' ); + + $sql = preg_replace( '/^EXPLAIN /', 'EXPLAIN PLAN SET STATEMENT_ID = \'' . $explain_id . '\' FOR', $sql, 1, $explain_count ); + + if ( ( $this->mLastResult = $stmt = oci_parse( $this->mConn, $sql ) ) === false ) { + $e = oci_error( $this->mConn ); + $this->reportQueryError( $e['message'], $e['code'], $sql, __METHOD__ ); + return false; + } + + if ( $explain_count > 0 ) { + return $this->doQuery( 'SELECT id, cardinality "ROWS" FROM plan_table WHERE statement_id = \'' . $explain_id . '\'' ); + } else { + $this->mAffectedRows = oci_num_rows( $stmt ); + return true; + } + } + +} // end DatabaseOracle class \ No newline at end of file diff --git a/app/src/main/resources/example10.txt b/app/src/main/resources/example10.txt index 36c47661af7fc30a837b086e00e414debfa450df..2169f7a570982eb229732f5ccd83e691ee67afc2 100644 --- a/app/src/main/resources/example10.txt +++ b/app/src/main/resources/example10.txt @@ -1,12 +1,198 @@ -CREATE TABLE tpcds.customer_demographics ( - cd_demo_sk integer NOT NULL, - cd_gender character(1), - cd_marital_status character(1), - cd_education_status character varying(20), - cd_purchase_estimate integer, - cd_credit_rating character varying(10), - cd_dep_count integer, - cd_dep_employed_count integer, - cd_dep_college_count integer -) -:DISTRIBUTED_BY; \ No newline at end of file +""" +PostgreSQL users and databases +============================== + +This module provides tools for creating PostgreSQL users and databases. + +""" +from __future__ import with_statement + +import re + +from fabric.api import cd, env, hide, require, run, settings, sudo + + +def setup_postgis(): + require('hosts') + try: + install_postgres() + except: pass + + install_postgis() + configure_postgis() + +def install_postgres(): + require('hosts') + #add repository to be able to install latest version + sudo('touch /etc/apt/sources.list.d/pgdg.list') + sudo('echo "deb http://apt.postgresql.org/pub/repos/apt/ wheezy-pgdg main" > /etc/apt/sources.list.d/pgdg.list') + sudo('wget https://www.postgresql.org/media/keys/ACCC4CF8.asc') + sudo('apt-key add ACCC4CF8.asc; aptitude update') + sudo('rm ACCC4CF8.asc') + #sudo('aptitude install -y postgresql postgresql-server-dev-9.1') + sudo('aptitude install -y postgresql postgresql-client postgresql-contrib ') + +def install_postgis(): + require('hosts') + #require('basedir') + + #VERSION = '1.5.7' + #REP = 'http://download.osgeo.org/postgis/source' + #pkg = 'postgis-%s' % VERSION + #tar = '%s.tar.gz' % pkg + + _install_postgis_deps() + + #with cd('%(basedir)s/packages' % env): + # if not exists(tar): + # _sudo('wget %s/%s' % (REP, tar)) + # if not exists(pkg): + # _sudo('tar xzf %s' % tar) + # with cd(pkg): + # sudo('ldconfig') + # _sudo('./configure && make') + # sudo('make install') + sudo('aptitude install -y postgis') + +def configure_postgis(password=None): + v = postgres_version() + if v: + #gis_v = postgis_version(v) + #contrib = '/usr/share/postgresql/%s/contrib/postgis-%s' % (v[:3], gis_v) + for cmd in ( + '''psql -c "CREATE ROLE gisgroup;"''', + '''psql -c "CREATE EXTENSION postgis;"''', + '''psql -c "CREATE EXTENSION postgis_topology;"''', + #'''createdb -E UTF8 template_postgis''', + #'''psql -d template_postgis < %s/postgis.sql''' % contrib, + #'''psql -d template_postgis < %s/spatial_ref_sys.sql''' % contrib, + #'''psql -c "ALTER TABLE geometry_columns OWNER TO gisgroup;" template_postgis''', + #'''psql -c "ALTER TABLE spatial_ref_sys OWNER TO gisgroup;" template_postgis''', + ): + try: + _run(cmd, password) + except: pass + +def create_user(name, password, groups=None, encrypted=True): + """ + Create a PostgreSQL user. + + Example:: + + # Create DB user if it does not exist + if not user_exists('dbuser'): + create_user('dbuser', password='somerandomstring') + + """ + if encrypted: + with_password = 'WITH ENCRYPTED PASSWORD' + else: + with_password = 'WITH PASSWORD' + + if groups: + groups = ' IN GROUP %s' % ', '.join(groups) + else: + groups = '' + + _run('''psql -c "CREATE USER %(name)s %(with_password)s '%(password)s'%(groups)s;"''' % locals()) + + +def create_database(name, owner, template='template_postgis', encoding='UTF8', locale='en_US.UTF-8'): + """ + Create a PostgreSQL database. + + Example:: + + # Create DB if it does not exist + if not database_exists('myapp'): + create_database('myapp', owner='dbuser') + + """ + #_run('''createdb --owner %(owner)s --template %(template)s --encoding=%(encoding)s --lc-ctype=%(locale)s --lc-collate=%(locale)s %(name)s''' % locals()) + #_run('''createdb --owner %(owner)s --encoding=%(encoding)s --lc-ctype=%(locale)s --lc-collate=%(locale)s %(name)s''' % locals()) + _run('''createdb --owner %(owner)s %(name)s''' % locals()) + _run('''psql -d %(name)s -c "CREATE EXTENSION postgis;"''' % locals()) + _run('''psql -d %(name)s -c "CREATE EXTENSION postgis_topology;"''' % locals()) + +def user_exists(name): + """ + Check if a PostgreSQL user exists. + """ + with settings(hide('running', 'stdout', 'stderr', 'warnings'), warn_only=True): + res = _run('''psql -t -A -c "SELECT COUNT(*) FROM pg_user WHERE usename = '%(name)s';"''' % locals()) + return (res == "1") + + +def change_password(name, password, encrypted=True): + if encrypted: + with_password = 'WITH ENCRYPTED PASSWORD' + else: + with_password = 'WITH PASSWORD' + cmd = '''psql -c "ALTER USER %(name)s %(with_password)s '%(password)s';"''' % locals() + _run(cmd) + + +def database_exists(name): + """ + Check if a PostgreSQL database exists. + """ + with settings(hide('running', 'stdout', 'stderr', 'warnings'), warn_only=True): + return _run('''psql -d %(name)s -c ""''' % locals()).succeeded + +def database_backup(name): + pass + +def database_restore(): + pass + +def unconfigure_postgis(password=None): + v = postgres_version() + if v: + gis_v = postgis_version(v) + contrib = '/usr/share/postgresql/%s/contrib/postgis-%s' % (v[:3], gis_v) + _run('''psql -d template_postgis < %s/uninstall_postgis.sql''' % contrib, password) + +def postgis_version(ver=None): + if not ver: + ver = postgres_version() + else: + ver = str(ver) + contrib = '/usr/share/postgresql/%s/contrib' % ver[:3] + out = qrun('find %s -iname "postgis-*"' % contrib) + return out.replace('%s/postgis-' % contrib, '') + +def postgres_version(): + require('hosts') + out = qrun('psql --version') + s = out.split('\n')[0] + m = re.match('.+(\d+)\.(\d+)\.(\d+).*', s) + if m: + #return '%s.%s.%s' % (m.group(1), m.group(2), m.group(3)) + return '%s.%s' % (m.group(1), m.group(2)) + return '' + +def warn_only(): + return settings(hide('running', 'stdout', 'stderr', 'warnings'), + warn_only=True) + +def qrun(cmd): + with warn_only(): + return run(cmd) + +def _install_postgis_deps(): + sudo('aptitude install -y libproj-dev libpq-dev') + +def _run(command, password=None): + """ + Run command as 'postgres' user + """ + with cd('/var/lib/postgresql'): + if password: + password = 'PGPASSWORD=%s; ' % password + else: + password = '' + return sudo('%ssudo -u postgres %s' % (password, command)) + +def _sudo(cmd): + require('webapp_user') + return sudo(cmd, user='%(webapp_user)s' % env) \ No newline at end of file diff --git a/app/src/main/resources/example2.txt b/app/src/main/resources/example2.txt index ba5f9af0763d8ada0f720d461ad57e516219bd4a..72e0cffa84c029e95482fd5ea97da522575ab8a7 100644 --- a/app/src/main/resources/example2.txt +++ b/app/src/main/resources/example2.txt @@ -1,15 +1,52 @@ -autocommit off; +<?php -create table a ( c char(1)); +class DatabaseOracle { + var $mInsertId = null; + var $mLastResult = null; + var $lastResult = null; + var $cursor = 0; + var $mAffectedRows; -insert into a values('e'); -select set{'a',c} from a; -select set{c,cast('a' as varchar)} from a; -select set{c,cast('e' as varchar)} from a; -select set{c,cast('w' as varchar)} from a; + var $ignore_DUP_VAL_ON_INDEX = false; + var $sequenceData = null; -create table b ( c varchar(1),v char(1)); -insert into b values('e','e'); -select v,c,set{v,c} from b; + var $defaultCharset = 'AL32UTF8'; -rollback; \ No newline at end of file + var $mFieldInfoCache = array(); + + protected function doQuery( $sql ) { + wfDebug( "SQL: [$sql]\n" ); + if ( !mb_check_encoding( $sql ) ) { + throw new MWException( "SQL encoding is invalid\n$sql" ); + } + + // handle some oracle specifics + // remove AS column/table/subquery namings + if( !$this->getFlag( DBO_DDLMODE ) ) { + $sql = preg_replace( '/ as /i', ' ', $sql ); + } + + // Oracle has issues with UNION clause if the statement includes LOB fields + // So we do a UNION ALL and then filter the results array with array_unique + $union_unique = ( preg_match( '/\/\* UNION_UNIQUE \*\/ /', $sql ) != 0 ); + // EXPLAIN syntax in Oracle is EXPLAIN PLAN FOR and it return nothing + // you have to select data from plan table after explain + $explain_id = date( 'dmYHis' ); + + $sql = preg_replace( '/^EXPLAIN /', 'EXPLAIN PLAN SET STATEMENT_ID = \'' . $explain_id . '\' FOR', $sql, 1, $explain_count ); + + if ( ( $this->mLastResult = $stmt = oci_parse( $this->mConn, $sql ) ) === false ) { + $e = oci_error( $this->mConn ); + $this->reportQueryError( $e['message'], $e['code'], $sql, __METHOD__ ); + return false; + } + + if ( $explain_count > 0 ) { + return $this->doQuery( 'SELECT id, cardinality "ROWS" FROM plan_table WHERE statement_id = \'' . $explain_id . '\' AND statement_id_2 = ' . $explain_id_2 ); + } else { + $this->mAffectedRows = oci_num_rows( $stmt ); + return true; + } + } + +} // end DatabaseOracle class \ No newline at end of file diff --git a/app/src/main/resources/example3.txt b/app/src/main/resources/example3.txt index 21b929a159ea33b8390896cdedbd932379bcee73..36a2a3555d492804c944f8c810d2b0e47855d372 100644 --- a/app/src/main/resources/example3.txt +++ b/app/src/main/resources/example3.txt @@ -1,4 +1,59 @@ --- trace.test --- --- execsql {SELECT 't6int', [t6int], t6int, ?1, "?1", t6int FROM t6} -SELECT 't6int', [t6int], t6int, ?1, "?1", t6int FROM t6 \ No newline at end of file +<?php include "../include/config.php"; ?> +<?php include "../include/header.php"; ?> +<?php + + if (empty($_GET['StudentID'])) + { + $result = oci_parse($con, "SELECT * FROM Students ORDER BY Name ASC"); + oci_execute($result); + while($row = oci_fetch_array($result)) + { + $StudentID .= "<option value='" . $row['STUDENTID'] . "'>" . $row['NAME'] . "</option>\n"; + } + +?> +<p>Hello Student. Please select your name from the list below:<p> +<form action="index.php" method"get"> + <table cellpadding="0" cellspacing="0"> + <tr> + <td><b>Name: </b></td> + <td><select name="StudentID"><?php echo $StudentID; ?></select></td> + </tr> + </table> + <br /> + <input type="submit" value="Continue" /> +</form> +<div class="home"> + <a href="<?php echo $RootDirectory; ?>index.php">Click here to return home</a> +</div> +<?php + + } + else + { + $result = oci_parse($con, "SELECT * FROM Students WHERE StudentID='" . $_GET['StudentID'] . "'"); + oci_execute($result); + $student = oci_fetch_array($result); + +?> +<p>Hello <?php echo $student['NAME']; ?> (Student). You can view any of the following reports:<p> +<div class="list"> + <div class="item"> + <a href="evaluations/report.php?StudentID=<?php echo $student['STUDENTID']; ?>">Calendar of Evaluations</a> + </div> + <div class="item"> + <a href="courses/report.php?StudentID=<?php echo $student['STUDENTID']; ?>">My Courses</a> + </div> + <div class="item"> + <a href="grades/report.php?StudentID=<?php echo $student['STUDENTID']; ?>">My Grades</a> + </div> +</div> +<div class="home"> + <a href="<?php echo $RootDirectory; ?>index.php">Click here to return home</a> +</div> +<?php + + } + +?> +<?php include "../include/footer.php"; ?> \ No newline at end of file diff --git a/app/src/main/resources/example9.txt b/app/src/main/resources/example9.txt index 8d6405eea86803378bf067c15441af516afbf3a7..0453c3318cf3b30d3d5c027afc377915460d4f8c 100644 --- a/app/src/main/resources/example9.txt +++ b/app/src/main/resources/example9.txt @@ -1,5 +1,246 @@ -CREATE TABLE "agriculture_and_biosciences_exports" ( - "years" text, - "historical_data" text, - "target" text -); \ No newline at end of file +(function (factory) { + if (typeof module !== 'undefined' && typeof module.exports !== 'undefined' && typeof require !== 'undefined') { + // CommonJS + factory(module.exports, require('underscore-data')); + } else { + // running in browser + window.warehouse = window.warehouse || {}; + factory(window.warehouse, _); + } +})(function(exports, _) { + +function sqlEscapeIdentifier(value) { + // http://dev.mysql.com/doc/refman/5.0/en/identifiers.html + // http://www.sqlite.org/lang_keywords.html + return '`' + value.replace(/`/g, '``') + '`'; +} + +/* + * following RQL to SQL conversion taken from: + * http://github.com/persvr/perstore/blob/master/store/sql.js + */ + +var sqlOperators = { + "and" : "&", + "or" : "|", + "eq" : "=", + "ne" : "!=", + "le" : "<=", + "ge" : ">=", + "lt" : "<", + "gt" : ">" +}; + +var valueToSql = function(value){ + if(value instanceof Array){ + return "(" + value.map(function(element){ + return valueToSql(element); + }).join(",") + ")"; + } + return typeof(value) == "string" ? "'" + value.replace(/'/g,"''") + "'" : value + ''; +}; + +var safeSqlName = function(name){ + if(name.match(/[^\w_*]/)){ + throw new URIError("Illegal column name " + name); + } + name = sqlEscapeIdentifier(name); + return name; +}; + +var generateSql = function(structure){ + var sql = "SELECT " + (structure.distinct ? 'DISTINCT ' : '') + structure.select + " FROM " + structure.from + + (structure.where && (" WHERE " + structure.where)) + (structure.order.length ? (" ORDER BY " + structure.order.join(", ")): ""); + if (structure.groupBy) { + sql += " GROUP BY " + structure.groupBy; + } + if (structure.limit) { + sql += " LIMIT " + structure.limit + " OFFSET " + structure.offset; + } + return sql; +}; + +var generateSqlCount = function(structure){ + return "SELECT COUNT(*) as count FROM " + structure.from + + (structure.where && (" WHERE " + structure.where)); +}; + +var toSQL = function(options) { + options = options || {}; + var query = this; + var limit, count, offset, postHandler, results = true; + var where = ""; + var select = []; + var distinct = false; + var order = [], groupBy = ''; + var params = (options.parameters = options.parameters || []); + + function convertRql(query){ + var conjunction = query.name; + query.args.forEach(function(term, index){ + var column = term.args[0]; + switch(term.name){ + case "eq": + if(term.args[1] instanceof Array){ + if(term.args[1].length === 0){ + // an empty IN clause is considered invalid SQL + if(index > 0){ + where += " " + conjunction + " "; + } + where += "0=1"; + } + else{ + safeSqlName(column); + addClause(column + " IN " + valueToSql(term.args[1])); + } + break; + } + // else fall through + case "ne": case "lt": case "le": case "gt": case "ge": + safeSqlName(column); + addClause(options.table + '.' + column + sqlOperators[term.name] + valueToSql(term.args[1])); + break; + case "sort": + if(term.args.length === 0) + throw new URIError("Must specify a sort criteria"); + term.args.forEach(function(sortAttribute){ + var firstChar = sortAttribute.charAt(0); + var orderDir = "ASC"; + if(firstChar == "-" || firstChar == "+"){ + if(firstChar == "-"){ + orderDir = "DESC"; + } + sortAttribute = sortAttribute.substring(1); + } + safeSqlName(sortAttribute); + order.push(options.table + "." + sortAttribute + " " + orderDir); + }); + break; + case "and": case "or": + addClause("("); + convertRql(term); + where += ")"; + break; + case "in": + //print("in() is deprecated"); + if(term.args[1].length === 0){ + // an empty IN clause is considered invalid SQL + if(index > 0){ + where += " " + conjunction + " "; + } + where += "0=1"; + } + else{ + safeSqlName(column); + addClause(column + " IN " + valueToSql(term.args[1])); + } + break; + case "out": + //print("in() is deprecated"); + if(term.args[1].length === 0){ + // an empty IN clause is considered invalid SQL + if(index > 0){ + where += " " + conjunction + " "; + } + where += "0=1"; + } + else{ + safeSqlName(column); + addClause(column + " NOT IN " + valueToSql(term.args[1])); + } + break; + case "select": + term.args.forEach(safeSqlName); + select = select.concat(term.args); + break; + case "distinct": + distinct = true; + break; + case "count": + count = true; + results = false; + postHandler = function(){ + return count; + }; + break; + case "one": case "first": + limit = term.name == "one" ? 2 : 1; + postHandler = function(){ + var firstRow; + return when(results.rows.some(function(row){ + if(firstRow){ + throw new TypeError("More than one object found"); + } + firstRow = row; + }), function(){ + return firstRow; + }); + }; + break; + case "limit": + limit = term.args[0]; + offset = term.args[1]; + count = term.args[2] > limit; + break; + case "aggregate": + groupBy = column; + safeSqlName(groupBy); + column = term.args[1].args[0]; + term.name = term.args[1].name; + // break is intentionally missing + case "mean": + term.name = "avg"; + case "sum": case "max": case "min": + select.push(term.name + "(" + safeSqlName(column) + ") as value"); + postHandler = function(){ + var firstRow; + return when(results.rows.some(function(row){ + firstRow = row; + }), function(){ + return firstRow.value; + }); + }; + break; + case "search": + safeSqlName(column); + addClause("MATCH (" + column + ") AGAINST (" + valueToSql(term.args[1]) + " IN BOOLEAN MODE)"); + break; + default: + throw new URIError("Invalid query syntax, " + term.name+ " not implemented"); + } + function addClause(sqlClause){ + if(where && !where.match(/\(\s*$/)){ + where += " " + conjunction + " "; + } + where += sqlClause; + } + }); + } + convertRql(query); + var structure = { + select: select.length > 0 ? select.join(',') : '*', + distinct: distinct, + from: options.table, + where: where, + groupBy: groupBy, + order: order, + limit: limit, + offset: offset || 0 + }; + var sql; + if(count){ + sql = generateSqlCount(structure); + } else { + sql = generateSql(structure); + } + return sql; +}; + +var rql2sql = function(query, options) { + return toSQL.call(query, options); +}; + +exports.rql2sql = rql2sql; +exports.sqlEscapeIdentifier = sqlEscapeIdentifier; + +}); \ No newline at end of file diff --git a/sample.db b/sample.db index 8bf7527ccff117d47135e223008cea683a22b8ea..a6f53dc6cc8375a9c2b2156befe6015a554d1be1 100644 Binary files a/sample.db and b/sample.db differ