com.github.antlrjavaparser.Java7Parser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of antlr-java-parser Show documentation
Show all versions of antlr-java-parser Show documentation
Antlr Java Parser aims to create a Java parser using Antlr 4 grammar rules.
// Generated from Java7Parser.g4 by ANTLR 4.0
package com.github.antlrjavaparser;
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 Java7Parser extends Parser {
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
PACKAGE=2, LT=90, STAR=5, WHILE=53, CONST=92, CASE=62, CHAR=32, NEW=69,
DO=54, BREAK=59, Identifier=98, LBRACKET=18, FINAL=13, RPAREN=21, IMPORT=3,
SUBSUB=66, STAREQ=84, CARET=77, THIS=42, RETURN=58, DOUBLE=38, BARBAR=80,
WhiteSpace=99, VOID=22, SUPER=43, EQ=26, GOTO=93, AMPAMP=79, QUES=39,
EQEQ=74, RBRACE=17, STATIC=12, PRIVATE=10, SWITCH=57, NULL=44, STRICTFP=14,
ELSE=51, ELLIPSIS=41, NATIVE=27, THROWS=25, INT=35, SLASHEQ=85, ASSERT=64,
TRY=55, FloatingPointLiteral=95, GT=89, CATCH=61, FALSE=46, THROW=24,
PROTECTED=9, CLASS=6, BAREQ=87, AMP=76, PLUSPLUS=65, CharacterLiteral=96,
LBRACE=16, SUBEQ=83, FOR=52, SUB=73, FLOAT=37, ABSTRACT=11, PLUSEQ=82,
LPAREN=20, IF=50, AT=47, BOOLEAN=31, SYNCHRONIZED=28, SLASH=70, SlashComment=101,
IMPLEMENTS=7, CONTINUE=60, COMMA=15, AMPEQ=86, TRANSIENT=29, TILDE=67,
BANGEQ=75, PLUS=72, RBRACKET=19, DOT=4, BYTE=33, PERCENT=71, VOLATILE=30,
DEFAULT=48, SHORT=34, BANG=68, INSTANCEOF=91, TRUE=45, SEMI=1, StringLiteral=97,
COLON=49, ENUM=63, FINALLY=56, PERCENTEQ=88, LineTerminator=100, CARETEQ=81,
INTERFACE=23, IntegerLiteral=94, LONG=36, EXTENDS=40, PUBLIC=8, BAR=78,
EndOfLineComment=102;
public static final String[] tokenNames = {
"", "';'", "'package'", "'import'", "'.'", "'*'", "'class'",
"'implements'", "'public'", "'protected'", "'private'", "'abstract'",
"'static'", "'final'", "'strictfp'", "','", "'{'", "'}'", "'['", "']'",
"'('", "')'", "'void'", "'interface'", "'throw'", "'throws'", "'='", "'native'",
"'synchronized'", "'transient'", "'volatile'", "'boolean'", "'char'",
"'byte'", "'short'", "'int'", "'long'", "'float'", "'double'", "'?'",
"'extends'", "'...'", "'this'", "'super'", "'null'", "'true'", "'false'",
"'@'", "'default'", "':'", "'if'", "'else'", "'for'", "'while'", "'do'",
"'try'", "'finally'", "'switch'", "'return'", "'break'", "'continue'",
"'catch'", "'case'", "'enum'", "'assert'", "'++'", "'--'", "'~'", "'!'",
"'new'", "'/'", "'%'", "'+'", "'-'", "'=='", "'!='", "'&'", "'^'", "'|'",
"'&&'", "'||'", "'^='", "'+='", "'-='", "'*='", "'/='", "'&='", "'|='",
"'%='", "'>'", "'<'", "'instanceof'", "'const'", "'goto'", "IntegerLiteral",
"FloatingPointLiteral", "CharacterLiteral", "StringLiteral", "Identifier",
"WhiteSpace", "LineTerminator", "SlashComment", "EndOfLineComment"
};
public static final int
RULE_compilationUnit = 0, RULE_packageDeclaration = 1, RULE_importDeclaration = 2,
RULE_qualifiedImportName = 3, RULE_typeDeclaration = 4, RULE_classOrInterfaceDeclaration = 5,
RULE_modifiers = 6, RULE_modifier = 7, RULE_variableModifiers = 8, RULE_classDeclaration = 9,
RULE_normalClassDeclaration = 10, RULE_typeParameters = 11, RULE_typeParameter = 12,
RULE_typeBound = 13, RULE_enumDeclaration = 14, RULE_enumBody = 15, RULE_enumConstants = 16,
RULE_enumConstant = 17, RULE_enumBodyDeclarations = 18, RULE_interfaceDeclaration = 19,
RULE_normalInterfaceDeclaration = 20, RULE_typeList = 21, RULE_classBody = 22,
RULE_interfaceBody = 23, RULE_classBodyDeclaration = 24, RULE_memberDecl = 25,
RULE_methodDeclaration = 26, RULE_constructorDeclaration = 27, RULE_constructorBlock = 28,
RULE_fieldDeclaration = 29, RULE_variableDeclarator = 30, RULE_interfaceBodyDeclaration = 31,
RULE_interfaceMethodDeclaration = 32, RULE_interfaceFieldDeclaration = 33,
RULE_type = 34, RULE_classOrInterfaceType = 35, RULE_identifierTypeArgument = 36,
RULE_primitiveType = 37, RULE_typeArguments = 38, RULE_typeArgument = 39,
RULE_qualifiedNameList = 40, RULE_formalParameters = 41, RULE_formalParameterDecls = 42,
RULE_normalParameterDecl = 43, RULE_ellipsisParameterDecl = 44, RULE_explicitConstructorInvocation = 45,
RULE_qualifiedName = 46, RULE_annotations = 47, RULE_annotation = 48,
RULE_markerAnnotation = 49, RULE_singleElementAnnotation = 50, RULE_normalAnnotation = 51,
RULE_elementValuePairs = 52, RULE_elementValuePair = 53, RULE_elementValue = 54,
RULE_elementValueArrayInitializer = 55, RULE_annotationTypeDeclaration = 56,
RULE_annotationTypeBody = 57, RULE_annotationTypeElementDeclaration = 58,
RULE_annotationMethodDeclaration = 59, RULE_block = 60, RULE_blockStatement = 61,
RULE_localVariableDeclarationStatement = 62, RULE_localVariableDeclaration = 63,
RULE_statement = 64, RULE_emptyStatement = 65, RULE_switchBlockStatementGroups = 66,
RULE_switchBlockStatementGroup = 67, RULE_switchLabel = 68, RULE_trystatement = 69,
RULE_tryWithResources = 70, RULE_resourceSpecification = 71, RULE_resources = 72,
RULE_resource = 73, RULE_catches = 74, RULE_catchClause = 75, RULE_catchFormalParameter = 76,
RULE_forstatement = 77, RULE_foreachStatement = 78, RULE_normalForStatement = 79,
RULE_forInit = 80, RULE_parExpression = 81, RULE_expressionList = 82,
RULE_expression = 83, RULE_assignmentOperator = 84, RULE_conditionalExpression = 85,
RULE_conditionalOrExpression = 86, RULE_conditionalAndExpression = 87,
RULE_inclusiveOrExpression = 88, RULE_exclusiveOrExpression = 89, RULE_andExpression = 90,
RULE_equalityExpression = 91, RULE_notEqualityExpression = 92, RULE_instanceOfExpression = 93,
RULE_relationalExpression = 94, RULE_relationalOp = 95, RULE_shiftExpression = 96,
RULE_shiftOp = 97, RULE_additiveExpression = 98, RULE_additiveOp = 99,
RULE_multiplicativeExpression = 100, RULE_multiplicativeOp = 101, RULE_unaryExpression = 102,
RULE_unaryExpressionNotPlusMinus = 103, RULE_castExpression = 104, RULE_primary = 105,
RULE_superSuffix = 106, RULE_thisSuffix = 107, RULE_identifierSuffix = 108,
RULE_selector = 109, RULE_creator = 110, RULE_arrayCreator = 111, RULE_variableInitializer = 112,
RULE_arrayInitializer = 113, RULE_createdName = 114, RULE_innerCreator = 115,
RULE_classCreatorRest = 116, RULE_nonWildcardTypeArguments = 117, RULE_arguments = 118,
RULE_literal = 119, RULE_classHeader = 120, RULE_enumHeader = 121, RULE_interfaceHeader = 122,
RULE_annotationHeader = 123, RULE_typeHeader = 124, RULE_methodHeader = 125,
RULE_fieldHeader = 126, RULE_localVariableHeader = 127;
public static final String[] ruleNames = {
"compilationUnit", "packageDeclaration", "importDeclaration", "qualifiedImportName",
"typeDeclaration", "classOrInterfaceDeclaration", "modifiers", "modifier",
"variableModifiers", "classDeclaration", "normalClassDeclaration", "typeParameters",
"typeParameter", "typeBound", "enumDeclaration", "enumBody", "enumConstants",
"enumConstant", "enumBodyDeclarations", "interfaceDeclaration", "normalInterfaceDeclaration",
"typeList", "classBody", "interfaceBody", "classBodyDeclaration", "memberDecl",
"methodDeclaration", "constructorDeclaration", "constructorBlock", "fieldDeclaration",
"variableDeclarator", "interfaceBodyDeclaration", "interfaceMethodDeclaration",
"interfaceFieldDeclaration", "type", "classOrInterfaceType", "identifierTypeArgument",
"primitiveType", "typeArguments", "typeArgument", "qualifiedNameList",
"formalParameters", "formalParameterDecls", "normalParameterDecl", "ellipsisParameterDecl",
"explicitConstructorInvocation", "qualifiedName", "annotations", "annotation",
"markerAnnotation", "singleElementAnnotation", "normalAnnotation", "elementValuePairs",
"elementValuePair", "elementValue", "elementValueArrayInitializer", "annotationTypeDeclaration",
"annotationTypeBody", "annotationTypeElementDeclaration", "annotationMethodDeclaration",
"block", "blockStatement", "localVariableDeclarationStatement", "localVariableDeclaration",
"statement", "emptyStatement", "switchBlockStatementGroups", "switchBlockStatementGroup",
"switchLabel", "trystatement", "tryWithResources", "resourceSpecification",
"resources", "resource", "catches", "catchClause", "catchFormalParameter",
"forstatement", "foreachStatement", "normalForStatement", "forInit", "parExpression",
"expressionList", "expression", "assignmentOperator", "conditionalExpression",
"conditionalOrExpression", "conditionalAndExpression", "inclusiveOrExpression",
"exclusiveOrExpression", "andExpression", "equalityExpression", "notEqualityExpression",
"instanceOfExpression", "relationalExpression", "relationalOp", "shiftExpression",
"shiftOp", "additiveExpression", "additiveOp", "multiplicativeExpression",
"multiplicativeOp", "unaryExpression", "unaryExpressionNotPlusMinus",
"castExpression", "primary", "superSuffix", "thisSuffix", "identifierSuffix",
"selector", "creator", "arrayCreator", "variableInitializer", "arrayInitializer",
"createdName", "innerCreator", "classCreatorRest", "nonWildcardTypeArguments",
"arguments", "literal", "classHeader", "enumHeader", "interfaceHeader",
"annotationHeader", "typeHeader", "methodHeader", "fieldHeader", "localVariableHeader"
};
@Override
public String getGrammarFileName() { return "Java7Parser.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public ATN getATN() { return _ATN; }
public Java7Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class CompilationUnitContext extends ParserRuleContext {
public PackageDeclarationContext packageDeclaration() {
return getRuleContext(PackageDeclarationContext.class,0);
}
public ImportDeclarationContext importDeclaration(int i) {
return getRuleContext(ImportDeclarationContext.class,i);
}
public List typeDeclaration() {
return getRuleContexts(TypeDeclarationContext.class);
}
public List importDeclaration() {
return getRuleContexts(ImportDeclarationContext.class);
}
public TypeDeclarationContext typeDeclaration(int i) {
return getRuleContext(TypeDeclarationContext.class,i);
}
public CompilationUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compilationUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterCompilationUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitCompilationUnit(this);
}
}
public final CompilationUnitContext compilationUnit() throws RecognitionException {
CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
enterRule(_localctx, 0, RULE_compilationUnit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(257);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(256); packageDeclaration();
}
break;
}
setState(262);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IMPORT) {
{
{
setState(259); importDeclaration();
}
}
setState(264);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(268);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEMI) | (1L << CLASS) | (1L << PUBLIC) | (1L << PROTECTED) | (1L << PRIVATE) | (1L << ABSTRACT) | (1L << STATIC) | (1L << FINAL) | (1L << STRICTFP) | (1L << INTERFACE) | (1L << NATIVE) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE) | (1L << AT) | (1L << ENUM))) != 0)) {
{
{
setState(265); typeDeclaration();
}
}
setState(270);
_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 PackageDeclarationContext extends ParserRuleContext {
public TerminalNode PACKAGE() { return getToken(Java7Parser.PACKAGE, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public AnnotationsContext annotations() {
return getRuleContext(AnnotationsContext.class,0);
}
public PackageDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterPackageDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitPackageDeclaration(this);
}
}
public final PackageDeclarationContext packageDeclaration() throws RecognitionException {
PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState());
enterRule(_localctx, 2, RULE_packageDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(272);
_la = _input.LA(1);
if (_la==AT) {
{
setState(271); annotations();
}
}
setState(274); match(PACKAGE);
setState(275); qualifiedName();
setState(276); match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportDeclarationContext extends ParserRuleContext {
public TerminalNode DOT(int i) {
return getToken(Java7Parser.DOT, i);
}
public TerminalNode IMPORT() { return getToken(Java7Parser.IMPORT, 0); }
public TerminalNode STAR() { return getToken(Java7Parser.STAR, 0); }
public TerminalNode Identifier(int i) {
return getToken(Java7Parser.Identifier, i);
}
public List DOT() { return getTokens(Java7Parser.DOT); }
public TerminalNode STATIC() { return getToken(Java7Parser.STATIC, 0); }
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public List Identifier() { return getTokens(Java7Parser.Identifier); }
public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterImportDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitImportDeclaration(this);
}
}
public final ImportDeclarationContext importDeclaration() throws RecognitionException {
ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
enterRule(_localctx, 4, RULE_importDeclaration);
int _la;
try {
int _alt;
setState(302);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(278); match(IMPORT);
setState(280);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(279); match(STATIC);
}
}
setState(282); match(Identifier);
setState(283); match(DOT);
setState(284); match(STAR);
setState(285); match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(286); match(IMPORT);
setState(288);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(287); match(STATIC);
}
}
setState(290); match(Identifier);
setState(293);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
do {
switch (_alt) {
case 1:
{
{
setState(291); match(DOT);
setState(292); match(Identifier);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(295);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
} while ( _alt!=2 && _alt!=-1 );
setState(299);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(297); match(DOT);
setState(298); match(STAR);
}
}
setState(301); match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedImportNameContext extends ParserRuleContext {
public TerminalNode DOT(int i) {
return getToken(Java7Parser.DOT, i);
}
public TerminalNode Identifier(int i) {
return getToken(Java7Parser.Identifier, i);
}
public List DOT() { return getTokens(Java7Parser.DOT); }
public List Identifier() { return getTokens(Java7Parser.Identifier); }
public QualifiedImportNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedImportName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterQualifiedImportName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitQualifiedImportName(this);
}
}
public final QualifiedImportNameContext qualifiedImportName() throws RecognitionException {
QualifiedImportNameContext _localctx = new QualifiedImportNameContext(_ctx, getState());
enterRule(_localctx, 6, RULE_qualifiedImportName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(304); match(Identifier);
setState(309);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(305); match(DOT);
setState(306); match(Identifier);
}
}
setState(311);
_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 TypeDeclarationContext extends ParserRuleContext {
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public ClassOrInterfaceDeclarationContext classOrInterfaceDeclaration() {
return getRuleContext(ClassOrInterfaceDeclarationContext.class,0);
}
public TypeDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitTypeDeclaration(this);
}
}
public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 8, RULE_typeDeclaration);
try {
setState(314);
switch (_input.LA(1)) {
case CLASS:
case PUBLIC:
case PROTECTED:
case PRIVATE:
case ABSTRACT:
case STATIC:
case FINAL:
case STRICTFP:
case INTERFACE:
case NATIVE:
case SYNCHRONIZED:
case TRANSIENT:
case VOLATILE:
case AT:
case ENUM:
enterOuterAlt(_localctx, 1);
{
setState(312); classOrInterfaceDeclaration();
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(313); match(SEMI);
}
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 ClassOrInterfaceDeclarationContext extends ParserRuleContext {
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public ClassOrInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classOrInterfaceDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterClassOrInterfaceDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitClassOrInterfaceDeclaration(this);
}
}
public final ClassOrInterfaceDeclarationContext classOrInterfaceDeclaration() throws RecognitionException {
ClassOrInterfaceDeclarationContext _localctx = new ClassOrInterfaceDeclarationContext(_ctx, getState());
enterRule(_localctx, 10, RULE_classOrInterfaceDeclaration);
try {
setState(318);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(316); classDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(317); interfaceDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModifiersContext extends ParserRuleContext {
public List modifier() {
return getRuleContexts(ModifierContext.class);
}
public ModifierContext modifier(int i) {
return getRuleContext(ModifierContext.class,i);
}
public ModifiersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_modifiers; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterModifiers(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitModifiers(this);
}
}
public final ModifiersContext modifiers() throws RecognitionException {
ModifiersContext _localctx = new ModifiersContext(_ctx, getState());
enterRule(_localctx, 12, RULE_modifiers);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(323);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(320); modifier();
}
}
}
setState(325);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
}
}
}
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 AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public TerminalNode NATIVE() { return getToken(Java7Parser.NATIVE, 0); }
public TerminalNode FINAL() { return getToken(Java7Parser.FINAL, 0); }
public TerminalNode PROTECTED() { return getToken(Java7Parser.PROTECTED, 0); }
public TerminalNode SYNCHRONIZED() { return getToken(Java7Parser.SYNCHRONIZED, 0); }
public TerminalNode ABSTRACT() { return getToken(Java7Parser.ABSTRACT, 0); }
public TerminalNode VOLATILE() { return getToken(Java7Parser.VOLATILE, 0); }
public TerminalNode STATIC() { return getToken(Java7Parser.STATIC, 0); }
public TerminalNode PRIVATE() { return getToken(Java7Parser.PRIVATE, 0); }
public TerminalNode PUBLIC() { return getToken(Java7Parser.PUBLIC, 0); }
public TerminalNode TRANSIENT() { return getToken(Java7Parser.TRANSIENT, 0); }
public TerminalNode STRICTFP() { return getToken(Java7Parser.STRICTFP, 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 Java7ParserListener ) ((Java7ParserListener)listener).enterModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitModifier(this);
}
}
public final ModifierContext modifier() throws RecognitionException {
ModifierContext _localctx = new ModifierContext(_ctx, getState());
enterRule(_localctx, 14, RULE_modifier);
try {
setState(338);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(326); annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(327); match(PUBLIC);
}
break;
case PROTECTED:
enterOuterAlt(_localctx, 3);
{
setState(328); match(PROTECTED);
}
break;
case PRIVATE:
enterOuterAlt(_localctx, 4);
{
setState(329); match(PRIVATE);
}
break;
case STATIC:
enterOuterAlt(_localctx, 5);
{
setState(330); match(STATIC);
}
break;
case ABSTRACT:
enterOuterAlt(_localctx, 6);
{
setState(331); match(ABSTRACT);
}
break;
case FINAL:
enterOuterAlt(_localctx, 7);
{
setState(332); match(FINAL);
}
break;
case NATIVE:
enterOuterAlt(_localctx, 8);
{
setState(333); match(NATIVE);
}
break;
case SYNCHRONIZED:
enterOuterAlt(_localctx, 9);
{
setState(334); match(SYNCHRONIZED);
}
break;
case TRANSIENT:
enterOuterAlt(_localctx, 10);
{
setState(335); match(TRANSIENT);
}
break;
case VOLATILE:
enterOuterAlt(_localctx, 11);
{
setState(336); match(VOLATILE);
}
break;
case STRICTFP:
enterOuterAlt(_localctx, 12);
{
setState(337); match(STRICTFP);
}
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 VariableModifiersContext extends ParserRuleContext {
public List annotation() {
return getRuleContexts(AnnotationContext.class);
}
public TerminalNode FINAL() { return getToken(Java7Parser.FINAL, 0); }
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public VariableModifiersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableModifiers; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterVariableModifiers(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitVariableModifiers(this);
}
}
public final VariableModifiersContext variableModifiers() throws RecognitionException {
VariableModifiersContext _localctx = new VariableModifiersContext(_ctx, getState());
enterRule(_localctx, 16, RULE_variableModifiers);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(343);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(340); annotation();
}
}
}
setState(345);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
setState(347);
_la = _input.LA(1);
if (_la==FINAL) {
{
setState(346); match(FINAL);
}
}
setState(352);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(349); annotation();
}
}
setState(354);
_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 ClassDeclarationContext extends ParserRuleContext {
public NormalClassDeclarationContext normalClassDeclaration() {
return getRuleContext(NormalClassDeclarationContext.class,0);
}
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.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 Java7ParserListener ) ((Java7ParserListener)listener).enterClassDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitClassDeclaration(this);
}
}
public final ClassDeclarationContext classDeclaration() throws RecognitionException {
ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
enterRule(_localctx, 18, RULE_classDeclaration);
try {
setState(357);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(355); normalClassDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(356); enumDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NormalClassDeclarationContext extends ParserRuleContext {
public TerminalNode CLASS() { return getToken(Java7Parser.CLASS, 0); }
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public TerminalNode IMPLEMENTS() { return getToken(Java7Parser.IMPLEMENTS, 0); }
public TerminalNode EXTENDS() { return getToken(Java7Parser.EXTENDS, 0); }
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_normalClassDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterNormalClassDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitNormalClassDeclaration(this);
}
}
public final NormalClassDeclarationContext normalClassDeclaration() throws RecognitionException {
NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(_ctx, getState());
enterRule(_localctx, 20, RULE_normalClassDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(359); modifiers();
setState(360); match(CLASS);
setState(361); match(Identifier);
setState(363);
_la = _input.LA(1);
if (_la==LT) {
{
setState(362); typeParameters();
}
}
setState(367);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(365); match(EXTENDS);
setState(366); type();
}
}
setState(371);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(369); match(IMPLEMENTS);
setState(370); typeList();
}
}
setState(373); classBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParametersContext extends ParserRuleContext {
public List typeParameter() {
return getRuleContexts(TypeParameterContext.class);
}
public TerminalNode GT() { return getToken(Java7Parser.GT, 0); }
public TerminalNode LT() { return getToken(Java7Parser.LT, 0); }
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public TypeParameterContext typeParameter(int i) {
return getRuleContext(TypeParameterContext.class,i);
}
public TypeParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterTypeParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitTypeParameters(this);
}
}
public final TypeParametersContext typeParameters() throws RecognitionException {
TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
enterRule(_localctx, 22, RULE_typeParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(375); match(LT);
setState(376); typeParameter();
setState(381);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(377); match(COMMA);
setState(378); typeParameter();
}
}
setState(383);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(384); match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParameterContext extends ParserRuleContext {
public TypeBoundContext typeBound() {
return getRuleContext(TypeBoundContext.class,0);
}
public TerminalNode EXTENDS() { return getToken(Java7Parser.EXTENDS, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TypeParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterTypeParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitTypeParameter(this);
}
}
public final TypeParameterContext typeParameter() throws RecognitionException {
TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
enterRule(_localctx, 24, RULE_typeParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(386); match(Identifier);
setState(389);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(387); match(EXTENDS);
setState(388); typeBound();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeBoundContext extends ParserRuleContext {
public TerminalNode AMP(int i) {
return getToken(Java7Parser.AMP, i);
}
public List AMP() { return getTokens(Java7Parser.AMP); }
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public List type() {
return getRuleContexts(TypeContext.class);
}
public TypeBoundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeBound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterTypeBound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitTypeBound(this);
}
}
public final TypeBoundContext typeBound() throws RecognitionException {
TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());
enterRule(_localctx, 26, RULE_typeBound);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(391); type();
setState(396);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AMP) {
{
{
setState(392); match(AMP);
setState(393); type();
}
}
setState(398);
_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 EnumDeclarationContext extends ParserRuleContext {
public TerminalNode ENUM() { return getToken(Java7Parser.ENUM, 0); }
public TerminalNode IMPLEMENTS() { return getToken(Java7Parser.IMPLEMENTS, 0); }
public EnumBodyContext enumBody() {
return getRuleContext(EnumBodyContext.class,0);
}
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,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 Java7ParserListener ) ((Java7ParserListener)listener).enterEnumDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitEnumDeclaration(this);
}
}
public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
enterRule(_localctx, 28, RULE_enumDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(399); modifiers();
setState(400); match(ENUM);
setState(401); match(Identifier);
setState(404);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(402); match(IMPLEMENTS);
setState(403); typeList();
}
}
setState(406); enumBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumBodyContext extends ParserRuleContext {
public EnumBodyDeclarationsContext enumBodyDeclarations() {
return getRuleContext(EnumBodyDeclarationsContext.class,0);
}
public EnumConstantsContext enumConstants() {
return getRuleContext(EnumConstantsContext.class,0);
}
public TerminalNode RBRACE() { return getToken(Java7Parser.RBRACE, 0); }
public TerminalNode COMMA() { return getToken(Java7Parser.COMMA, 0); }
public TerminalNode LBRACE() { return getToken(Java7Parser.LBRACE, 0); }
public EnumBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterEnumBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitEnumBody(this);
}
}
public final EnumBodyContext enumBody() throws RecognitionException {
EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState());
enterRule(_localctx, 30, RULE_enumBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(408); match(LBRACE);
setState(410);
_la = _input.LA(1);
if (_la==AT || _la==Identifier) {
{
setState(409); enumConstants();
}
}
setState(413);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(412); match(COMMA);
}
}
setState(416);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(415); enumBodyDeclarations();
}
}
setState(418); match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantsContext extends ParserRuleContext {
public List enumConstant() {
return getRuleContexts(EnumConstantContext.class);
}
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public EnumConstantContext enumConstant(int i) {
return getRuleContext(EnumConstantContext.class,i);
}
public EnumConstantsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstants; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterEnumConstants(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitEnumConstants(this);
}
}
public final EnumConstantsContext enumConstants() throws RecognitionException {
EnumConstantsContext _localctx = new EnumConstantsContext(_ctx, getState());
enterRule(_localctx, 32, RULE_enumConstants);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(420); enumConstant();
setState(425);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(421); match(COMMA);
setState(422); enumConstant();
}
}
}
setState(427);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantContext extends ParserRuleContext {
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public AnnotationsContext annotations() {
return getRuleContext(AnnotationsContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public EnumConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterEnumConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitEnumConstant(this);
}
}
public final EnumConstantContext enumConstant() throws RecognitionException {
EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
enterRule(_localctx, 34, RULE_enumConstant);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(429);
_la = _input.LA(1);
if (_la==AT) {
{
setState(428); annotations();
}
}
setState(431); match(Identifier);
setState(433);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(432); arguments();
}
}
setState(436);
_la = _input.LA(1);
if (_la==LBRACE) {
{
setState(435); classBody();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumBodyDeclarationsContext extends ParserRuleContext {
public ClassBodyDeclarationContext classBodyDeclaration(int i) {
return getRuleContext(ClassBodyDeclarationContext.class,i);
}
public List classBodyDeclaration() {
return getRuleContexts(ClassBodyDeclarationContext.class);
}
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumBodyDeclarations; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterEnumBodyDeclarations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitEnumBodyDeclarations(this);
}
}
public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
enterRule(_localctx, 36, RULE_enumBodyDeclarations);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(438); match(SEMI);
setState(442);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEMI) | (1L << CLASS) | (1L << PUBLIC) | (1L << PROTECTED) | (1L << PRIVATE) | (1L << ABSTRACT) | (1L << STATIC) | (1L << FINAL) | (1L << STRICTFP) | (1L << LBRACE) | (1L << VOID) | (1L << INTERFACE) | (1L << NATIVE) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << AT) | (1L << ENUM))) != 0) || _la==LT || _la==Identifier) {
{
{
setState(439); classBodyDeclaration();
}
}
setState(444);
_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 InterfaceDeclarationContext extends ParserRuleContext {
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
}
public NormalInterfaceDeclarationContext normalInterfaceDeclaration() {
return getRuleContext(NormalInterfaceDeclarationContext.class,0);
}
public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterInterfaceDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitInterfaceDeclaration(this);
}
}
public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
enterRule(_localctx, 38, RULE_interfaceDeclaration);
try {
setState(447);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(445); normalInterfaceDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(446); annotationTypeDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NormalInterfaceDeclarationContext extends ParserRuleContext {
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public InterfaceBodyContext interfaceBody() {
return getRuleContext(InterfaceBodyContext.class,0);
}
public TerminalNode INTERFACE() { return getToken(Java7Parser.INTERFACE, 0); }
public TerminalNode EXTENDS() { return getToken(Java7Parser.EXTENDS, 0); }
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_normalInterfaceDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterNormalInterfaceDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitNormalInterfaceDeclaration(this);
}
}
public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() throws RecognitionException {
NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(_ctx, getState());
enterRule(_localctx, 40, RULE_normalInterfaceDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(449); modifiers();
setState(450); match(INTERFACE);
setState(451); match(Identifier);
setState(453);
_la = _input.LA(1);
if (_la==LT) {
{
setState(452); typeParameters();
}
}
setState(457);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(455); match(EXTENDS);
setState(456); typeList();
}
}
setState(459); interfaceBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeListContext extends ParserRuleContext {
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public List type() {
return getRuleContexts(TypeContext.class);
}
public TypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitTypeList(this);
}
}
public final TypeListContext typeList() throws RecognitionException {
TypeListContext _localctx = new TypeListContext(_ctx, getState());
enterRule(_localctx, 42, RULE_typeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(461); type();
setState(466);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(462); match(COMMA);
setState(463); type();
}
}
setState(468);
_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 ClassBodyContext extends ParserRuleContext {
public ClassBodyDeclarationContext classBodyDeclaration(int i) {
return getRuleContext(ClassBodyDeclarationContext.class,i);
}
public TerminalNode RBRACE() { return getToken(Java7Parser.RBRACE, 0); }
public List classBodyDeclaration() {
return getRuleContexts(ClassBodyDeclarationContext.class);
}
public TerminalNode LBRACE() { return getToken(Java7Parser.LBRACE, 0); }
public ClassBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterClassBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitClassBody(this);
}
}
public final ClassBodyContext classBody() throws RecognitionException {
ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
enterRule(_localctx, 44, RULE_classBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(469); match(LBRACE);
setState(473);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEMI) | (1L << CLASS) | (1L << PUBLIC) | (1L << PROTECTED) | (1L << PRIVATE) | (1L << ABSTRACT) | (1L << STATIC) | (1L << FINAL) | (1L << STRICTFP) | (1L << LBRACE) | (1L << VOID) | (1L << INTERFACE) | (1L << NATIVE) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << AT) | (1L << ENUM))) != 0) || _la==LT || _la==Identifier) {
{
{
setState(470); classBodyDeclaration();
}
}
setState(475);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(476); match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceBodyContext extends ParserRuleContext {
public InterfaceBodyDeclarationContext interfaceBodyDeclaration(int i) {
return getRuleContext(InterfaceBodyDeclarationContext.class,i);
}
public List interfaceBodyDeclaration() {
return getRuleContexts(InterfaceBodyDeclarationContext.class);
}
public TerminalNode RBRACE() { return getToken(Java7Parser.RBRACE, 0); }
public TerminalNode LBRACE() { return getToken(Java7Parser.LBRACE, 0); }
public InterfaceBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterInterfaceBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitInterfaceBody(this);
}
}
public final InterfaceBodyContext interfaceBody() throws RecognitionException {
InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
enterRule(_localctx, 46, RULE_interfaceBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(478); match(LBRACE);
setState(482);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEMI) | (1L << CLASS) | (1L << PUBLIC) | (1L << PROTECTED) | (1L << PRIVATE) | (1L << ABSTRACT) | (1L << STATIC) | (1L << FINAL) | (1L << STRICTFP) | (1L << VOID) | (1L << INTERFACE) | (1L << NATIVE) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << AT) | (1L << ENUM))) != 0) || _la==LT || _la==Identifier) {
{
{
setState(479); interfaceBodyDeclaration();
}
}
setState(484);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(485); match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassBodyDeclarationContext extends ParserRuleContext {
public MemberDeclContext memberDecl() {
return getRuleContext(MemberDeclContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode STATIC() { return getToken(Java7Parser.STATIC, 0); }
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classBodyDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterClassBodyDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitClassBodyDeclaration(this);
}
}
public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
enterRule(_localctx, 48, RULE_classBodyDeclaration);
int _la;
try {
setState(493);
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(487); match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(489);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(488); match(STATIC);
}
}
setState(491); block();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(492); memberDecl();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MemberDeclContext extends ParserRuleContext {
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public ConstructorDeclarationContext constructorDeclaration() {
return getRuleContext(ConstructorDeclarationContext.class,0);
}
public FieldDeclarationContext fieldDeclaration() {
return getRuleContext(FieldDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public MethodDeclarationContext methodDeclaration() {
return getRuleContext(MethodDeclarationContext.class,0);
}
public MemberDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_memberDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterMemberDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitMemberDecl(this);
}
}
public final MemberDeclContext memberDecl() throws RecognitionException {
MemberDeclContext _localctx = new MemberDeclContext(_ctx, getState());
enterRule(_localctx, 50, RULE_memberDecl);
try {
setState(500);
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(495); constructorDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(496); fieldDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(497); methodDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(498); classDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(499); interfaceDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodDeclarationContext extends ParserRuleContext {
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public TerminalNode THROWS() { return getToken(Java7Parser.THROWS, 0); }
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public TerminalNode VOID() { return getToken(Java7Parser.VOID, 0); }
public FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public QualifiedNameListContext qualifiedNameList() {
return getRuleContext(QualifiedNameListContext.class,0);
}
public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitMethodDeclaration(this);
}
}
public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 52, RULE_methodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(502); modifiers();
setState(504);
_la = _input.LA(1);
if (_la==LT) {
{
setState(503); typeParameters();
}
}
setState(508);
switch (_input.LA(1)) {
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
case LONG:
case FLOAT:
case DOUBLE:
case Identifier:
{
setState(506); type();
}
break;
case VOID:
{
setState(507); match(VOID);
}
break;
default:
throw new NoViableAltException(this);
}
setState(510); match(Identifier);
setState(511); formalParameters();
setState(516);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(512); match(LBRACKET);
setState(513); match(RBRACKET);
}
}
setState(518);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(521);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(519); match(THROWS);
setState(520); qualifiedNameList();
}
}
setState(525);
switch (_input.LA(1)) {
case LBRACE:
{
setState(523); block();
}
break;
case SEMI:
{
setState(524); match(SEMI);
}
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 ConstructorDeclarationContext extends ParserRuleContext {
public TerminalNode THROWS() { return getToken(Java7Parser.THROWS, 0); }
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public ConstructorBlockContext constructorBlock() {
return getRuleContext(ConstructorBlockContext.class,0);
}
public QualifiedNameListContext qualifiedNameList() {
return getRuleContext(QualifiedNameListContext.class,0);
}
public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterConstructorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitConstructorDeclaration(this);
}
}
public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
enterRule(_localctx, 54, RULE_constructorDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(527); modifiers();
setState(529);
_la = _input.LA(1);
if (_la==LT) {
{
setState(528); typeParameters();
}
}
setState(531); match(Identifier);
setState(532); formalParameters();
setState(535);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(533); match(THROWS);
setState(534); qualifiedNameList();
}
}
setState(537); constructorBlock();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorBlockContext extends ParserRuleContext {
public BlockStatementContext blockStatement(int i) {
return getRuleContext(BlockStatementContext.class,i);
}
public ExplicitConstructorInvocationContext explicitConstructorInvocation() {
return getRuleContext(ExplicitConstructorInvocationContext.class,0);
}
public TerminalNode RBRACE() { return getToken(Java7Parser.RBRACE, 0); }
public List blockStatement() {
return getRuleContexts(BlockStatementContext.class);
}
public TerminalNode LBRACE() { return getToken(Java7Parser.LBRACE, 0); }
public ConstructorBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterConstructorBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitConstructorBlock(this);
}
}
public final ConstructorBlockContext constructorBlock() throws RecognitionException {
ConstructorBlockContext _localctx = new ConstructorBlockContext(_ctx, getState());
enterRule(_localctx, 56, RULE_constructorBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(539); match(LBRACE);
setState(541);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
{
setState(540); explicitConstructorInvocation();
}
break;
}
setState(546);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEMI) | (1L << CLASS) | (1L << PUBLIC) | (1L << PROTECTED) | (1L << PRIVATE) | (1L << ABSTRACT) | (1L << STATIC) | (1L << FINAL) | (1L << STRICTFP) | (1L << LBRACE) | (1L << LPAREN) | (1L << VOID) | (1L << INTERFACE) | (1L << THROW) | (1L << NATIVE) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << THIS) | (1L << SUPER) | (1L << NULL) | (1L << TRUE) | (1L << FALSE) | (1L << AT) | (1L << IF) | (1L << FOR) | (1L << WHILE) | (1L << DO) | (1L << TRY) | (1L << SWITCH) | (1L << RETURN) | (1L << BREAK) | (1L << CONTINUE) | (1L << ENUM))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (ASSERT - 64)) | (1L << (PLUSPLUS - 64)) | (1L << (SUBSUB - 64)) | (1L << (TILDE - 64)) | (1L << (BANG - 64)) | (1L << (NEW - 64)) | (1L << (PLUS - 64)) | (1L << (SUB - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
{
setState(543); blockStatement();
}
}
setState(548);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(549); match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldDeclarationContext extends ParserRuleContext {
public List variableDeclarator() {
return getRuleContexts(VariableDeclaratorContext.class);
}
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public VariableDeclaratorContext variableDeclarator(int i) {
return getRuleContext(VariableDeclaratorContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterFieldDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitFieldDeclaration(this);
}
}
public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
enterRule(_localctx, 58, RULE_fieldDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(551); modifiers();
setState(552); type();
setState(553); variableDeclarator();
setState(558);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(554); match(COMMA);
setState(555); variableDeclarator();
}
}
setState(560);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(561); match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableDeclaratorContext extends ParserRuleContext {
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public TerminalNode EQ() { return getToken(Java7Parser.EQ, 0); }
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public VariableInitializerContext variableInitializer() {
return getRuleContext(VariableInitializerContext.class,0);
}
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterVariableDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitVariableDeclarator(this);
}
}
public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
enterRule(_localctx, 60, RULE_variableDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(563); match(Identifier);
setState(568);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(564); match(LBRACKET);
setState(565); match(RBRACKET);
}
}
setState(570);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(573);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(571); match(EQ);
setState(572); variableInitializer();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceBodyDeclarationContext extends ParserRuleContext {
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
return getRuleContext(InterfaceMethodDeclarationContext.class,0);
}
public InterfaceFieldDeclarationContext interfaceFieldDeclaration() {
return getRuleContext(InterfaceFieldDeclarationContext.class,0);
}
public InterfaceBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceBodyDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterInterfaceBodyDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitInterfaceBodyDeclaration(this);
}
}
public final InterfaceBodyDeclarationContext interfaceBodyDeclaration() throws RecognitionException {
InterfaceBodyDeclarationContext _localctx = new InterfaceBodyDeclarationContext(_ctx, getState());
enterRule(_localctx, 62, RULE_interfaceBodyDeclaration);
try {
setState(580);
switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(575); interfaceFieldDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(576); interfaceMethodDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(577); interfaceDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(578); classDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(579); match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceMethodDeclarationContext extends ParserRuleContext {
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public TerminalNode THROWS() { return getToken(Java7Parser.THROWS, 0); }
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public TerminalNode VOID() { return getToken(Java7Parser.VOID, 0); }
public FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public QualifiedNameListContext qualifiedNameList() {
return getRuleContext(QualifiedNameListContext.class,0);
}
public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterInterfaceMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitInterfaceMethodDeclaration(this);
}
}
public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 64, RULE_interfaceMethodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(582); modifiers();
setState(584);
_la = _input.LA(1);
if (_la==LT) {
{
setState(583); typeParameters();
}
}
setState(588);
switch (_input.LA(1)) {
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
case LONG:
case FLOAT:
case DOUBLE:
case Identifier:
{
setState(586); type();
}
break;
case VOID:
{
setState(587); match(VOID);
}
break;
default:
throw new NoViableAltException(this);
}
setState(590); match(Identifier);
setState(591); formalParameters();
setState(596);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(592); match(LBRACKET);
setState(593); match(RBRACKET);
}
}
setState(598);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(601);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(599); match(THROWS);
setState(600); qualifiedNameList();
}
}
setState(603); match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceFieldDeclarationContext extends ParserRuleContext {
public List variableDeclarator() {
return getRuleContexts(VariableDeclaratorContext.class);
}
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public VariableDeclaratorContext variableDeclarator(int i) {
return getRuleContext(VariableDeclaratorContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public InterfaceFieldDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceFieldDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterInterfaceFieldDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitInterfaceFieldDeclaration(this);
}
}
public final InterfaceFieldDeclarationContext interfaceFieldDeclaration() throws RecognitionException {
InterfaceFieldDeclarationContext _localctx = new InterfaceFieldDeclarationContext(_ctx, getState());
enterRule(_localctx, 66, RULE_interfaceFieldDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(605); modifiers();
setState(606); type();
setState(607); variableDeclarator();
setState(612);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(608); match(COMMA);
setState(609); variableDeclarator();
}
}
setState(614);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(615); match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeContext extends ParserRuleContext {
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitType(this);
}
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 68, RULE_type);
int _la;
try {
setState(633);
switch (_input.LA(1)) {
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(617); classOrInterfaceType();
setState(622);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(618); match(LBRACKET);
setState(619); match(RBRACKET);
}
}
setState(624);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
case LONG:
case FLOAT:
case DOUBLE:
enterOuterAlt(_localctx, 2);
{
setState(625); primitiveType();
setState(630);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(626); match(LBRACKET);
setState(627); match(RBRACKET);
}
}
setState(632);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
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 ClassOrInterfaceTypeContext extends ParserRuleContext {
public TerminalNode DOT(int i) {
return getToken(Java7Parser.DOT, i);
}
public List DOT() { return getTokens(Java7Parser.DOT); }
public IdentifierTypeArgumentContext identifierTypeArgument(int i) {
return getRuleContext(IdentifierTypeArgumentContext.class,i);
}
public List identifierTypeArgument() {
return getRuleContexts(IdentifierTypeArgumentContext.class);
}
public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterClassOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitClassOrInterfaceType(this);
}
}
public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 70, RULE_classOrInterfaceType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(635); identifierTypeArgument();
setState(640);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(636); match(DOT);
setState(637); identifierTypeArgument();
}
}
setState(642);
_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 IdentifierTypeArgumentContext extends ParserRuleContext {
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public IdentifierTypeArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierTypeArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterIdentifierTypeArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitIdentifierTypeArgument(this);
}
}
public final IdentifierTypeArgumentContext identifierTypeArgument() throws RecognitionException {
IdentifierTypeArgumentContext _localctx = new IdentifierTypeArgumentContext(_ctx, getState());
enterRule(_localctx, 72, RULE_identifierTypeArgument);
try {
enterOuterAlt(_localctx, 1);
{
setState(643); match(Identifier);
setState(645);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
{
setState(644); typeArguments();
}
break;
}
}
}
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 CHAR() { return getToken(Java7Parser.CHAR, 0); }
public TerminalNode DOUBLE() { return getToken(Java7Parser.DOUBLE, 0); }
public TerminalNode BYTE() { return getToken(Java7Parser.BYTE, 0); }
public TerminalNode SHORT() { return getToken(Java7Parser.SHORT, 0); }
public TerminalNode FLOAT() { return getToken(Java7Parser.FLOAT, 0); }
public TerminalNode INT() { return getToken(Java7Parser.INT, 0); }
public TerminalNode BOOLEAN() { return getToken(Java7Parser.BOOLEAN, 0); }
public TerminalNode LONG() { return getToken(Java7Parser.LONG, 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 Java7ParserListener ) ((Java7ParserListener)listener).enterPrimitiveType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitPrimitiveType(this);
}
}
public final PrimitiveTypeContext primitiveType() throws RecognitionException {
PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
enterRule(_localctx, 74, RULE_primitiveType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(647);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentsContext extends ParserRuleContext {
public TerminalNode GT() { return getToken(Java7Parser.GT, 0); }
public TerminalNode LT() { return getToken(Java7Parser.LT, 0); }
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public TypeArgumentContext typeArgument(int i) {
return getRuleContext(TypeArgumentContext.class,i);
}
public List typeArgument() {
return getRuleContexts(TypeArgumentContext.class);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitTypeArguments(this);
}
}
public final TypeArgumentsContext typeArguments() throws RecognitionException {
TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 76, RULE_typeArguments);
int _la;
try {
setState(662);
switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(649); match(LT);
setState(650); typeArgument();
setState(655);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(651); match(COMMA);
setState(652); typeArgument();
}
}
setState(657);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(658); match(GT);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(660); match(LT);
setState(661); match(GT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentContext extends ParserRuleContext {
public TerminalNode SUPER() { return getToken(Java7Parser.SUPER, 0); }
public TerminalNode EXTENDS() { return getToken(Java7Parser.EXTENDS, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode QUES() { return getToken(Java7Parser.QUES, 0); }
public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterTypeArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitTypeArgument(this);
}
}
public final TypeArgumentContext typeArgument() throws RecognitionException {
TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
enterRule(_localctx, 78, RULE_typeArgument);
int _la;
try {
setState(670);
switch (_input.LA(1)) {
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
case LONG:
case FLOAT:
case DOUBLE:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(664); type();
}
break;
case QUES:
enterOuterAlt(_localctx, 2);
{
setState(665); match(QUES);
setState(668);
_la = _input.LA(1);
if (_la==EXTENDS || _la==SUPER) {
{
setState(666);
_la = _input.LA(1);
if ( !(_la==EXTENDS || _la==SUPER) ) {
_errHandler.recoverInline(this);
}
consume();
setState(667); type();
}
}
}
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 QualifiedNameListContext extends ParserRuleContext {
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public List qualifiedName() {
return getRuleContexts(QualifiedNameContext.class);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public QualifiedNameContext qualifiedName(int i) {
return getRuleContext(QualifiedNameContext.class,i);
}
public QualifiedNameListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedNameList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterQualifiedNameList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitQualifiedNameList(this);
}
}
public final QualifiedNameListContext qualifiedNameList() throws RecognitionException {
QualifiedNameListContext _localctx = new QualifiedNameListContext(_ctx, getState());
enterRule(_localctx, 80, RULE_qualifiedNameList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(672); qualifiedName();
setState(677);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(673); match(COMMA);
setState(674); qualifiedName();
}
}
setState(679);
_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 FormalParametersContext extends ParserRuleContext {
public TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public FormalParameterDeclsContext formalParameterDecls() {
return getRuleContext(FormalParameterDeclsContext.class,0);
}
public TerminalNode LPAREN() { return getToken(Java7Parser.LPAREN, 0); }
public FormalParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterFormalParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitFormalParameters(this);
}
}
public final FormalParametersContext formalParameters() throws RecognitionException {
FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
enterRule(_localctx, 82, RULE_formalParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(680); match(LPAREN);
setState(682);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << AT))) != 0) || _la==Identifier) {
{
setState(681); formalParameterDecls();
}
}
setState(684); match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FormalParameterDeclsContext extends ParserRuleContext {
public int parameterType;
public NormalParameterDeclContext normalParameterDecl(int i) {
return getRuleContext(NormalParameterDeclContext.class,i);
}
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public EllipsisParameterDeclContext ellipsisParameterDecl() {
return getRuleContext(EllipsisParameterDeclContext.class,0);
}
public List normalParameterDecl() {
return getRuleContexts(NormalParameterDeclContext.class);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public FormalParameterDeclsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameterDecls; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterFormalParameterDecls(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitFormalParameterDecls(this);
}
}
public final FormalParameterDeclsContext formalParameterDecls() throws RecognitionException {
FormalParameterDeclsContext _localctx = new FormalParameterDeclsContext(_ctx, getState());
enterRule(_localctx, 84, RULE_formalParameterDecls);
int _la;
try {
int _alt;
setState(709);
switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(686); ellipsisParameterDecl();
((FormalParameterDeclsContext)_localctx).parameterType = 1;
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(689); normalParameterDecl();
setState(694);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(690); match(COMMA);
setState(691); normalParameterDecl();
}
}
setState(696);
_errHandler.sync(this);
_la = _input.LA(1);
}
((FormalParameterDeclsContext)_localctx).parameterType = 2;
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(702);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
do {
switch (_alt) {
case 1:
{
{
setState(699); normalParameterDecl();
setState(700); match(COMMA);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(704);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
} while ( _alt!=2 && _alt!=-1 );
setState(706); ellipsisParameterDecl();
((FormalParameterDeclsContext)_localctx).parameterType = 3;
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NormalParameterDeclContext extends ParserRuleContext {
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public VariableModifiersContext variableModifiers() {
return getRuleContext(VariableModifiersContext.class,0);
}
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public NormalParameterDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_normalParameterDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterNormalParameterDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitNormalParameterDecl(this);
}
}
public final NormalParameterDeclContext normalParameterDecl() throws RecognitionException {
NormalParameterDeclContext _localctx = new NormalParameterDeclContext(_ctx, getState());
enterRule(_localctx, 86, RULE_normalParameterDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(711); variableModifiers();
setState(712); type();
setState(713); match(Identifier);
setState(718);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(714); match(LBRACKET);
setState(715); match(RBRACKET);
}
}
setState(720);
_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 EllipsisParameterDeclContext extends ParserRuleContext {
public TerminalNode ELLIPSIS() { return getToken(Java7Parser.ELLIPSIS, 0); }
public VariableModifiersContext variableModifiers() {
return getRuleContext(VariableModifiersContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public EllipsisParameterDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ellipsisParameterDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterEllipsisParameterDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitEllipsisParameterDecl(this);
}
}
public final EllipsisParameterDeclContext ellipsisParameterDecl() throws RecognitionException {
EllipsisParameterDeclContext _localctx = new EllipsisParameterDeclContext(_ctx, getState());
enterRule(_localctx, 88, RULE_ellipsisParameterDecl);
try {
enterOuterAlt(_localctx, 1);
{
setState(721); variableModifiers();
setState(722); type();
setState(723); match(ELLIPSIS);
setState(724); match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExplicitConstructorInvocationContext extends ParserRuleContext {
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public TerminalNode SUPER() { return getToken(Java7Parser.SUPER, 0); }
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public TerminalNode DOT() { return getToken(Java7Parser.DOT, 0); }
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public TerminalNode THIS() { return getToken(Java7Parser.THIS, 0); }
public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explicitConstructorInvocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterExplicitConstructorInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitExplicitConstructorInvocation(this);
}
}
public final ExplicitConstructorInvocationContext explicitConstructorInvocation() throws RecognitionException {
ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(_ctx, getState());
enterRule(_localctx, 90, RULE_explicitConstructorInvocation);
int _la;
try {
setState(742);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(727);
_la = _input.LA(1);
if (_la==LT) {
{
setState(726); nonWildcardTypeArguments();
}
}
setState(729);
_la = _input.LA(1);
if ( !(_la==THIS || _la==SUPER) ) {
_errHandler.recoverInline(this);
}
consume();
setState(730); arguments();
setState(731); match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(733); primary();
setState(734); match(DOT);
setState(736);
_la = _input.LA(1);
if (_la==LT) {
{
setState(735); nonWildcardTypeArguments();
}
}
setState(738); match(SUPER);
setState(739); arguments();
setState(740); match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedNameContext extends ParserRuleContext {
public TerminalNode DOT(int i) {
return getToken(Java7Parser.DOT, i);
}
public TerminalNode Identifier(int i) {
return getToken(Java7Parser.Identifier, i);
}
public List DOT() { return getTokens(Java7Parser.DOT); }
public List Identifier() { return getTokens(Java7Parser.Identifier); }
public QualifiedNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterQualifiedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitQualifiedName(this);
}
}
public final QualifiedNameContext qualifiedName() throws RecognitionException {
QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState());
enterRule(_localctx, 92, RULE_qualifiedName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(744); match(Identifier);
setState(749);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(745); match(DOT);
setState(746); match(Identifier);
}
}
setState(751);
_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 AnnotationsContext extends ParserRuleContext {
public List annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public AnnotationsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotations; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterAnnotations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAnnotations(this);
}
}
public final AnnotationsContext annotations() throws RecognitionException {
AnnotationsContext _localctx = new AnnotationsContext(_ctx, getState());
enterRule(_localctx, 94, RULE_annotations);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(753);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(752); annotation();
}
}
setState(755);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==AT );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationContext extends ParserRuleContext {
public MarkerAnnotationContext markerAnnotation() {
return getRuleContext(MarkerAnnotationContext.class,0);
}
public NormalAnnotationContext normalAnnotation() {
return getRuleContext(NormalAnnotationContext.class,0);
}
public SingleElementAnnotationContext singleElementAnnotation() {
return getRuleContext(SingleElementAnnotationContext.class,0);
}
public AnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAnnotation(this);
}
}
public final AnnotationContext annotation() throws RecognitionException {
AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
enterRule(_localctx, 96, RULE_annotation);
try {
setState(760);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(757); markerAnnotation();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(758); singleElementAnnotation();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(759); normalAnnotation();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MarkerAnnotationContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(Java7Parser.AT, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public MarkerAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_markerAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterMarkerAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitMarkerAnnotation(this);
}
}
public final MarkerAnnotationContext markerAnnotation() throws RecognitionException {
MarkerAnnotationContext _localctx = new MarkerAnnotationContext(_ctx, getState());
enterRule(_localctx, 98, RULE_markerAnnotation);
try {
enterOuterAlt(_localctx, 1);
{
setState(762); match(AT);
setState(763); qualifiedName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleElementAnnotationContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(Java7Parser.AT, 0); }
public TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,0);
}
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode LPAREN() { return getToken(Java7Parser.LPAREN, 0); }
public SingleElementAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleElementAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterSingleElementAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitSingleElementAnnotation(this);
}
}
public final SingleElementAnnotationContext singleElementAnnotation() throws RecognitionException {
SingleElementAnnotationContext _localctx = new SingleElementAnnotationContext(_ctx, getState());
enterRule(_localctx, 100, RULE_singleElementAnnotation);
try {
enterOuterAlt(_localctx, 1);
{
setState(765); match(AT);
setState(766); qualifiedName();
setState(767); match(LPAREN);
setState(768); elementValue();
setState(769); match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NormalAnnotationContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(Java7Parser.AT, 0); }
public TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public ElementValuePairsContext elementValuePairs() {
return getRuleContext(ElementValuePairsContext.class,0);
}
public TerminalNode LPAREN() { return getToken(Java7Parser.LPAREN, 0); }
public NormalAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_normalAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterNormalAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitNormalAnnotation(this);
}
}
public final NormalAnnotationContext normalAnnotation() throws RecognitionException {
NormalAnnotationContext _localctx = new NormalAnnotationContext(_ctx, getState());
enterRule(_localctx, 102, RULE_normalAnnotation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(771); match(AT);
setState(772); qualifiedName();
setState(773); match(LPAREN);
setState(775);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(774); elementValuePairs();
}
}
setState(777); match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValuePairsContext extends ParserRuleContext {
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public ElementValuePairContext elementValuePair(int i) {
return getRuleContext(ElementValuePairContext.class,i);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public List elementValuePair() {
return getRuleContexts(ElementValuePairContext.class);
}
public ElementValuePairsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValuePairs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterElementValuePairs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitElementValuePairs(this);
}
}
public final ElementValuePairsContext elementValuePairs() throws RecognitionException {
ElementValuePairsContext _localctx = new ElementValuePairsContext(_ctx, getState());
enterRule(_localctx, 104, RULE_elementValuePairs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(779); elementValuePair();
setState(784);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(780); match(COMMA);
setState(781); elementValuePair();
}
}
setState(786);
_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 ElementValuePairContext extends ParserRuleContext {
public ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,0);
}
public TerminalNode EQ() { return getToken(Java7Parser.EQ, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ElementValuePairContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValuePair; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterElementValuePair(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitElementValuePair(this);
}
}
public final ElementValuePairContext elementValuePair() throws RecognitionException {
ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState());
enterRule(_localctx, 106, RULE_elementValuePair);
try {
enterOuterAlt(_localctx, 1);
{
setState(787); match(Identifier);
setState(788); match(EQ);
setState(789); elementValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValueContext extends ParserRuleContext {
public ElementValueArrayInitializerContext elementValueArrayInitializer() {
return getRuleContext(ElementValueArrayInitializerContext.class,0);
}
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public ConditionalExpressionContext conditionalExpression() {
return getRuleContext(ConditionalExpressionContext.class,0);
}
public ElementValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterElementValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitElementValue(this);
}
}
public final ElementValueContext elementValue() throws RecognitionException {
ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
enterRule(_localctx, 108, RULE_elementValue);
try {
setState(794);
switch (_input.LA(1)) {
case LPAREN:
case VOID:
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
case LONG:
case FLOAT:
case DOUBLE:
case THIS:
case SUPER:
case NULL:
case TRUE:
case FALSE:
case PLUSPLUS:
case SUBSUB:
case TILDE:
case BANG:
case NEW:
case PLUS:
case SUB:
case IntegerLiteral:
case FloatingPointLiteral:
case CharacterLiteral:
case StringLiteral:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(791); conditionalExpression();
}
break;
case AT:
enterOuterAlt(_localctx, 2);
{
setState(792); annotation();
}
break;
case LBRACE:
enterOuterAlt(_localctx, 3);
{
setState(793); elementValueArrayInitializer();
}
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 ElementValueArrayInitializerContext extends ParserRuleContext {
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public List elementValue() {
return getRuleContexts(ElementValueContext.class);
}
public TerminalNode RBRACE() { return getToken(Java7Parser.RBRACE, 0); }
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public TerminalNode LBRACE() { return getToken(Java7Parser.LBRACE, 0); }
public ElementValueContext elementValue(int i) {
return getRuleContext(ElementValueContext.class,i);
}
public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterElementValueArrayInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitElementValueArrayInitializer(this);
}
}
public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException {
ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState());
enterRule(_localctx, 110, RULE_elementValueArrayInitializer);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(796); match(LBRACE);
setState(805);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LBRACE) | (1L << LPAREN) | (1L << VOID) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << THIS) | (1L << SUPER) | (1L << NULL) | (1L << TRUE) | (1L << FALSE) | (1L << AT))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PLUSPLUS - 65)) | (1L << (SUBSUB - 65)) | (1L << (TILDE - 65)) | (1L << (BANG - 65)) | (1L << (NEW - 65)) | (1L << (PLUS - 65)) | (1L << (SUB - 65)) | (1L << (IntegerLiteral - 65)) | (1L << (FloatingPointLiteral - 65)) | (1L << (CharacterLiteral - 65)) | (1L << (StringLiteral - 65)) | (1L << (Identifier - 65)))) != 0)) {
{
setState(797); elementValue();
setState(802);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,84,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(798); match(COMMA);
setState(799); elementValue();
}
}
}
setState(804);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,84,_ctx);
}
}
}
setState(808);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(807); match(COMMA);
}
}
setState(810); match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeDeclarationContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(Java7Parser.AT, 0); }
public TerminalNode INTERFACE() { return getToken(Java7Parser.INTERFACE, 0); }
public AnnotationTypeBodyContext annotationTypeBody() {
return getRuleContext(AnnotationTypeBodyContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterAnnotationTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAnnotationTypeDeclaration(this);
}
}
public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 112, RULE_annotationTypeDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(812); modifiers();
setState(813); match(AT);
setState(814); match(INTERFACE);
setState(815); match(Identifier);
setState(816); annotationTypeBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeBodyContext extends ParserRuleContext {
public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration(int i) {
return getRuleContext(AnnotationTypeElementDeclarationContext.class,i);
}
public TerminalNode RBRACE() { return getToken(Java7Parser.RBRACE, 0); }
public List annotationTypeElementDeclaration() {
return getRuleContexts(AnnotationTypeElementDeclarationContext.class);
}
public TerminalNode LBRACE() { return getToken(Java7Parser.LBRACE, 0); }
public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterAnnotationTypeBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAnnotationTypeBody(this);
}
}
public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException {
AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState());
enterRule(_localctx, 114, RULE_annotationTypeBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(818); match(LBRACE);
setState(822);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEMI) | (1L << CLASS) | (1L << PUBLIC) | (1L << PROTECTED) | (1L << PRIVATE) | (1L << ABSTRACT) | (1L << STATIC) | (1L << FINAL) | (1L << STRICTFP) | (1L << INTERFACE) | (1L << NATIVE) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << AT) | (1L << ENUM))) != 0) || _la==Identifier) {
{
{
setState(819); annotationTypeElementDeclaration();
}
}
setState(824);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(825); match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext {
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
}
public AnnotationMethodDeclarationContext annotationMethodDeclaration() {
return getRuleContext(AnnotationMethodDeclarationContext.class,0);
}
public NormalClassDeclarationContext normalClassDeclaration() {
return getRuleContext(NormalClassDeclarationContext.class,0);
}
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public NormalInterfaceDeclarationContext normalInterfaceDeclaration() {
return getRuleContext(NormalInterfaceDeclarationContext.class,0);
}
public InterfaceFieldDeclarationContext interfaceFieldDeclaration() {
return getRuleContext(InterfaceFieldDeclarationContext.class,0);
}
public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterAnnotationTypeElementDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAnnotationTypeElementDeclaration(this);
}
}
public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException {
AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState());
enterRule(_localctx, 116, RULE_annotationTypeElementDeclaration);
try {
setState(834);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(827); annotationMethodDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(828); interfaceFieldDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(829); normalClassDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(830); normalInterfaceDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(831); enumDeclaration();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(832); annotationTypeDeclaration();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(833); match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationMethodDeclarationContext extends ParserRuleContext {
public TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,0);
}
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public TerminalNode LPAREN() { return getToken(Java7Parser.LPAREN, 0); }
public TerminalNode DEFAULT() { return getToken(Java7Parser.DEFAULT, 0); }
public AnnotationMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationMethodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterAnnotationMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAnnotationMethodDeclaration(this);
}
}
public final AnnotationMethodDeclarationContext annotationMethodDeclaration() throws RecognitionException {
AnnotationMethodDeclarationContext _localctx = new AnnotationMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 118, RULE_annotationMethodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(836); modifiers();
setState(837); type();
setState(838); match(Identifier);
setState(839); match(LPAREN);
setState(840); match(RPAREN);
setState(843);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(841); match(DEFAULT);
setState(842); elementValue();
}
}
setState(845); match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockContext extends ParserRuleContext {
public BlockStatementContext blockStatement(int i) {
return getRuleContext(BlockStatementContext.class,i);
}
public TerminalNode RBRACE() { return getToken(Java7Parser.RBRACE, 0); }
public List blockStatement() {
return getRuleContexts(BlockStatementContext.class);
}
public TerminalNode LBRACE() { return getToken(Java7Parser.LBRACE, 0); }
public BlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitBlock(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 120, RULE_block);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(847); match(LBRACE);
setState(851);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEMI) | (1L << CLASS) | (1L << PUBLIC) | (1L << PROTECTED) | (1L << PRIVATE) | (1L << ABSTRACT) | (1L << STATIC) | (1L << FINAL) | (1L << STRICTFP) | (1L << LBRACE) | (1L << LPAREN) | (1L << VOID) | (1L << INTERFACE) | (1L << THROW) | (1L << NATIVE) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << THIS) | (1L << SUPER) | (1L << NULL) | (1L << TRUE) | (1L << FALSE) | (1L << AT) | (1L << IF) | (1L << FOR) | (1L << WHILE) | (1L << DO) | (1L << TRY) | (1L << SWITCH) | (1L << RETURN) | (1L << BREAK) | (1L << CONTINUE) | (1L << ENUM))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (ASSERT - 64)) | (1L << (PLUSPLUS - 64)) | (1L << (SUBSUB - 64)) | (1L << (TILDE - 64)) | (1L << (BANG - 64)) | (1L << (NEW - 64)) | (1L << (PLUS - 64)) | (1L << (SUB - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
{
setState(848); blockStatement();
}
}
setState(853);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(854); match(RBRACE);
}
}
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 StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() {
return getRuleContext(LocalVariableDeclarationStatementContext.class,0);
}
public ClassOrInterfaceDeclarationContext classOrInterfaceDeclaration() {
return getRuleContext(ClassOrInterfaceDeclarationContext.class,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 Java7ParserListener ) ((Java7ParserListener)listener).enterBlockStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitBlockStatement(this);
}
}
public final BlockStatementContext blockStatement() throws RecognitionException {
BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState());
enterRule(_localctx, 122, RULE_blockStatement);
try {
setState(859);
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(856); localVariableDeclarationStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(857); classOrInterfaceDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(858); statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocalVariableDeclarationStatementContext extends ParserRuleContext {
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public LocalVariableDeclarationContext localVariableDeclaration() {
return getRuleContext(LocalVariableDeclarationContext.class,0);
}
public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_localVariableDeclarationStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterLocalVariableDeclarationStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitLocalVariableDeclarationStatement(this);
}
}
public final LocalVariableDeclarationStatementContext localVariableDeclarationStatement() throws RecognitionException {
LocalVariableDeclarationStatementContext _localctx = new LocalVariableDeclarationStatementContext(_ctx, getState());
enterRule(_localctx, 124, RULE_localVariableDeclarationStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(861); localVariableDeclaration();
setState(862); match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocalVariableDeclarationContext extends ParserRuleContext {
public List variableDeclarator() {
return getRuleContexts(VariableDeclaratorContext.class);
}
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public VariableModifiersContext variableModifiers() {
return getRuleContext(VariableModifiersContext.class,0);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public VariableDeclaratorContext variableDeclarator(int i) {
return getRuleContext(VariableDeclaratorContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_localVariableDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterLocalVariableDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitLocalVariableDeclaration(this);
}
}
public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException {
LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState());
enterRule(_localctx, 126, RULE_localVariableDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(864); variableModifiers();
setState(865); type();
setState(866); variableDeclarator();
setState(871);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(867); match(COMMA);
setState(868); variableDeclarator();
}
}
setState(873);
_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 StatementContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RBRACE() { return getToken(Java7Parser.RBRACE, 0); }
public TerminalNode WHILE() { return getToken(Java7Parser.WHILE, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode SWITCH() { return getToken(Java7Parser.SWITCH, 0); }
public TerminalNode ELSE() { return getToken(Java7Parser.ELSE, 0); }
public TerminalNode LBRACE() { return getToken(Java7Parser.LBRACE, 0); }
public TerminalNode DO() { return getToken(Java7Parser.DO, 0); }
public SwitchBlockStatementGroupsContext switchBlockStatementGroups() {
return getRuleContext(SwitchBlockStatementGroupsContext.class,0);
}
public ForstatementContext forstatement() {
return getRuleContext(ForstatementContext.class,0);
}
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public TerminalNode ASSERT() { return getToken(Java7Parser.ASSERT, 0); }
public TerminalNode BREAK() { return getToken(Java7Parser.BREAK, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TerminalNode IF() { return getToken(Java7Parser.IF, 0); }
public TerminalNode COLON() { return getToken(Java7Parser.COLON, 0); }
public ParExpressionContext parExpression() {
return getRuleContext(ParExpressionContext.class,0);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public TerminalNode SYNCHRONIZED() { return getToken(Java7Parser.SYNCHRONIZED, 0); }
public TerminalNode CONTINUE() { return getToken(Java7Parser.CONTINUE, 0); }
public EmptyStatementContext emptyStatement() {
return getRuleContext(EmptyStatementContext.class,0);
}
public TrystatementContext trystatement() {
return getRuleContext(TrystatementContext.class,0);
}
public TerminalNode RETURN() { return getToken(Java7Parser.RETURN, 0); }
public List statement() {
return getRuleContexts(StatementContext.class);
}
public TerminalNode THROW() { return getToken(Java7Parser.THROW, 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 Java7ParserListener ) ((Java7ParserListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitStatement(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 128, RULE_statement);
int _la;
try {
setState(938);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(874); block();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(875); match(ASSERT);
setState(876); expression();
setState(879);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(877); match(COLON);
setState(878); expression();
}
}
setState(881); match(SEMI);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(883); match(IF);
setState(884); parExpression();
setState(885); statement();
setState(888);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
{
setState(886); match(ELSE);
setState(887); statement();
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(890); forstatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(891); match(WHILE);
setState(892); parExpression();
setState(893); statement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(895); match(DO);
setState(896); statement();
setState(897); match(WHILE);
setState(898); parExpression();
setState(899); match(SEMI);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(901); trystatement();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(902); match(SWITCH);
setState(903); parExpression();
setState(904); match(LBRACE);
setState(905); switchBlockStatementGroups();
setState(906); match(RBRACE);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(908); match(SYNCHRONIZED);
setState(909); parExpression();
setState(910); block();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(912); match(RETURN);
setState(914);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << VOID) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << THIS) | (1L << SUPER) | (1L << NULL) | (1L << TRUE) | (1L << FALSE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PLUSPLUS - 65)) | (1L << (SUBSUB - 65)) | (1L << (TILDE - 65)) | (1L << (BANG - 65)) | (1L << (NEW - 65)) | (1L << (PLUS - 65)) | (1L << (SUB - 65)) | (1L << (IntegerLiteral - 65)) | (1L << (FloatingPointLiteral - 65)) | (1L << (CharacterLiteral - 65)) | (1L << (StringLiteral - 65)) | (1L << (Identifier - 65)))) != 0)) {
{
setState(913); expression();
}
}
setState(916); match(SEMI);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(917); match(THROW);
setState(918); expression();
setState(919); match(SEMI);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(921); match(BREAK);
setState(923);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(922); match(Identifier);
}
}
setState(925); match(SEMI);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(926); match(CONTINUE);
setState(928);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(927); match(Identifier);
}
}
setState(930); match(SEMI);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(931); expression();
setState(932); match(SEMI);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(934); match(Identifier);
setState(935); match(COLON);
setState(936); statement();
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(937); emptyStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EmptyStatementContext extends ParserRuleContext {
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public EmptyStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_emptyStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterEmptyStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitEmptyStatement(this);
}
}
public final EmptyStatementContext emptyStatement() throws RecognitionException {
EmptyStatementContext _localctx = new EmptyStatementContext(_ctx, getState());
enterRule(_localctx, 130, RULE_emptyStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(940); match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchBlockStatementGroupsContext extends ParserRuleContext {
public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) {
return getRuleContext(SwitchBlockStatementGroupContext.class,i);
}
public List switchBlockStatementGroup() {
return getRuleContexts(SwitchBlockStatementGroupContext.class);
}
public SwitchBlockStatementGroupsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchBlockStatementGroups; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterSwitchBlockStatementGroups(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitSwitchBlockStatementGroups(this);
}
}
public final SwitchBlockStatementGroupsContext switchBlockStatementGroups() throws RecognitionException {
SwitchBlockStatementGroupsContext _localctx = new SwitchBlockStatementGroupsContext(_ctx, getState());
enterRule(_localctx, 132, RULE_switchBlockStatementGroups);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(945);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DEFAULT || _la==CASE) {
{
{
setState(942); switchBlockStatementGroup();
}
}
setState(947);
_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 SwitchBlockStatementGroupContext extends ParserRuleContext {
public BlockStatementContext blockStatement(int i) {
return getRuleContext(BlockStatementContext.class,i);
}
public SwitchLabelContext switchLabel() {
return getRuleContext(SwitchLabelContext.class,0);
}
public List blockStatement() {
return getRuleContexts(BlockStatementContext.class);
}
public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterSwitchBlockStatementGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitSwitchBlockStatementGroup(this);
}
}
public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException {
SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState());
enterRule(_localctx, 134, RULE_switchBlockStatementGroup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(948); switchLabel();
setState(952);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEMI) | (1L << CLASS) | (1L << PUBLIC) | (1L << PROTECTED) | (1L << PRIVATE) | (1L << ABSTRACT) | (1L << STATIC) | (1L << FINAL) | (1L << STRICTFP) | (1L << LBRACE) | (1L << LPAREN) | (1L << VOID) | (1L << INTERFACE) | (1L << THROW) | (1L << NATIVE) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << THIS) | (1L << SUPER) | (1L << NULL) | (1L << TRUE) | (1L << FALSE) | (1L << AT) | (1L << IF) | (1L << FOR) | (1L << WHILE) | (1L << DO) | (1L << TRY) | (1L << SWITCH) | (1L << RETURN) | (1L << BREAK) | (1L << CONTINUE) | (1L << ENUM))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (ASSERT - 64)) | (1L << (PLUSPLUS - 64)) | (1L << (SUBSUB - 64)) | (1L << (TILDE - 64)) | (1L << (BANG - 64)) | (1L << (NEW - 64)) | (1L << (PLUS - 64)) | (1L << (SUB - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
{
setState(949); blockStatement();
}
}
setState(954);
_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 SwitchLabelContext extends ParserRuleContext {
public TerminalNode COLON() { return getToken(Java7Parser.COLON, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(Java7Parser.DEFAULT, 0); }
public TerminalNode CASE() { return getToken(Java7Parser.CASE, 0); }
public SwitchLabelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchLabel; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterSwitchLabel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitSwitchLabel(this);
}
}
public final SwitchLabelContext switchLabel() throws RecognitionException {
SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState());
enterRule(_localctx, 136, RULE_switchLabel);
try {
setState(961);
switch (_input.LA(1)) {
case CASE:
enterOuterAlt(_localctx, 1);
{
setState(955); match(CASE);
setState(956); expression();
setState(957); match(COLON);
}
break;
case DEFAULT:
enterOuterAlt(_localctx, 2);
{
setState(959); match(DEFAULT);
setState(960); match(COLON);
}
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 TrystatementContext extends ParserRuleContext {
public int statementType;
public BlockContext block(int i) {
return getRuleContext(BlockContext.class,i);
}
public CatchesContext catches() {
return getRuleContext(CatchesContext.class,0);
}
public TryWithResourcesContext tryWithResources() {
return getRuleContext(TryWithResourcesContext.class,0);
}
public TerminalNode FINALLY() { return getToken(Java7Parser.FINALLY, 0); }
public List block() {
return getRuleContexts(BlockContext.class);
}
public TerminalNode TRY() { return getToken(Java7Parser.TRY, 0); }
public TrystatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trystatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterTrystatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitTrystatement(this);
}
}
public final TrystatementContext trystatement() throws RecognitionException {
TrystatementContext _localctx = new TrystatementContext(_ctx, getState());
enterRule(_localctx, 138, RULE_trystatement);
try {
setState(988);
switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(963); match(TRY);
setState(964); block();
((TrystatementContext)_localctx).statementType = 1;
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(967); match(TRY);
setState(968); block();
setState(969); catches();
setState(970); match(FINALLY);
setState(971); block();
((TrystatementContext)_localctx).statementType = 2;
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(974); match(TRY);
setState(975); block();
setState(976); catches();
((TrystatementContext)_localctx).statementType = 3;
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(979); match(TRY);
setState(980); block();
setState(981); match(FINALLY);
setState(982); block();
((TrystatementContext)_localctx).statementType = 4;
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(985); tryWithResources();
((TrystatementContext)_localctx).statementType = 5;
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TryWithResourcesContext extends ParserRuleContext {
public BlockContext block(int i) {
return getRuleContext(BlockContext.class,i);
}
public ResourceSpecificationContext resourceSpecification() {
return getRuleContext(ResourceSpecificationContext.class,0);
}
public CatchesContext catches() {
return getRuleContext(CatchesContext.class,0);
}
public TerminalNode FINALLY() { return getToken(Java7Parser.FINALLY, 0); }
public List block() {
return getRuleContexts(BlockContext.class);
}
public TerminalNode TRY() { return getToken(Java7Parser.TRY, 0); }
public TryWithResourcesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tryWithResources; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterTryWithResources(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitTryWithResources(this);
}
}
public final TryWithResourcesContext tryWithResources() throws RecognitionException {
TryWithResourcesContext _localctx = new TryWithResourcesContext(_ctx, getState());
enterRule(_localctx, 140, RULE_tryWithResources);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(990); match(TRY);
setState(991); resourceSpecification();
setState(992); block();
setState(994);
_la = _input.LA(1);
if (_la==CATCH) {
{
setState(993); catches();
}
}
setState(998);
_la = _input.LA(1);
if (_la==FINALLY) {
{
setState(996); match(FINALLY);
setState(997); block();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourceSpecificationContext extends ParserRuleContext {
public ResourcesContext resources() {
return getRuleContext(ResourcesContext.class,0);
}
public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resourceSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterResourceSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitResourceSpecification(this);
}
}
public final ResourceSpecificationContext resourceSpecification() throws RecognitionException {
ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState());
enterRule(_localctx, 142, RULE_resourceSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1000); match(LPAREN);
setState(1001); resources();
setState(1003);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(1002); match(SEMI);
}
}
setState(1005); match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourcesContext extends ParserRuleContext {
public ResourceContext resource(int i) {
return getRuleContext(ResourceContext.class,i);
}
public List resource() {
return getRuleContexts(ResourceContext.class);
}
public ResourcesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resources; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterResources(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitResources(this);
}
}
public final ResourcesContext resources() throws RecognitionException {
ResourcesContext _localctx = new ResourcesContext(_ctx, getState());
enterRule(_localctx, 144, RULE_resources);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1007); resource();
setState(1012);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,106,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(1008); match(SEMI);
setState(1009); resource();
}
}
}
setState(1014);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,106,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourceContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public VariableModifiersContext variableModifiers() {
return getRuleContext(VariableModifiersContext.class,0);
}
public TerminalNode EQ() { return getToken(Java7Parser.EQ, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ResourceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resource; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitResource(this);
}
}
public final ResourceContext resource() throws RecognitionException {
ResourceContext _localctx = new ResourceContext(_ctx, getState());
enterRule(_localctx, 146, RULE_resource);
try {
enterOuterAlt(_localctx, 1);
{
setState(1016);
switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
case 1:
{
setState(1015); variableModifiers();
}
break;
}
setState(1018); type();
setState(1019); match(Identifier);
setState(1020); match(EQ);
setState(1021); expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchesContext extends ParserRuleContext {
public List catchClause() {
return getRuleContexts(CatchClauseContext.class);
}
public CatchClauseContext catchClause(int i) {
return getRuleContext(CatchClauseContext.class,i);
}
public CatchesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catches; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterCatches(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitCatches(this);
}
}
public final CatchesContext catches() throws RecognitionException {
CatchesContext _localctx = new CatchesContext(_ctx, getState());
enterRule(_localctx, 148, RULE_catches);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1023); catchClause();
setState(1027);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CATCH) {
{
{
setState(1024); catchClause();
}
}
setState(1029);
_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 CatchClauseContext extends ParserRuleContext {
public TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public TerminalNode CATCH() { return getToken(Java7Parser.CATCH, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TerminalNode LPAREN() { return getToken(Java7Parser.LPAREN, 0); }
public CatchFormalParameterContext catchFormalParameter() {
return getRuleContext(CatchFormalParameterContext.class,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 Java7ParserListener ) ((Java7ParserListener)listener).enterCatchClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitCatchClause(this);
}
}
public final CatchClauseContext catchClause() throws RecognitionException {
CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState());
enterRule(_localctx, 150, RULE_catchClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1030); match(CATCH);
setState(1031); match(LPAREN);
setState(1032); catchFormalParameter();
setState(1033); match(RPAREN);
setState(1034); block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchFormalParameterContext extends ParserRuleContext {
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public VariableModifiersContext variableModifiers() {
return getRuleContext(VariableModifiersContext.class,0);
}
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public TerminalNode BAR(int i) {
return getToken(Java7Parser.BAR, i);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public List BAR() { return getTokens(Java7Parser.BAR); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public List type() {
return getRuleContexts(TypeContext.class);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public CatchFormalParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchFormalParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterCatchFormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitCatchFormalParameter(this);
}
}
public final CatchFormalParameterContext catchFormalParameter() throws RecognitionException {
CatchFormalParameterContext _localctx = new CatchFormalParameterContext(_ctx, getState());
enterRule(_localctx, 152, RULE_catchFormalParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1036); variableModifiers();
setState(1037); type();
setState(1042);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BAR) {
{
{
setState(1038); match(BAR);
setState(1039); type();
}
}
setState(1044);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1045); match(Identifier);
setState(1050);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(1046); match(LBRACKET);
setState(1047); match(RBRACKET);
}
}
setState(1052);
_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 ForstatementContext extends ParserRuleContext {
public NormalForStatementContext normalForStatement() {
return getRuleContext(NormalForStatementContext.class,0);
}
public ForeachStatementContext foreachStatement() {
return getRuleContext(ForeachStatementContext.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 Java7ParserListener ) ((Java7ParserListener)listener).enterForstatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitForstatement(this);
}
}
public final ForstatementContext forstatement() throws RecognitionException {
ForstatementContext _localctx = new ForstatementContext(_ctx, getState());
enterRule(_localctx, 154, RULE_forstatement);
try {
setState(1055);
switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1053); foreachStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1054); normalForStatement();
}
break;
}
}
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 StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode COLON() { return getToken(Java7Parser.COLON, 0); }
public TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public TerminalNode FOR() { return getToken(Java7Parser.FOR, 0); }
public VariableModifiersContext variableModifiers() {
return getRuleContext(VariableModifiersContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode LPAREN() { return getToken(Java7Parser.LPAREN, 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 Java7ParserListener ) ((Java7ParserListener)listener).enterForeachStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitForeachStatement(this);
}
}
public final ForeachStatementContext foreachStatement() throws RecognitionException {
ForeachStatementContext _localctx = new ForeachStatementContext(_ctx, getState());
enterRule(_localctx, 156, RULE_foreachStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1057); match(FOR);
setState(1058); match(LPAREN);
setState(1059); variableModifiers();
setState(1060); type();
setState(1061); match(Identifier);
setState(1062); match(COLON);
setState(1063); expression();
setState(1064); match(RPAREN);
setState(1065); statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NormalForStatementContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public TerminalNode FOR() { return getToken(Java7Parser.FOR, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public List SEMI() { return getTokens(Java7Parser.SEMI); }
public ForInitContext forInit() {
return getRuleContext(ForInitContext.class,0);
}
public TerminalNode SEMI(int i) {
return getToken(Java7Parser.SEMI, i);
}
public TerminalNode LPAREN() { return getToken(Java7Parser.LPAREN, 0); }
public NormalForStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_normalForStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterNormalForStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitNormalForStatement(this);
}
}
public final NormalForStatementContext normalForStatement() throws RecognitionException {
NormalForStatementContext _localctx = new NormalForStatementContext(_ctx, getState());
enterRule(_localctx, 158, RULE_normalForStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1067); match(FOR);
setState(1068); match(LPAREN);
setState(1070);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << LPAREN) | (1L << VOID) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << THIS) | (1L << SUPER) | (1L << NULL) | (1L << TRUE) | (1L << FALSE) | (1L << AT))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PLUSPLUS - 65)) | (1L << (SUBSUB - 65)) | (1L << (TILDE - 65)) | (1L << (BANG - 65)) | (1L << (NEW - 65)) | (1L << (PLUS - 65)) | (1L << (SUB - 65)) | (1L << (IntegerLiteral - 65)) | (1L << (FloatingPointLiteral - 65)) | (1L << (CharacterLiteral - 65)) | (1L << (StringLiteral - 65)) | (1L << (Identifier - 65)))) != 0)) {
{
setState(1069); forInit();
}
}
setState(1072); match(SEMI);
setState(1074);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << VOID) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << THIS) | (1L << SUPER) | (1L << NULL) | (1L << TRUE) | (1L << FALSE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PLUSPLUS - 65)) | (1L << (SUBSUB - 65)) | (1L << (TILDE - 65)) | (1L << (BANG - 65)) | (1L << (NEW - 65)) | (1L << (PLUS - 65)) | (1L << (SUB - 65)) | (1L << (IntegerLiteral - 65)) | (1L << (FloatingPointLiteral - 65)) | (1L << (CharacterLiteral - 65)) | (1L << (StringLiteral - 65)) | (1L << (Identifier - 65)))) != 0)) {
{
setState(1073); expression();
}
}
setState(1076); match(SEMI);
setState(1078);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << VOID) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << THIS) | (1L << SUPER) | (1L << NULL) | (1L << TRUE) | (1L << FALSE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PLUSPLUS - 65)) | (1L << (SUBSUB - 65)) | (1L << (TILDE - 65)) | (1L << (BANG - 65)) | (1L << (NEW - 65)) | (1L << (PLUS - 65)) | (1L << (SUB - 65)) | (1L << (IntegerLiteral - 65)) | (1L << (FloatingPointLiteral - 65)) | (1L << (CharacterLiteral - 65)) | (1L << (StringLiteral - 65)) | (1L << (Identifier - 65)))) != 0)) {
{
setState(1077); expressionList();
}
}
setState(1080); match(RPAREN);
setState(1081); statement();
}
}
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 LocalVariableDeclarationContext localVariableDeclaration() {
return getRuleContext(LocalVariableDeclarationContext.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 Java7ParserListener ) ((Java7ParserListener)listener).enterForInit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitForInit(this);
}
}
public final ForInitContext forInit() throws RecognitionException {
ForInitContext _localctx = new ForInitContext(_ctx, getState());
enterRule(_localctx, 160, RULE_forInit);
try {
setState(1085);
switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1083); localVariableDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1084); expressionList();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public TerminalNode LPAREN() { return getToken(Java7Parser.LPAREN, 0); }
public ParExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterParExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitParExpression(this);
}
}
public final ParExpressionContext parExpression() throws RecognitionException {
ParExpressionContext _localctx = new ParExpressionContext(_ctx, getState());
enterRule(_localctx, 162, RULE_parExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1087); match(LPAREN);
setState(1088); expression();
setState(1089); match(RPAREN);
}
}
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 expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
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 Java7ParserListener ) ((Java7ParserListener)listener).enterExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitExpressionList(this);
}
}
public final ExpressionListContext expressionList() throws RecognitionException {
ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
enterRule(_localctx, 164, RULE_expressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1091); expression();
setState(1096);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1092); match(COMMA);
setState(1093); expression();
}
}
setState(1098);
_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 ExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public AssignmentOperatorContext assignmentOperator() {
return getRuleContext(AssignmentOperatorContext.class,0);
}
public ConditionalExpressionContext conditionalExpression() {
return getRuleContext(ConditionalExpressionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitExpression(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 166, RULE_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1099); conditionalExpression();
setState(1103);
_la = _input.LA(1);
if (_la==EQ || ((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & ((1L << (CARETEQ - 81)) | (1L << (PLUSEQ - 81)) | (1L << (SUBEQ - 81)) | (1L << (STAREQ - 81)) | (1L << (SLASHEQ - 81)) | (1L << (AMPEQ - 81)) | (1L << (BAREQ - 81)) | (1L << (PERCENTEQ - 81)) | (1L << (GT - 81)) | (1L << (LT - 81)))) != 0)) {
{
setState(1100); assignmentOperator();
setState(1101); expression();
}
}
}
}
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 int assignmentType;
public TerminalNode SUBEQ() { return getToken(Java7Parser.SUBEQ, 0); }
public List GT() { return getTokens(Java7Parser.GT); }
public TerminalNode CARETEQ() { return getToken(Java7Parser.CARETEQ, 0); }
public List LT() { return getTokens(Java7Parser.LT); }
public TerminalNode SLASHEQ() { return getToken(Java7Parser.SLASHEQ, 0); }
public TerminalNode PERCENTEQ() { return getToken(Java7Parser.PERCENTEQ, 0); }
public TerminalNode BAREQ() { return getToken(Java7Parser.BAREQ, 0); }
public TerminalNode EQ() { return getToken(Java7Parser.EQ, 0); }
public TerminalNode LT(int i) {
return getToken(Java7Parser.LT, i);
}
public TerminalNode AMPEQ() { return getToken(Java7Parser.AMPEQ, 0); }
public TerminalNode GT(int i) {
return getToken(Java7Parser.GT, i);
}
public TerminalNode STAREQ() { return getToken(Java7Parser.STAREQ, 0); }
public TerminalNode PLUSEQ() { return getToken(Java7Parser.PLUSEQ, 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 Java7ParserListener ) ((Java7ParserListener)listener).enterAssignmentOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAssignmentOperator(this);
}
}
public final AssignmentOperatorContext assignmentOperator() throws RecognitionException {
AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState());
enterRule(_localctx, 168, RULE_assignmentOperator);
try {
setState(1136);
switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1105); match(EQ);
((AssignmentOperatorContext)_localctx).assignmentType = 1;
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1107); match(PLUSEQ);
((AssignmentOperatorContext)_localctx).assignmentType = 2;
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1109); match(SUBEQ);
((AssignmentOperatorContext)_localctx).assignmentType = 3;
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1111); match(STAREQ);
((AssignmentOperatorContext)_localctx).assignmentType = 4;
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1113); match(SLASHEQ);
((AssignmentOperatorContext)_localctx).assignmentType = 5;
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1115); match(AMPEQ);
((AssignmentOperatorContext)_localctx).assignmentType = 6;
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1117); match(BAREQ);
((AssignmentOperatorContext)_localctx).assignmentType = 7;
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1119); match(CARETEQ);
((AssignmentOperatorContext)_localctx).assignmentType = 8;
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(1121); match(PERCENTEQ);
((AssignmentOperatorContext)_localctx).assignmentType = 9;
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(1123); match(LT);
setState(1124); match(LT);
setState(1125); match(EQ);
((AssignmentOperatorContext)_localctx).assignmentType = 10;
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(1127); match(GT);
setState(1128); match(GT);
setState(1129); match(GT);
setState(1130); match(EQ);
((AssignmentOperatorContext)_localctx).assignmentType = 11;
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(1132); match(GT);
setState(1133); match(GT);
setState(1134); match(EQ);
((AssignmentOperatorContext)_localctx).assignmentType = 12;
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConditionalExpressionContext extends ParserRuleContext {
public TerminalNode COLON() { return getToken(Java7Parser.COLON, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ConditionalOrExpressionContext conditionalOrExpression() {
return getRuleContext(ConditionalOrExpressionContext.class,0);
}
public TerminalNode QUES() { return getToken(Java7Parser.QUES, 0); }
public ConditionalExpressionContext conditionalExpression() {
return getRuleContext(ConditionalExpressionContext.class,0);
}
public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterConditionalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitConditionalExpression(this);
}
}
public final ConditionalExpressionContext conditionalExpression() throws RecognitionException {
ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState());
enterRule(_localctx, 170, RULE_conditionalExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1138); conditionalOrExpression();
setState(1144);
_la = _input.LA(1);
if (_la==QUES) {
{
setState(1139); match(QUES);
setState(1140); expression();
setState(1141); match(COLON);
setState(1142); conditionalExpression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConditionalOrExpressionContext extends ParserRuleContext {
public List BARBAR() { return getTokens(Java7Parser.BARBAR); }
public TerminalNode BARBAR(int i) {
return getToken(Java7Parser.BARBAR, i);
}
public List conditionalAndExpression() {
return getRuleContexts(ConditionalAndExpressionContext.class);
}
public ConditionalAndExpressionContext conditionalAndExpression(int i) {
return getRuleContext(ConditionalAndExpressionContext.class,i);
}
public ConditionalOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterConditionalOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitConditionalOrExpression(this);
}
}
public final ConditionalOrExpressionContext conditionalOrExpression() throws RecognitionException {
ConditionalOrExpressionContext _localctx = new ConditionalOrExpressionContext(_ctx, getState());
enterRule(_localctx, 172, RULE_conditionalOrExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1146); conditionalAndExpression();
setState(1151);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BARBAR) {
{
{
setState(1147); match(BARBAR);
setState(1148); conditionalAndExpression();
}
}
setState(1153);
_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 ConditionalAndExpressionContext extends ParserRuleContext {
public List inclusiveOrExpression() {
return getRuleContexts(InclusiveOrExpressionContext.class);
}
public List AMPAMP() { return getTokens(Java7Parser.AMPAMP); }
public InclusiveOrExpressionContext inclusiveOrExpression(int i) {
return getRuleContext(InclusiveOrExpressionContext.class,i);
}
public TerminalNode AMPAMP(int i) {
return getToken(Java7Parser.AMPAMP, i);
}
public ConditionalAndExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalAndExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterConditionalAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitConditionalAndExpression(this);
}
}
public final ConditionalAndExpressionContext conditionalAndExpression() throws RecognitionException {
ConditionalAndExpressionContext _localctx = new ConditionalAndExpressionContext(_ctx, getState());
enterRule(_localctx, 174, RULE_conditionalAndExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1154); inclusiveOrExpression();
setState(1159);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AMPAMP) {
{
{
setState(1155); match(AMPAMP);
setState(1156); inclusiveOrExpression();
}
}
setState(1161);
_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 InclusiveOrExpressionContext extends ParserRuleContext {
public List exclusiveOrExpression() {
return getRuleContexts(ExclusiveOrExpressionContext.class);
}
public ExclusiveOrExpressionContext exclusiveOrExpression(int i) {
return getRuleContext(ExclusiveOrExpressionContext.class,i);
}
public TerminalNode BAR(int i) {
return getToken(Java7Parser.BAR, i);
}
public List BAR() { return getTokens(Java7Parser.BAR); }
public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inclusiveOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterInclusiveOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitInclusiveOrExpression(this);
}
}
public final InclusiveOrExpressionContext inclusiveOrExpression() throws RecognitionException {
InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(_ctx, getState());
enterRule(_localctx, 176, RULE_inclusiveOrExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1162); exclusiveOrExpression();
setState(1167);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BAR) {
{
{
setState(1163); match(BAR);
setState(1164); exclusiveOrExpression();
}
}
setState(1169);
_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 ExclusiveOrExpressionContext extends ParserRuleContext {
public List andExpression() {
return getRuleContexts(AndExpressionContext.class);
}
public TerminalNode CARET(int i) {
return getToken(Java7Parser.CARET, i);
}
public List CARET() { return getTokens(Java7Parser.CARET); }
public AndExpressionContext andExpression(int i) {
return getRuleContext(AndExpressionContext.class,i);
}
public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exclusiveOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterExclusiveOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitExclusiveOrExpression(this);
}
}
public final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException {
ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, getState());
enterRule(_localctx, 178, RULE_exclusiveOrExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1170); andExpression();
setState(1175);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CARET) {
{
{
setState(1171); match(CARET);
setState(1172); andExpression();
}
}
setState(1177);
_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 AndExpressionContext extends ParserRuleContext {
public EqualityExpressionContext equalityExpression(int i) {
return getRuleContext(EqualityExpressionContext.class,i);
}
public List equalityExpression() {
return getRuleContexts(EqualityExpressionContext.class);
}
public TerminalNode AMP(int i) {
return getToken(Java7Parser.AMP, i);
}
public List AMP() { return getTokens(Java7Parser.AMP); }
public AndExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAndExpression(this);
}
}
public final AndExpressionContext andExpression() throws RecognitionException {
AndExpressionContext _localctx = new AndExpressionContext(_ctx, getState());
enterRule(_localctx, 180, RULE_andExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1178); equalityExpression();
setState(1183);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AMP) {
{
{
setState(1179); match(AMP);
setState(1180); equalityExpression();
}
}
setState(1185);
_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 EqualityExpressionContext extends ParserRuleContext {
public NotEqualityExpressionContext notEqualityExpression(int i) {
return getRuleContext(NotEqualityExpressionContext.class,i);
}
public TerminalNode EQEQ(int i) {
return getToken(Java7Parser.EQEQ, i);
}
public List EQEQ() { return getTokens(Java7Parser.EQEQ); }
public List notEqualityExpression() {
return getRuleContexts(NotEqualityExpressionContext.class);
}
public EqualityExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalityExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterEqualityExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitEqualityExpression(this);
}
}
public final EqualityExpressionContext equalityExpression() throws RecognitionException {
EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, getState());
enterRule(_localctx, 182, RULE_equalityExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1186); notEqualityExpression();
setState(1191);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==EQEQ) {
{
{
setState(1187); match(EQEQ);
setState(1188); notEqualityExpression();
}
}
setState(1193);
_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 NotEqualityExpressionContext extends ParserRuleContext {
public List BANGEQ() { return getTokens(Java7Parser.BANGEQ); }
public InstanceOfExpressionContext instanceOfExpression(int i) {
return getRuleContext(InstanceOfExpressionContext.class,i);
}
public List instanceOfExpression() {
return getRuleContexts(InstanceOfExpressionContext.class);
}
public TerminalNode BANGEQ(int i) {
return getToken(Java7Parser.BANGEQ, i);
}
public NotEqualityExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notEqualityExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterNotEqualityExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitNotEqualityExpression(this);
}
}
public final NotEqualityExpressionContext notEqualityExpression() throws RecognitionException {
NotEqualityExpressionContext _localctx = new NotEqualityExpressionContext(_ctx, getState());
enterRule(_localctx, 184, RULE_notEqualityExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1194); instanceOfExpression();
setState(1199);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BANGEQ) {
{
{
setState(1195); match(BANGEQ);
setState(1196); instanceOfExpression();
}
}
setState(1201);
_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 InstanceOfExpressionContext extends ParserRuleContext {
public TerminalNode INSTANCEOF() { return getToken(Java7Parser.INSTANCEOF, 0); }
public RelationalExpressionContext relationalExpression() {
return getRuleContext(RelationalExpressionContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public InstanceOfExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_instanceOfExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterInstanceOfExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitInstanceOfExpression(this);
}
}
public final InstanceOfExpressionContext instanceOfExpression() throws RecognitionException {
InstanceOfExpressionContext _localctx = new InstanceOfExpressionContext(_ctx, getState());
enterRule(_localctx, 186, RULE_instanceOfExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1202); relationalExpression();
setState(1205);
_la = _input.LA(1);
if (_la==INSTANCEOF) {
{
setState(1203); match(INSTANCEOF);
setState(1204); type();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelationalExpressionContext extends ParserRuleContext {
public List relationalOp() {
return getRuleContexts(RelationalOpContext.class);
}
public RelationalOpContext relationalOp(int i) {
return getRuleContext(RelationalOpContext.class,i);
}
public ShiftExpressionContext shiftExpression(int i) {
return getRuleContext(ShiftExpressionContext.class,i);
}
public List shiftExpression() {
return getRuleContexts(ShiftExpressionContext.class);
}
public RelationalExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterRelationalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitRelationalExpression(this);
}
}
public final RelationalExpressionContext relationalExpression() throws RecognitionException {
RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, getState());
enterRule(_localctx, 188, RULE_relationalExpression);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1207); shiftExpression();
setState(1213);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,128,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(1208); relationalOp();
setState(1209); shiftExpression();
}
}
}
setState(1215);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,128,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelationalOpContext extends ParserRuleContext {
public int operatorType;
public TerminalNode GT() { return getToken(Java7Parser.GT, 0); }
public TerminalNode LT() { return getToken(Java7Parser.LT, 0); }
public TerminalNode EQ() { return getToken(Java7Parser.EQ, 0); }
public RelationalOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationalOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterRelationalOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitRelationalOp(this);
}
}
public final RelationalOpContext relationalOp() throws RecognitionException {
RelationalOpContext _localctx = new RelationalOpContext(_ctx, getState());
enterRule(_localctx, 190, RULE_relationalOp);
try {
setState(1226);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1216); match(LT);
setState(1217); match(EQ);
((RelationalOpContext)_localctx).operatorType = 1;
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1219); match(GT);
setState(1220); match(EQ);
((RelationalOpContext)_localctx).operatorType = 2;
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1222); match(LT);
((RelationalOpContext)_localctx).operatorType = 3;
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1224); match(GT);
((RelationalOpContext)_localctx).operatorType = 4;
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ShiftExpressionContext extends ParserRuleContext {
public List shiftOp() {
return getRuleContexts(ShiftOpContext.class);
}
public ShiftOpContext shiftOp(int i) {
return getRuleContext(ShiftOpContext.class,i);
}
public List additiveExpression() {
return getRuleContexts(AdditiveExpressionContext.class);
}
public AdditiveExpressionContext additiveExpression(int i) {
return getRuleContext(AdditiveExpressionContext.class,i);
}
public ShiftExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shiftExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterShiftExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitShiftExpression(this);
}
}
public final ShiftExpressionContext shiftExpression() throws RecognitionException {
ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, getState());
enterRule(_localctx, 192, RULE_shiftExpression);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1228); additiveExpression();
setState(1234);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(1229); shiftOp();
setState(1230); additiveExpression();
}
}
}
setState(1236);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ShiftOpContext extends ParserRuleContext {
public int operatorType;
public List GT() { return getTokens(Java7Parser.GT); }
public List LT() { return getTokens(Java7Parser.LT); }
public TerminalNode LT(int i) {
return getToken(Java7Parser.LT, i);
}
public TerminalNode GT(int i) {
return getToken(Java7Parser.GT, i);
}
public ShiftOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shiftOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterShiftOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitShiftOp(this);
}
}
public final ShiftOpContext shiftOp() throws RecognitionException {
ShiftOpContext _localctx = new ShiftOpContext(_ctx, getState());
enterRule(_localctx, 194, RULE_shiftOp);
try {
setState(1247);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1237); match(LT);
setState(1238); match(LT);
((ShiftOpContext)_localctx).operatorType = 1;
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1240); match(GT);
setState(1241); match(GT);
setState(1242); match(GT);
((ShiftOpContext)_localctx).operatorType = 2;
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1244); match(GT);
setState(1245); match(GT);
((ShiftOpContext)_localctx).operatorType = 3;
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AdditiveExpressionContext extends ParserRuleContext {
public AdditiveOpContext additiveOp(int i) {
return getRuleContext(AdditiveOpContext.class,i);
}
public MultiplicativeExpressionContext multiplicativeExpression(int i) {
return getRuleContext(MultiplicativeExpressionContext.class,i);
}
public List additiveOp() {
return getRuleContexts(AdditiveOpContext.class);
}
public List multiplicativeExpression() {
return getRuleContexts(MultiplicativeExpressionContext.class);
}
public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterAdditiveExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAdditiveExpression(this);
}
}
public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState());
enterRule(_localctx, 196, RULE_additiveExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1249); multiplicativeExpression();
setState(1255);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PLUS || _la==SUB) {
{
{
setState(1250); additiveOp();
setState(1251); multiplicativeExpression();
}
}
setState(1257);
_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 AdditiveOpContext extends ParserRuleContext {
public int operatorType;
public TerminalNode SUB() { return getToken(Java7Parser.SUB, 0); }
public TerminalNode PLUS() { return getToken(Java7Parser.PLUS, 0); }
public AdditiveOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterAdditiveOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAdditiveOp(this);
}
}
public final AdditiveOpContext additiveOp() throws RecognitionException {
AdditiveOpContext _localctx = new AdditiveOpContext(_ctx, getState());
enterRule(_localctx, 198, RULE_additiveOp);
try {
setState(1262);
switch (_input.LA(1)) {
case PLUS:
enterOuterAlt(_localctx, 1);
{
setState(1258); match(PLUS);
((AdditiveOpContext)_localctx).operatorType = 1;
}
break;
case SUB:
enterOuterAlt(_localctx, 2);
{
setState(1260); match(SUB);
((AdditiveOpContext)_localctx).operatorType = 2;
}
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 MultiplicativeExpressionContext extends ParserRuleContext {
public List multiplicativeOp() {
return getRuleContexts(MultiplicativeOpContext.class);
}
public List unaryExpression() {
return getRuleContexts(UnaryExpressionContext.class);
}
public MultiplicativeOpContext multiplicativeOp(int i) {
return getRuleContext(MultiplicativeOpContext.class,i);
}
public UnaryExpressionContext unaryExpression(int i) {
return getRuleContext(UnaryExpressionContext.class,i);
}
public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicativeExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterMultiplicativeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitMultiplicativeExpression(this);
}
}
public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException {
MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, getState());
enterRule(_localctx, 200, RULE_multiplicativeExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1264); unaryExpression();
setState(1270);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==STAR || _la==SLASH || _la==PERCENT) {
{
{
setState(1265); multiplicativeOp();
setState(1266); unaryExpression();
}
}
setState(1272);
_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 MultiplicativeOpContext extends ParserRuleContext {
public int operatorType;
public TerminalNode SLASH() { return getToken(Java7Parser.SLASH, 0); }
public TerminalNode STAR() { return getToken(Java7Parser.STAR, 0); }
public TerminalNode PERCENT() { return getToken(Java7Parser.PERCENT, 0); }
public MultiplicativeOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicativeOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterMultiplicativeOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitMultiplicativeOp(this);
}
}
public final MultiplicativeOpContext multiplicativeOp() throws RecognitionException {
MultiplicativeOpContext _localctx = new MultiplicativeOpContext(_ctx, getState());
enterRule(_localctx, 202, RULE_multiplicativeOp);
try {
setState(1279);
switch (_input.LA(1)) {
case STAR:
enterOuterAlt(_localctx, 1);
{
setState(1273); match(STAR);
((MultiplicativeOpContext)_localctx).operatorType = 1;
}
break;
case SLASH:
enterOuterAlt(_localctx, 2);
{
setState(1275); match(SLASH);
((MultiplicativeOpContext)_localctx).operatorType = 2;
}
break;
case PERCENT:
enterOuterAlt(_localctx, 3);
{
setState(1277); match(PERCENT);
((MultiplicativeOpContext)_localctx).operatorType = 3;
}
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 UnaryExpressionContext extends ParserRuleContext {
public TerminalNode SUB() { return getToken(Java7Parser.SUB, 0); }
public TerminalNode PLUS() { return getToken(Java7Parser.PLUS, 0); }
public TerminalNode BANG() { return getToken(Java7Parser.BANG, 0); }
public UnaryExpressionContext unaryExpression() {
return getRuleContext(UnaryExpressionContext.class,0);
}
public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() {
return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0);
}
public TerminalNode SUBSUB() { return getToken(Java7Parser.SUBSUB, 0); }
public TerminalNode PLUSPLUS() { return getToken(Java7Parser.PLUSPLUS, 0); }
public TerminalNode TILDE() { return getToken(Java7Parser.TILDE, 0); }
public UnaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterUnaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitUnaryExpression(this);
}
}
public final UnaryExpressionContext unaryExpression() throws RecognitionException {
UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState());
enterRule(_localctx, 204, RULE_unaryExpression);
try {
setState(1294);
switch (_input.LA(1)) {
case PLUS:
enterOuterAlt(_localctx, 1);
{
setState(1281); match(PLUS);
setState(1282); unaryExpression();
}
break;
case SUB:
enterOuterAlt(_localctx, 2);
{
setState(1283); match(SUB);
setState(1284); unaryExpression();
}
break;
case PLUSPLUS:
enterOuterAlt(_localctx, 3);
{
setState(1285); match(PLUSPLUS);
setState(1286); unaryExpression();
}
break;
case SUBSUB:
enterOuterAlt(_localctx, 4);
{
setState(1287); match(SUBSUB);
setState(1288); unaryExpression();
}
break;
case TILDE:
enterOuterAlt(_localctx, 5);
{
setState(1289); match(TILDE);
setState(1290); unaryExpression();
}
break;
case BANG:
enterOuterAlt(_localctx, 6);
{
setState(1291); match(BANG);
setState(1292); unaryExpression();
}
break;
case LPAREN:
case VOID:
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
case LONG:
case FLOAT:
case DOUBLE:
case THIS:
case SUPER:
case NULL:
case TRUE:
case FALSE:
case NEW:
case IntegerLiteral:
case FloatingPointLiteral:
case CharacterLiteral:
case StringLiteral:
case Identifier:
enterOuterAlt(_localctx, 7);
{
setState(1293); unaryExpressionNotPlusMinus();
}
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 UnaryExpressionNotPlusMinusContext extends ParserRuleContext {
public List selector() {
return getRuleContexts(SelectorContext.class);
}
public SelectorContext selector(int i) {
return getRuleContext(SelectorContext.class,i);
}
public CastExpressionContext castExpression() {
return getRuleContext(CastExpressionContext.class,0);
}
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public TerminalNode SUBSUB() { return getToken(Java7Parser.SUBSUB, 0); }
public TerminalNode PLUSPLUS() { return getToken(Java7Parser.PLUSPLUS, 0); }
public UnaryExpressionNotPlusMinusContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpressionNotPlusMinus; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterUnaryExpressionNotPlusMinus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitUnaryExpressionNotPlusMinus(this);
}
}
public final UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() throws RecognitionException {
UnaryExpressionNotPlusMinusContext _localctx = new UnaryExpressionNotPlusMinusContext(_ctx, getState());
enterRule(_localctx, 206, RULE_unaryExpressionNotPlusMinus);
int _la;
try {
setState(1307);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1296); castExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1297); primary();
setState(1301);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT || _la==LBRACKET) {
{
{
setState(1298); selector();
}
}
setState(1303);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1305);
_la = _input.LA(1);
if (_la==PLUSPLUS || _la==SUBSUB) {
{
setState(1304);
_la = _input.LA(1);
if ( !(_la==PLUSPLUS || _la==SUBSUB) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CastExpressionContext extends ParserRuleContext {
public TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public UnaryExpressionContext unaryExpression() {
return getRuleContext(UnaryExpressionContext.class,0);
}
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() {
return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode LPAREN() { return getToken(Java7Parser.LPAREN, 0); }
public CastExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_castExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterCastExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitCastExpression(this);
}
}
public final CastExpressionContext castExpression() throws RecognitionException {
CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState());
enterRule(_localctx, 208, RULE_castExpression);
try {
setState(1319);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1309); match(LPAREN);
setState(1310); primitiveType();
setState(1311); match(RPAREN);
setState(1312); unaryExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1314); match(LPAREN);
setState(1315); type();
setState(1316); match(RPAREN);
setState(1317); unaryExpressionNotPlusMinus();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryContext extends ParserRuleContext {
public int operationType;
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public ParExpressionContext parExpression() {
return getRuleContext(ParExpressionContext.class,0);
}
public TerminalNode CLASS() { return getToken(Java7Parser.CLASS, 0); }
public TerminalNode DOT(int i) {
return getToken(Java7Parser.DOT, i);
}
public ThisSuffixContext thisSuffix() {
return getRuleContext(ThisSuffixContext.class,0);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public TerminalNode THIS() { return getToken(Java7Parser.THIS, 0); }
public CreatorContext creator() {
return getRuleContext(CreatorContext.class,0);
}
public SuperSuffixContext superSuffix() {
return getRuleContext(SuperSuffixContext.class,0);
}
public TerminalNode VOID() { return getToken(Java7Parser.VOID, 0); }
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public TerminalNode Identifier(int i) {
return getToken(Java7Parser.Identifier, i);
}
public TerminalNode SUPER() { return getToken(Java7Parser.SUPER, 0); }
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public List DOT() { return getTokens(Java7Parser.DOT); }
public IdentifierSuffixContext identifierSuffix() {
return getRuleContext(IdentifierSuffixContext.class,0);
}
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public List Identifier() { return getTokens(Java7Parser.Identifier); }
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public PrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitPrimary(this);
}
}
public final PrimaryContext primary() throws RecognitionException {
PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
enterRule(_localctx, 210, RULE_primary);
int _la;
try {
int _alt;
setState(1374);
switch (_input.LA(1)) {
case LPAREN:
enterOuterAlt(_localctx, 1);
{
setState(1321); parExpression();
((PrimaryContext)_localctx).operationType = 1;
}
break;
case THIS:
enterOuterAlt(_localctx, 2);
{
setState(1324); match(THIS);
setState(1329);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,141,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(1325); match(DOT);
setState(1326); match(Identifier);
}
}
}
setState(1331);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,141,_ctx);
}
setState(1333);
switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
case 1:
{
setState(1332); thisSuffix();
}
break;
}
((PrimaryContext)_localctx).operationType = 2;
}
break;
case Identifier:
enterOuterAlt(_localctx, 3);
{
setState(1336); match(Identifier);
setState(1341);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(1337); match(DOT);
setState(1338); match(Identifier);
}
}
}
setState(1343);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
}
setState(1345);
switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
case 1:
{
setState(1344); identifierSuffix();
}
break;
}
((PrimaryContext)_localctx).operationType = 3;
}
break;
case SUPER:
enterOuterAlt(_localctx, 4);
{
setState(1348); match(SUPER);
setState(1349); superSuffix();
((PrimaryContext)_localctx).operationType = 4;
}
break;
case NULL:
case TRUE:
case FALSE:
case IntegerLiteral:
case FloatingPointLiteral:
case CharacterLiteral:
case StringLiteral:
enterOuterAlt(_localctx, 5);
{
setState(1352); literal();
((PrimaryContext)_localctx).operationType = 5;
}
break;
case NEW:
enterOuterAlt(_localctx, 6);
{
setState(1355); creator();
((PrimaryContext)_localctx).operationType = 6;
}
break;
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
case LONG:
case FLOAT:
case DOUBLE:
enterOuterAlt(_localctx, 7);
{
setState(1358); primitiveType();
setState(1363);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(1359); match(LBRACKET);
setState(1360); match(RBRACKET);
}
}
setState(1365);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1366); match(DOT);
setState(1367); match(CLASS);
((PrimaryContext)_localctx).operationType = 7;
}
break;
case VOID:
enterOuterAlt(_localctx, 8);
{
setState(1370); match(VOID);
setState(1371); match(DOT);
setState(1372); match(CLASS);
((PrimaryContext)_localctx).operationType = 8;
}
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 SuperSuffixContext extends ParserRuleContext {
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public TerminalNode DOT() { return getToken(Java7Parser.DOT, 0); }
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public SuperSuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_superSuffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterSuperSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitSuperSuffix(this);
}
}
public final SuperSuffixContext superSuffix() throws RecognitionException {
SuperSuffixContext _localctx = new SuperSuffixContext(_ctx, getState());
enterRule(_localctx, 212, RULE_superSuffix);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1376); match(DOT);
setState(1378);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1377); typeArguments();
}
}
setState(1380); match(Identifier);
setState(1382);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1381); arguments();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ThisSuffixContext extends ParserRuleContext {
public int operationType;
public InnerCreatorContext innerCreator() {
return getRuleContext(InnerCreatorContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public TerminalNode DOT() { return getToken(Java7Parser.DOT, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public ThisSuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_thisSuffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterThisSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitThisSuffix(this);
}
}
public final ThisSuffixContext thisSuffix() throws RecognitionException {
ThisSuffixContext _localctx = new ThisSuffixContext(_ctx, getState());
enterRule(_localctx, 214, RULE_thisSuffix);
try {
int _alt;
setState(1406);
switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1388);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,149,_ctx);
do {
switch (_alt) {
case 1:
{
{
setState(1384); match(LBRACKET);
setState(1385); expression();
setState(1386); match(RBRACKET);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1390);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,149,_ctx);
} while ( _alt!=2 && _alt!=-1 );
((ThisSuffixContext)_localctx).operationType = 1;
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1394); arguments();
((ThisSuffixContext)_localctx).operationType = 2;
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1397); match(DOT);
setState(1398); nonWildcardTypeArguments();
setState(1399); match(Identifier);
setState(1400); arguments();
((ThisSuffixContext)_localctx).operationType = 3;
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1403); innerCreator();
((ThisSuffixContext)_localctx).operationType = 4;
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierSuffixContext extends ParserRuleContext {
public int operationType;
public InnerCreatorContext innerCreator() {
return getRuleContext(InnerCreatorContext.class,0);
}
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public TerminalNode CLASS() { return getToken(Java7Parser.CLASS, 0); }
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public TerminalNode THIS() { return getToken(Java7Parser.THIS, 0); }
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public TerminalNode DOT() { return getToken(Java7Parser.DOT, 0); }
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public IdentifierSuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierSuffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterIdentifierSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitIdentifierSuffix(this);
}
}
public final IdentifierSuffixContext identifierSuffix() throws RecognitionException {
IdentifierSuffixContext _localctx = new IdentifierSuffixContext(_ctx, getState());
enterRule(_localctx, 216, RULE_identifierSuffix);
int _la;
try {
int _alt;
setState(1445);
switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1410);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1408); match(LBRACKET);
setState(1409); match(RBRACKET);
}
}
setState(1412);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==LBRACKET );
setState(1414); match(DOT);
setState(1415); match(CLASS);
((IdentifierSuffixContext)_localctx).operationType = 1;
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1421);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,152,_ctx);
do {
switch (_alt) {
case 1:
{
{
setState(1417); match(LBRACKET);
setState(1418); expression();
setState(1419); match(RBRACKET);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1423);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,152,_ctx);
} while ( _alt!=2 && _alt!=-1 );
((IdentifierSuffixContext)_localctx).operationType = 2;
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1427); arguments();
((IdentifierSuffixContext)_localctx).operationType = 3;
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1430); match(DOT);
setState(1431); match(CLASS);
((IdentifierSuffixContext)_localctx).operationType = 4;
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1433); match(DOT);
setState(1434); nonWildcardTypeArguments();
setState(1435); match(Identifier);
setState(1436); arguments();
((IdentifierSuffixContext)_localctx).operationType = 5;
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1439); match(DOT);
setState(1440); match(THIS);
((IdentifierSuffixContext)_localctx).operationType = 6;
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1442); innerCreator();
((IdentifierSuffixContext)_localctx).operationType = 7;
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectorContext extends ParserRuleContext {
public int operationType;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode LBRACKET() { return getToken(Java7Parser.LBRACKET, 0); }
public InnerCreatorContext innerCreator() {
return getRuleContext(InnerCreatorContext.class,0);
}
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public SuperSuffixContext superSuffix() {
return getRuleContext(SuperSuffixContext.class,0);
}
public TerminalNode SUPER() { return getToken(Java7Parser.SUPER, 0); }
public TerminalNode RBRACKET() { return getToken(Java7Parser.RBRACKET, 0); }
public TerminalNode DOT() { return getToken(Java7Parser.DOT, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TerminalNode THIS() { return getToken(Java7Parser.THIS, 0); }
public SelectorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selector; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterSelector(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitSelector(this);
}
}
public final SelectorContext selector() throws RecognitionException {
SelectorContext _localctx = new SelectorContext(_ctx, getState());
enterRule(_localctx, 218, RULE_selector);
int _la;
try {
setState(1469);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1447); match(DOT);
setState(1448); match(Identifier);
setState(1450);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1449); arguments();
}
}
((SelectorContext)_localctx).operationType = 1;
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1453); match(DOT);
setState(1454); match(THIS);
((SelectorContext)_localctx).operationType = 2;
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1456); match(DOT);
setState(1457); match(SUPER);
setState(1458); superSuffix();
((SelectorContext)_localctx).operationType = 3;
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1461); innerCreator();
((SelectorContext)_localctx).operationType = 4;
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1464); match(LBRACKET);
setState(1465); expression();
setState(1466); match(RBRACKET);
((SelectorContext)_localctx).operationType = 5;
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreatorContext extends ParserRuleContext {
public TerminalNode NEW() { return getToken(Java7Parser.NEW, 0); }
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public ArrayCreatorContext arrayCreator() {
return getRuleContext(ArrayCreatorContext.class,0);
}
public ClassCreatorRestContext classCreatorRest() {
return getRuleContext(ClassCreatorRestContext.class,0);
}
public CreatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_creator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterCreator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitCreator(this);
}
}
public final CreatorContext creator() throws RecognitionException {
CreatorContext _localctx = new CreatorContext(_ctx, getState());
enterRule(_localctx, 220, RULE_creator);
try {
setState(1481);
switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1471); match(NEW);
setState(1472); nonWildcardTypeArguments();
setState(1473); classOrInterfaceType();
setState(1474); classCreatorRest();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1476); match(NEW);
setState(1477); classOrInterfaceType();
setState(1478); classCreatorRest();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1480); arrayCreator();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayCreatorContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public CreatedNameContext createdName() {
return getRuleContext(CreatedNameContext.class,0);
}
public TerminalNode NEW() { return getToken(Java7Parser.NEW, 0); }
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ArrayInitializerContext arrayInitializer() {
return getRuleContext(ArrayInitializerContext.class,0);
}
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public ArrayCreatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayCreator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterArrayCreator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitArrayCreator(this);
}
}
public final ArrayCreatorContext arrayCreator() throws RecognitionException {
ArrayCreatorContext _localctx = new ArrayCreatorContext(_ctx, getState());
enterRule(_localctx, 222, RULE_arrayCreator);
int _la;
try {
int _alt;
setState(1517);
switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1483); match(NEW);
setState(1484); createdName();
setState(1485); match(LBRACKET);
setState(1486); match(RBRACKET);
setState(1491);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(1487); match(LBRACKET);
setState(1488); match(RBRACKET);
}
}
setState(1493);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1494); arrayInitializer();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1496); match(NEW);
setState(1497); createdName();
setState(1498); match(LBRACKET);
setState(1499); expression();
setState(1500); match(RBRACKET);
setState(1507);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,158,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(1501); match(LBRACKET);
setState(1502); expression();
setState(1503); match(RBRACKET);
}
}
}
setState(1509);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,158,_ctx);
}
setState(1514);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,159,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(1510); match(LBRACKET);
setState(1511); match(RBRACKET);
}
}
}
setState(1516);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,159,_ctx);
}
}
break;
}
}
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 ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ArrayInitializerContext arrayInitializer() {
return getRuleContext(ArrayInitializerContext.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 Java7ParserListener ) ((Java7ParserListener)listener).enterVariableInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitVariableInitializer(this);
}
}
public final VariableInitializerContext variableInitializer() throws RecognitionException {
VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
enterRule(_localctx, 224, RULE_variableInitializer);
try {
setState(1521);
switch (_input.LA(1)) {
case LBRACE:
enterOuterAlt(_localctx, 1);
{
setState(1519); arrayInitializer();
}
break;
case LPAREN:
case VOID:
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
case LONG:
case FLOAT:
case DOUBLE:
case THIS:
case SUPER:
case NULL:
case TRUE:
case FALSE:
case PLUSPLUS:
case SUBSUB:
case TILDE:
case BANG:
case NEW:
case PLUS:
case SUB:
case IntegerLiteral:
case FloatingPointLiteral:
case CharacterLiteral:
case StringLiteral:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(1520); expression();
}
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 ArrayInitializerContext extends ParserRuleContext {
public TerminalNode COMMA(int i) {
return getToken(Java7Parser.COMMA, i);
}
public TerminalNode RBRACE() { return getToken(Java7Parser.RBRACE, 0); }
public VariableInitializerContext variableInitializer(int i) {
return getRuleContext(VariableInitializerContext.class,i);
}
public List COMMA() { return getTokens(Java7Parser.COMMA); }
public List variableInitializer() {
return getRuleContexts(VariableInitializerContext.class);
}
public TerminalNode LBRACE() { return getToken(Java7Parser.LBRACE, 0); }
public ArrayInitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayInitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterArrayInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitArrayInitializer(this);
}
}
public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
enterRule(_localctx, 226, RULE_arrayInitializer);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1523); match(LBRACE);
setState(1532);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LBRACE) | (1L << LPAREN) | (1L << VOID) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << THIS) | (1L << SUPER) | (1L << NULL) | (1L << TRUE) | (1L << FALSE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PLUSPLUS - 65)) | (1L << (SUBSUB - 65)) | (1L << (TILDE - 65)) | (1L << (BANG - 65)) | (1L << (NEW - 65)) | (1L << (PLUS - 65)) | (1L << (SUB - 65)) | (1L << (IntegerLiteral - 65)) | (1L << (FloatingPointLiteral - 65)) | (1L << (CharacterLiteral - 65)) | (1L << (StringLiteral - 65)) | (1L << (Identifier - 65)))) != 0)) {
{
setState(1524); variableInitializer();
setState(1529);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,162,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(1525); match(COMMA);
setState(1526); variableInitializer();
}
}
}
setState(1531);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,162,_ctx);
}
}
}
setState(1535);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1534); match(COMMA);
}
}
setState(1537); match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreatedNameContext extends ParserRuleContext {
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public CreatedNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createdName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterCreatedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitCreatedName(this);
}
}
public final CreatedNameContext createdName() throws RecognitionException {
CreatedNameContext _localctx = new CreatedNameContext(_ctx, getState());
enterRule(_localctx, 228, RULE_createdName);
try {
setState(1541);
switch (_input.LA(1)) {
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1539); classOrInterfaceType();
}
break;
case BOOLEAN:
case CHAR:
case BYTE:
case SHORT:
case INT:
case LONG:
case FLOAT:
case DOUBLE:
enterOuterAlt(_localctx, 2);
{
setState(1540); primitiveType();
}
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 InnerCreatorContext extends ParserRuleContext {
public TerminalNode NEW() { return getToken(Java7Parser.NEW, 0); }
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public TerminalNode DOT() { return getToken(Java7Parser.DOT, 0); }
public IdentifierTypeArgumentContext identifierTypeArgument() {
return getRuleContext(IdentifierTypeArgumentContext.class,0);
}
public ClassCreatorRestContext classCreatorRest() {
return getRuleContext(ClassCreatorRestContext.class,0);
}
public InnerCreatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_innerCreator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterInnerCreator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitInnerCreator(this);
}
}
public final InnerCreatorContext innerCreator() throws RecognitionException {
InnerCreatorContext _localctx = new InnerCreatorContext(_ctx, getState());
enterRule(_localctx, 230, RULE_innerCreator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1543); match(DOT);
setState(1544); match(NEW);
setState(1546);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1545); nonWildcardTypeArguments();
}
}
setState(1548); identifierTypeArgument();
setState(1549); classCreatorRest();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassCreatorRestContext extends ParserRuleContext {
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public ClassCreatorRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classCreatorRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterClassCreatorRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitClassCreatorRest(this);
}
}
public final ClassCreatorRestContext classCreatorRest() throws RecognitionException {
ClassCreatorRestContext _localctx = new ClassCreatorRestContext(_ctx, getState());
enterRule(_localctx, 232, RULE_classCreatorRest);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1551); arguments();
setState(1553);
_la = _input.LA(1);
if (_la==LBRACE) {
{
setState(1552); classBody();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NonWildcardTypeArgumentsContext extends ParserRuleContext {
public TerminalNode GT() { return getToken(Java7Parser.GT, 0); }
public TerminalNode LT() { return getToken(Java7Parser.LT, 0); }
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public NonWildcardTypeArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nonWildcardTypeArguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterNonWildcardTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitNonWildcardTypeArguments(this);
}
}
public final NonWildcardTypeArgumentsContext nonWildcardTypeArguments() throws RecognitionException {
NonWildcardTypeArgumentsContext _localctx = new NonWildcardTypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 234, RULE_nonWildcardTypeArguments);
try {
enterOuterAlt(_localctx, 1);
{
setState(1555); match(LT);
setState(1556); typeList();
setState(1557); match(GT);
}
}
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 TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public TerminalNode LPAREN() { return getToken(Java7Parser.LPAREN, 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 Java7ParserListener ) ((Java7ParserListener)listener).enterArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitArguments(this);
}
}
public final ArgumentsContext arguments() throws RecognitionException {
ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState());
enterRule(_localctx, 236, RULE_arguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1559); match(LPAREN);
setState(1561);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << VOID) | (1L << BOOLEAN) | (1L << CHAR) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << THIS) | (1L << SUPER) | (1L << NULL) | (1L << TRUE) | (1L << FALSE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PLUSPLUS - 65)) | (1L << (SUBSUB - 65)) | (1L << (TILDE - 65)) | (1L << (BANG - 65)) | (1L << (NEW - 65)) | (1L << (PLUS - 65)) | (1L << (SUB - 65)) | (1L << (IntegerLiteral - 65)) | (1L << (FloatingPointLiteral - 65)) | (1L << (CharacterLiteral - 65)) | (1L << (StringLiteral - 65)) | (1L << (Identifier - 65)))) != 0)) {
{
setState(1560); expressionList();
}
}
setState(1563); match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public TerminalNode StringLiteral() { return getToken(Java7Parser.StringLiteral, 0); }
public TerminalNode IntegerLiteral() { return getToken(Java7Parser.IntegerLiteral, 0); }
public TerminalNode FALSE() { return getToken(Java7Parser.FALSE, 0); }
public TerminalNode TRUE() { return getToken(Java7Parser.TRUE, 0); }
public TerminalNode CharacterLiteral() { return getToken(Java7Parser.CharacterLiteral, 0); }
public TerminalNode NULL() { return getToken(Java7Parser.NULL, 0); }
public TerminalNode FloatingPointLiteral() { return getToken(Java7Parser.FloatingPointLiteral, 0); }
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitLiteral(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 238, RULE_literal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1565);
_la = _input.LA(1);
if ( !(((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (NULL - 44)) | (1L << (TRUE - 44)) | (1L << (FALSE - 44)) | (1L << (IntegerLiteral - 44)) | (1L << (FloatingPointLiteral - 44)) | (1L << (CharacterLiteral - 44)) | (1L << (StringLiteral - 44)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassHeaderContext extends ParserRuleContext {
public TerminalNode CLASS() { return getToken(Java7Parser.CLASS, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public ClassHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterClassHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitClassHeader(this);
}
}
public final ClassHeaderContext classHeader() throws RecognitionException {
ClassHeaderContext _localctx = new ClassHeaderContext(_ctx, getState());
enterRule(_localctx, 240, RULE_classHeader);
try {
enterOuterAlt(_localctx, 1);
{
setState(1567); modifiers();
setState(1568); match(CLASS);
setState(1569); match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumHeaderContext extends ParserRuleContext {
public TerminalNode ENUM() { return getToken(Java7Parser.ENUM, 0); }
public TerminalNode Identifier(int i) {
return getToken(Java7Parser.Identifier, i);
}
public List Identifier() { return getTokens(Java7Parser.Identifier); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public EnumHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterEnumHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitEnumHeader(this);
}
}
public final EnumHeaderContext enumHeader() throws RecognitionException {
EnumHeaderContext _localctx = new EnumHeaderContext(_ctx, getState());
enterRule(_localctx, 242, RULE_enumHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1571); modifiers();
setState(1572);
_la = _input.LA(1);
if ( !(_la==ENUM || _la==Identifier) ) {
_errHandler.recoverInline(this);
}
consume();
setState(1573); match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceHeaderContext extends ParserRuleContext {
public TerminalNode INTERFACE() { return getToken(Java7Parser.INTERFACE, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public InterfaceHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterInterfaceHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitInterfaceHeader(this);
}
}
public final InterfaceHeaderContext interfaceHeader() throws RecognitionException {
InterfaceHeaderContext _localctx = new InterfaceHeaderContext(_ctx, getState());
enterRule(_localctx, 244, RULE_interfaceHeader);
try {
enterOuterAlt(_localctx, 1);
{
setState(1575); modifiers();
setState(1576); match(INTERFACE);
setState(1577); match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationHeaderContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(Java7Parser.AT, 0); }
public TerminalNode INTERFACE() { return getToken(Java7Parser.INTERFACE, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public AnnotationHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterAnnotationHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitAnnotationHeader(this);
}
}
public final AnnotationHeaderContext annotationHeader() throws RecognitionException {
AnnotationHeaderContext _localctx = new AnnotationHeaderContext(_ctx, getState());
enterRule(_localctx, 246, RULE_annotationHeader);
try {
enterOuterAlt(_localctx, 1);
{
setState(1579); modifiers();
setState(1580); match(AT);
setState(1581); match(INTERFACE);
setState(1582); match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeHeaderContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(Java7Parser.AT, 0); }
public TerminalNode CLASS() { return getToken(Java7Parser.CLASS, 0); }
public TerminalNode INTERFACE() { return getToken(Java7Parser.INTERFACE, 0); }
public TerminalNode ENUM() { return getToken(Java7Parser.ENUM, 0); }
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public TypeHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterTypeHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitTypeHeader(this);
}
}
public final TypeHeaderContext typeHeader() throws RecognitionException {
TypeHeaderContext _localctx = new TypeHeaderContext(_ctx, getState());
enterRule(_localctx, 248, RULE_typeHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1584); modifiers();
setState(1591);
switch (_input.LA(1)) {
case CLASS:
{
setState(1585); match(CLASS);
}
break;
case ENUM:
{
setState(1586); match(ENUM);
}
break;
case INTERFACE:
case AT:
{
{
setState(1588);
_la = _input.LA(1);
if (_la==AT) {
{
setState(1587); match(AT);
}
}
setState(1590); match(INTERFACE);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1593); match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodHeaderContext extends ParserRuleContext {
public TerminalNode RPAREN() { return getToken(Java7Parser.RPAREN, 0); }
public TerminalNode VOID() { return getToken(Java7Parser.VOID, 0); }
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public MethodHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterMethodHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitMethodHeader(this);
}
}
public final MethodHeaderContext methodHeader() throws RecognitionException {
MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState());
enterRule(_localctx, 250, RULE_methodHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1595); modifiers();
setState(1597);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1596); typeParameters();
}
}
setState(1601);
switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) {
case 1:
{
setState(1599); type();
}
break;
case 2:
{
setState(1600); match(VOID);
}
break;
}
setState(1603); match(Identifier);
setState(1604); match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldHeaderContext extends ParserRuleContext {
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public TerminalNode EQ() { return getToken(Java7Parser.EQ, 0); }
public TerminalNode COMMA() { return getToken(Java7Parser.COMMA, 0); }
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ModifiersContext modifiers() {
return getRuleContext(ModifiersContext.class,0);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public FieldHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterFieldHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitFieldHeader(this);
}
}
public final FieldHeaderContext fieldHeader() throws RecognitionException {
FieldHeaderContext _localctx = new FieldHeaderContext(_ctx, getState());
enterRule(_localctx, 252, RULE_fieldHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1606); modifiers();
setState(1607); type();
setState(1608); match(Identifier);
setState(1613);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(1609); match(LBRACKET);
setState(1610); match(RBRACKET);
}
}
setState(1615);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1616);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEMI) | (1L << COMMA) | (1L << EQ))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocalVariableHeaderContext extends ParserRuleContext {
public List LBRACKET() { return getTokens(Java7Parser.LBRACKET); }
public VariableModifiersContext variableModifiers() {
return getRuleContext(VariableModifiersContext.class,0);
}
public List RBRACKET() { return getTokens(Java7Parser.RBRACKET); }
public TerminalNode EQ() { return getToken(Java7Parser.EQ, 0); }
public TerminalNode COMMA() { return getToken(Java7Parser.COMMA, 0); }
public TerminalNode SEMI() { return getToken(Java7Parser.SEMI, 0); }
public TerminalNode RBRACKET(int i) {
return getToken(Java7Parser.RBRACKET, i);
}
public TerminalNode Identifier() { return getToken(Java7Parser.Identifier, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode LBRACKET(int i) {
return getToken(Java7Parser.LBRACKET, i);
}
public LocalVariableHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_localVariableHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).enterLocalVariableHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java7ParserListener ) ((Java7ParserListener)listener).exitLocalVariableHeader(this);
}
}
public final LocalVariableHeaderContext localVariableHeader() throws RecognitionException {
LocalVariableHeaderContext _localctx = new LocalVariableHeaderContext(_ctx, getState());
enterRule(_localctx, 254, RULE_localVariableHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1618); variableModifiers();
setState(1619); type();
setState(1620); match(Identifier);
setState(1625);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACKET) {
{
{
setState(1621); match(LBRACKET);
setState(1622); match(RBRACKET);
}
}
setState(1627);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1628);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SEMI) | (1L << COMMA) | (1L << EQ))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\2\3h\u0661\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\t"+
"F\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4"+
"R\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\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\3\2\5\2\u0104\n\2\3\2\7\2\u0107"+
"\n\2\f\2\16\2\u010a\13\2\3\2\7\2\u010d\n\2\f\2\16\2\u0110\13\2\3\3\5\3"+
"\u0113\n\3\3\3\3\3\3\3\3\3\3\4\3\4\5\4\u011b\n\4\3\4\3\4\3\4\3\4\3\4\3"+
"\4\5\4\u0123\n\4\3\4\3\4\3\4\6\4\u0128\n\4\r\4\16\4\u0129\3\4\3\4\5\4"+
"\u012e\n\4\3\4\5\4\u0131\n\4\3\5\3\5\3\5\7\5\u0136\n\5\f\5\16\5\u0139"+
"\13\5\3\6\3\6\5\6\u013d\n\6\3\7\3\7\5\7\u0141\n\7\3\b\7\b\u0144\n\b\f"+
"\b\16\b\u0147\13\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t"+
"\u0155\n\t\3\n\7\n\u0158\n\n\f\n\16\n\u015b\13\n\3\n\5\n\u015e\n\n\3\n"+
"\7\n\u0161\n\n\f\n\16\n\u0164\13\n\3\13\3\13\5\13\u0168\n\13\3\f\3\f\3"+
"\f\3\f\5\f\u016e\n\f\3\f\3\f\5\f\u0172\n\f\3\f\3\f\5\f\u0176\n\f\3\f\3"+
"\f\3\r\3\r\3\r\3\r\7\r\u017e\n\r\f\r\16\r\u0181\13\r\3\r\3\r\3\16\3\16"+
"\3\16\5\16\u0188\n\16\3\17\3\17\3\17\7\17\u018d\n\17\f\17\16\17\u0190"+
"\13\17\3\20\3\20\3\20\3\20\3\20\5\20\u0197\n\20\3\20\3\20\3\21\3\21\5"+
"\21\u019d\n\21\3\21\5\21\u01a0\n\21\3\21\5\21\u01a3\n\21\3\21\3\21\3\22"+
"\3\22\3\22\7\22\u01aa\n\22\f\22\16\22\u01ad\13\22\3\23\5\23\u01b0\n\23"+
"\3\23\3\23\5\23\u01b4\n\23\3\23\5\23\u01b7\n\23\3\24\3\24\7\24\u01bb\n"+
"\24\f\24\16\24\u01be\13\24\3\25\3\25\5\25\u01c2\n\25\3\26\3\26\3\26\3"+
"\26\5\26\u01c8\n\26\3\26\3\26\5\26\u01cc\n\26\3\26\3\26\3\27\3\27\3\27"+
"\7\27\u01d3\n\27\f\27\16\27\u01d6\13\27\3\30\3\30\7\30\u01da\n\30\f\30"+
"\16\30\u01dd\13\30\3\30\3\30\3\31\3\31\7\31\u01e3\n\31\f\31\16\31\u01e6"+
"\13\31\3\31\3\31\3\32\3\32\5\32\u01ec\n\32\3\32\3\32\5\32\u01f0\n\32\3"+
"\33\3\33\3\33\3\33\3\33\5\33\u01f7\n\33\3\34\3\34\5\34\u01fb\n\34\3\34"+
"\3\34\5\34\u01ff\n\34\3\34\3\34\3\34\3\34\7\34\u0205\n\34\f\34\16\34\u0208"+
"\13\34\3\34\3\34\5\34\u020c\n\34\3\34\3\34\5\34\u0210\n\34\3\35\3\35\5"+
"\35\u0214\n\35\3\35\3\35\3\35\3\35\5\35\u021a\n\35\3\35\3\35\3\36\3\36"+
"\5\36\u0220\n\36\3\36\7\36\u0223\n\36\f\36\16\36\u0226\13\36\3\36\3\36"+
"\3\37\3\37\3\37\3\37\3\37\7\37\u022f\n\37\f\37\16\37\u0232\13\37\3\37"+
"\3\37\3 \3 \3 \7 \u0239\n \f \16 \u023c\13 \3 \3 \5 \u0240\n \3!\3!\3"+
"!\3!\3!\5!\u0247\n!\3\"\3\"\5\"\u024b\n\"\3\"\3\"\5\"\u024f\n\"\3\"\3"+
"\"\3\"\3\"\7\"\u0255\n\"\f\"\16\"\u0258\13\"\3\"\3\"\5\"\u025c\n\"\3\""+
"\3\"\3#\3#\3#\3#\3#\7#\u0265\n#\f#\16#\u0268\13#\3#\3#\3$\3$\3$\7$\u026f"+
"\n$\f$\16$\u0272\13$\3$\3$\3$\7$\u0277\n$\f$\16$\u027a\13$\5$\u027c\n"+
"$\3%\3%\3%\7%\u0281\n%\f%\16%\u0284\13%\3&\3&\5&\u0288\n&\3\'\3\'\3(\3"+
"(\3(\3(\7(\u0290\n(\f(\16(\u0293\13(\3(\3(\3(\3(\5(\u0299\n(\3)\3)\3)"+
"\3)\5)\u029f\n)\5)\u02a1\n)\3*\3*\3*\7*\u02a6\n*\f*\16*\u02a9\13*\3+\3"+
"+\5+\u02ad\n+\3+\3+\3,\3,\3,\3,\3,\3,\7,\u02b7\n,\f,\16,\u02ba\13,\3,"+
"\3,\3,\3,\3,\6,\u02c1\n,\r,\16,\u02c2\3,\3,\3,\5,\u02c8\n,\3-\3-\3-\3"+
"-\3-\7-\u02cf\n-\f-\16-\u02d2\13-\3.\3.\3.\3.\3.\3/\5/\u02da\n/\3/\3/"+
"\3/\3/\3/\3/\3/\5/\u02e3\n/\3/\3/\3/\3/\5/\u02e9\n/\3\60\3\60\3\60\7\60"+
"\u02ee\n\60\f\60\16\60\u02f1\13\60\3\61\6\61\u02f4\n\61\r\61\16\61\u02f5"+
"\3\62\3\62\3\62\5\62\u02fb\n\62\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64"+
"\3\64\3\65\3\65\3\65\3\65\5\65\u030a\n\65\3\65\3\65\3\66\3\66\3\66\7\66"+
"\u0311\n\66\f\66\16\66\u0314\13\66\3\67\3\67\3\67\3\67\38\38\38\58\u031d"+
"\n8\39\39\39\39\79\u0323\n9\f9\169\u0326\139\59\u0328\n9\39\59\u032b\n"+
"9\39\39\3:\3:\3:\3:\3:\3:\3;\3;\7;\u0337\n;\f;\16;\u033a\13;\3;\3;\3<"+
"\3<\3<\3<\3<\3<\3<\5<\u0345\n<\3=\3=\3=\3=\3=\3=\3=\5=\u034e\n=\3=\3="+
"\3>\3>\7>\u0354\n>\f>\16>\u0357\13>\3>\3>\3?\3?\3?\5?\u035e\n?\3@\3@\3"+
"@\3A\3A\3A\3A\3A\7A\u0368\nA\fA\16A\u036b\13A\3B\3B\3B\3B\3B\5B\u0372"+
"\nB\3B\3B\3B\3B\3B\3B\3B\5B\u037b\nB\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B"+
"\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\5B\u0395\nB\3B\3B\3B\3B\3B\3B"+
"\3B\5B\u039e\nB\3B\3B\3B\5B\u03a3\nB\3B\3B\3B\3B\3B\3B\3B\3B\5B\u03ad"+
"\nB\3C\3C\3D\7D\u03b2\nD\fD\16D\u03b5\13D\3E\3E\7E\u03b9\nE\fE\16E\u03bc"+
"\13E\3F\3F\3F\3F\3F\3F\5F\u03c4\nF\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3"+
"G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\5G\u03df\nG\3H\3H\3H\3H\5H\u03e5"+
"\nH\3H\3H\5H\u03e9\nH\3I\3I\3I\5I\u03ee\nI\3I\3I\3J\3J\3J\7J\u03f5\nJ"+
"\fJ\16J\u03f8\13J\3K\5K\u03fb\nK\3K\3K\3K\3K\3K\3L\3L\7L\u0404\nL\fL\16"+
"L\u0407\13L\3M\3M\3M\3M\3M\3M\3N\3N\3N\3N\7N\u0413\nN\fN\16N\u0416\13"+
"N\3N\3N\3N\7N\u041b\nN\fN\16N\u041e\13N\3O\3O\5O\u0422\nO\3P\3P\3P\3P"+
"\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\5Q\u0431\nQ\3Q\3Q\5Q\u0435\nQ\3Q\3Q\5Q\u0439"+
"\nQ\3Q\3Q\3Q\3R\3R\5R\u0440\nR\3S\3S\3S\3S\3T\3T\3T\7T\u0449\nT\fT\16"+
"T\u044c\13T\3U\3U\3U\3U\5U\u0452\nU\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3"+
"V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\5V\u0473\n"+
"V\3W\3W\3W\3W\3W\3W\5W\u047b\nW\3X\3X\3X\7X\u0480\nX\fX\16X\u0483\13X"+
"\3Y\3Y\3Y\7Y\u0488\nY\fY\16Y\u048b\13Y\3Z\3Z\3Z\7Z\u0490\nZ\fZ\16Z\u0493"+
"\13Z\3[\3[\3[\7[\u0498\n[\f[\16[\u049b\13[\3\\\3\\\3\\\7\\\u04a0\n\\\f"+
"\\\16\\\u04a3\13\\\3]\3]\3]\7]\u04a8\n]\f]\16]\u04ab\13]\3^\3^\3^\7^\u04b0"+
"\n^\f^\16^\u04b3\13^\3_\3_\3_\5_\u04b8\n_\3`\3`\3`\3`\7`\u04be\n`\f`\16"+
"`\u04c1\13`\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a\5a\u04cd\na\3b\3b\3b\3b\7b\u04d3"+
"\nb\fb\16b\u04d6\13b\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\5c\u04e2\nc\3d\3d\3"+
"d\3d\7d\u04e8\nd\fd\16d\u04eb\13d\3e\3e\3e\3e\5e\u04f1\ne\3f\3f\3f\3f"+
"\7f\u04f7\nf\ff\16f\u04fa\13f\3g\3g\3g\3g\3g\3g\5g\u0502\ng\3h\3h\3h\3"+
"h\3h\3h\3h\3h\3h\3h\3h\3h\3h\5h\u0511\nh\3i\3i\3i\7i\u0516\ni\fi\16i\u0519"+
"\13i\3i\5i\u051c\ni\5i\u051e\ni\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\5j\u052a"+
"\nj\3k\3k\3k\3k\3k\3k\7k\u0532\nk\fk\16k\u0535\13k\3k\5k\u0538\nk\3k\3"+
"k\3k\3k\7k\u053e\nk\fk\16k\u0541\13k\3k\5k\u0544\nk\3k\3k\3k\3k\3k\3k"+
"\3k\3k\3k\3k\3k\3k\3k\3k\7k\u0554\nk\fk\16k\u0557\13k\3k\3k\3k\3k\3k\3"+
"k\3k\3k\5k\u0561\nk\3l\3l\5l\u0565\nl\3l\3l\5l\u0569\nl\3m\3m\3m\3m\6"+
"m\u056f\nm\rm\16m\u0570\3m\3m\3m\3m\3m\3m\3m\3m\3m\3m\3m\3m\3m\3m\5m\u0581"+
"\nm\3n\3n\6n\u0585\nn\rn\16n\u0586\3n\3n\3n\3n\3n\3n\3n\6n\u0590\nn\r"+
"n\16n\u0591\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3"+
"n\5n\u05a8\nn\3o\3o\3o\5o\u05ad\no\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3o\3"+
"o\3o\3o\3o\3o\3o\5o\u05c0\no\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\5p\u05cc\n"+
"p\3q\3q\3q\3q\3q\3q\7q\u05d4\nq\fq\16q\u05d7\13q\3q\3q\3q\3q\3q\3q\3q"+
"\3q\3q\3q\3q\7q\u05e4\nq\fq\16q\u05e7\13q\3q\3q\7q\u05eb\nq\fq\16q\u05ee"+
"\13q\5q\u05f0\nq\3r\3r\5r\u05f4\nr\3s\3s\3s\3s\7s\u05fa\ns\fs\16s\u05fd"+
"\13s\5s\u05ff\ns\3s\5s\u0602\ns\3s\3s\3t\3t\5t\u0608\nt\3u\3u\3u\5u\u060d"+
"\nu\3u\3u\3u\3v\3v\5v\u0614\nv\3w\3w\3w\3w\3x\3x\5x\u061c\nx\3x\3x\3y"+
"\3y\3z\3z\3z\3z\3{\3{\3{\3{\3|\3|\3|\3|\3}\3}\3}\3}\3}\3~\3~\3~\3~\5~"+
"\u0637\n~\3~\5~\u063a\n~\3~\3~\3\177\3\177\5\177\u0640\n\177\3\177\3\177"+
"\5\177\u0644\n\177\3\177\3\177\3\177\3\u0080\3\u0080\3\u0080\3\u0080\3"+
"\u0080\7\u0080\u064e\n\u0080\f\u0080\16\u0080\u0651\13\u0080\3\u0080\3"+
"\u0080\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\7\u0081\u065a\n\u0081\f"+
"\u0081\16\u0081\u065d\13\u0081\3\u0081\3\u0081\3\u0081\2\u0082\2\4\6\b"+
"\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVX"+
"Z\\^`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\2\n\3!(\4**--\3,-\3C"+
"D\4.\60`c\4AAdd\5\3\3\21\21\34\34\5\3\3\21\21\34\34\u06e0\2\u0103\3\2"+
"\2\2\4\u0112\3\2\2\2\6\u0130\3\2\2\2\b\u0132\3\2\2\2\n\u013c\3\2\2\2\f"+
"\u0140\3\2\2\2\16\u0145\3\2\2\2\20\u0154\3\2\2\2\22\u0159\3\2\2\2\24\u0167"+
"\3\2\2\2\26\u0169\3\2\2\2\30\u0179\3\2\2\2\32\u0184\3\2\2\2\34\u0189\3"+
"\2\2\2\36\u0191\3\2\2\2 \u019a\3\2\2\2\"\u01a6\3\2\2\2$\u01af\3\2\2\2"+
"&\u01b8\3\2\2\2(\u01c1\3\2\2\2*\u01c3\3\2\2\2,\u01cf\3\2\2\2.\u01d7\3"+
"\2\2\2\60\u01e0\3\2\2\2\62\u01ef\3\2\2\2\64\u01f6\3\2\2\2\66\u01f8\3\2"+
"\2\28\u0211\3\2\2\2:\u021d\3\2\2\2<\u0229\3\2\2\2>\u0235\3\2\2\2@\u0246"+
"\3\2\2\2B\u0248\3\2\2\2D\u025f\3\2\2\2F\u027b\3\2\2\2H\u027d\3\2\2\2J"+
"\u0285\3\2\2\2L\u0289\3\2\2\2N\u0298\3\2\2\2P\u02a0\3\2\2\2R\u02a2\3\2"+
"\2\2T\u02aa\3\2\2\2V\u02c7\3\2\2\2X\u02c9\3\2\2\2Z\u02d3\3\2\2\2\\\u02e8"+
"\3\2\2\2^\u02ea\3\2\2\2`\u02f3\3\2\2\2b\u02fa\3\2\2\2d\u02fc\3\2\2\2f"+
"\u02ff\3\2\2\2h\u0305\3\2\2\2j\u030d\3\2\2\2l\u0315\3\2\2\2n\u031c\3\2"+
"\2\2p\u031e\3\2\2\2r\u032e\3\2\2\2t\u0334\3\2\2\2v\u0344\3\2\2\2x\u0346"+
"\3\2\2\2z\u0351\3\2\2\2|\u035d\3\2\2\2~\u035f\3\2\2\2\u0080\u0362\3\2"+
"\2\2\u0082\u03ac\3\2\2\2\u0084\u03ae\3\2\2\2\u0086\u03b3\3\2\2\2\u0088"+
"\u03b6\3\2\2\2\u008a\u03c3\3\2\2\2\u008c\u03de\3\2\2\2\u008e\u03e0\3\2"+
"\2\2\u0090\u03ea\3\2\2\2\u0092\u03f1\3\2\2\2\u0094\u03fa\3\2\2\2\u0096"+
"\u0401\3\2\2\2\u0098\u0408\3\2\2\2\u009a\u040e\3\2\2\2\u009c\u0421\3\2"+
"\2\2\u009e\u0423\3\2\2\2\u00a0\u042d\3\2\2\2\u00a2\u043f\3\2\2\2\u00a4"+
"\u0441\3\2\2\2\u00a6\u0445\3\2\2\2\u00a8\u044d\3\2\2\2\u00aa\u0472\3\2"+
"\2\2\u00ac\u0474\3\2\2\2\u00ae\u047c\3\2\2\2\u00b0\u0484\3\2\2\2\u00b2"+
"\u048c\3\2\2\2\u00b4\u0494\3\2\2\2\u00b6\u049c\3\2\2\2\u00b8\u04a4\3\2"+
"\2\2\u00ba\u04ac\3\2\2\2\u00bc\u04b4\3\2\2\2\u00be\u04b9\3\2\2\2\u00c0"+
"\u04cc\3\2\2\2\u00c2\u04ce\3\2\2\2\u00c4\u04e1\3\2\2\2\u00c6\u04e3\3\2"+
"\2\2\u00c8\u04f0\3\2\2\2\u00ca\u04f2\3\2\2\2\u00cc\u0501\3\2\2\2\u00ce"+
"\u0510\3\2\2\2\u00d0\u051d\3\2\2\2\u00d2\u0529\3\2\2\2\u00d4\u0560\3\2"+
"\2\2\u00d6\u0562\3\2\2\2\u00d8\u0580\3\2\2\2\u00da\u05a7\3\2\2\2\u00dc"+
"\u05bf\3\2\2\2\u00de\u05cb\3\2\2\2\u00e0\u05ef\3\2\2\2\u00e2\u05f3\3\2"+
"\2\2\u00e4\u05f5\3\2\2\2\u00e6\u0607\3\2\2\2\u00e8\u0609\3\2\2\2\u00ea"+
"\u0611\3\2\2\2\u00ec\u0615\3\2\2\2\u00ee\u0619\3\2\2\2\u00f0\u061f\3\2"+
"\2\2\u00f2\u0621\3\2\2\2\u00f4\u0625\3\2\2\2\u00f6\u0629\3\2\2\2\u00f8"+
"\u062d\3\2\2\2\u00fa\u0632\3\2\2\2\u00fc\u063d\3\2\2\2\u00fe\u0648\3\2"+
"\2\2\u0100\u0654\3\2\2\2\u0102\u0104\5\4\3\2\u0103\u0102\3\2\2\2\u0103"+
"\u0104\3\2\2\2\u0104\u0108\3\2\2\2\u0105\u0107\5\6\4\2\u0106\u0105\3\2"+
"\2\2\u0107\u010a\3\2\2\2\u0108\u0106\3\2\2\2\u0108\u0109\3\2\2\2\u0109"+
"\u010e\3\2\2\2\u010a\u0108\3\2\2\2\u010b\u010d\5\n\6\2\u010c\u010b\3\2"+
"\2\2\u010d\u0110\3\2\2\2\u010e\u010c\3\2\2\2\u010e\u010f\3\2\2\2\u010f"+
"\3\3\2\2\2\u0110\u010e\3\2\2\2\u0111\u0113\5`\61\2\u0112\u0111\3\2\2\2"+
"\u0112\u0113\3\2\2\2\u0113\u0114\3\2\2\2\u0114\u0115\7\4\2\2\u0115\u0116"+
"\5^\60\2\u0116\u0117\7\3\2\2\u0117\5\3\2\2\2\u0118\u011a\7\5\2\2\u0119"+
"\u011b\7\16\2\2\u011a\u0119\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u011c\3"+
"\2\2\2\u011c\u011d\7d\2\2\u011d\u011e\7\6\2\2\u011e\u011f\7\7\2\2\u011f"+
"\u0131\7\3\2\2\u0120\u0122\7\5\2\2\u0121\u0123\7\16\2\2\u0122\u0121\3"+
"\2\2\2\u0122\u0123\3\2\2\2\u0123\u0124\3\2\2\2\u0124\u0127\7d\2\2\u0125"+
"\u0126\7\6\2\2\u0126\u0128\7d\2\2\u0127\u0125\3\2\2\2\u0128\u0129\3\2"+
"\2\2\u0129\u0127\3\2\2\2\u0129\u012a\3\2\2\2\u012a\u012d\3\2\2\2\u012b"+
"\u012c\7\6\2\2\u012c\u012e\7\7\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2"+
"\2\2\u012e\u012f\3\2\2\2\u012f\u0131\7\3\2\2\u0130\u0118\3\2\2\2\u0130"+
"\u0120\3\2\2\2\u0131\7\3\2\2\2\u0132\u0137\7d\2\2\u0133\u0134\7\6\2\2"+
"\u0134\u0136\7d\2\2\u0135\u0133\3\2\2\2\u0136\u0139\3\2\2\2\u0137\u0135"+
"\3\2\2\2\u0137\u0138\3\2\2\2\u0138\t\3\2\2\2\u0139\u0137\3\2\2\2\u013a"+
"\u013d\5\f\7\2\u013b\u013d\7\3\2\2\u013c\u013a\3\2\2\2\u013c\u013b\3\2"+
"\2\2\u013d\13\3\2\2\2\u013e\u0141\5\24\13\2\u013f\u0141\5(\25\2\u0140"+
"\u013e\3\2\2\2\u0140\u013f\3\2\2\2\u0141\r\3\2\2\2\u0142\u0144\5\20\t"+
"\2\u0143\u0142\3\2\2\2\u0144\u0147\3\2\2\2\u0145\u0143\3\2\2\2\u0145\u0146"+
"\3\2\2\2\u0146\17\3\2\2\2\u0147\u0145\3\2\2\2\u0148\u0155\5b\62\2\u0149"+
"\u0155\7\n\2\2\u014a\u0155\7\13\2\2\u014b\u0155\7\f\2\2\u014c\u0155\7"+
"\16\2\2\u014d\u0155\7\r\2\2\u014e\u0155\7\17\2\2\u014f\u0155\7\35\2\2"+
"\u0150\u0155\7\36\2\2\u0151\u0155\7\37\2\2\u0152\u0155\7 \2\2\u0153\u0155"+
"\7\20\2\2\u0154\u0148\3\2\2\2\u0154\u0149\3\2\2\2\u0154\u014a\3\2\2\2"+
"\u0154\u014b\3\2\2\2\u0154\u014c\3\2\2\2\u0154\u014d\3\2\2\2\u0154\u014e"+
"\3\2\2\2\u0154\u014f\3\2\2\2\u0154\u0150\3\2\2\2\u0154\u0151\3\2\2\2\u0154"+
"\u0152\3\2\2\2\u0154\u0153\3\2\2\2\u0155\21\3\2\2\2\u0156\u0158\5b\62"+
"\2\u0157\u0156\3\2\2\2\u0158\u015b\3\2\2\2\u0159\u0157\3\2\2\2\u0159\u015a"+
"\3\2\2\2\u015a\u015d\3\2\2\2\u015b\u0159\3\2\2\2\u015c\u015e\7\17\2\2"+
"\u015d\u015c\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u0162\3\2\2\2\u015f\u0161"+
"\5b\62\2\u0160\u015f\3\2\2\2\u0161\u0164\3\2\2\2\u0162\u0160\3\2\2\2\u0162"+
"\u0163\3\2\2\2\u0163\23\3\2\2\2\u0164\u0162\3\2\2\2\u0165\u0168\5\26\f"+
"\2\u0166\u0168\5\36\20\2\u0167\u0165\3\2\2\2\u0167\u0166\3\2\2\2\u0168"+
"\25\3\2\2\2\u0169\u016a\5\16\b\2\u016a\u016b\7\b\2\2\u016b\u016d\7d\2"+
"\2\u016c\u016e\5\30\r\2\u016d\u016c\3\2\2\2\u016d\u016e\3\2\2\2\u016e"+
"\u0171\3\2\2\2\u016f\u0170\7*\2\2\u0170\u0172\5F$\2\u0171\u016f\3\2\2"+
"\2\u0171\u0172\3\2\2\2\u0172\u0175\3\2\2\2\u0173\u0174\7\t\2\2\u0174\u0176"+
"\5,\27\2\u0175\u0173\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u0177\3\2\2\2\u0177"+
"\u0178\5.\30\2\u0178\27\3\2\2\2\u0179\u017a\7\\\2\2\u017a\u017f\5\32\16"+
"\2\u017b\u017c\7\21\2\2\u017c\u017e\5\32\16\2\u017d\u017b\3\2\2\2\u017e"+
"\u0181\3\2\2\2\u017f\u017d\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0182\3\2"+
"\2\2\u0181\u017f\3\2\2\2\u0182\u0183\7[\2\2\u0183\31\3\2\2\2\u0184\u0187"+
"\7d\2\2\u0185\u0186\7*\2\2\u0186\u0188\5\34\17\2\u0187\u0185\3\2\2\2\u0187"+
"\u0188\3\2\2\2\u0188\33\3\2\2\2\u0189\u018e\5F$\2\u018a\u018b\7N\2\2\u018b"+
"\u018d\5F$\2\u018c\u018a\3\2\2\2\u018d\u0190\3\2\2\2\u018e\u018c\3\2\2"+
"\2\u018e\u018f\3\2\2\2\u018f\35\3\2\2\2\u0190\u018e\3\2\2\2\u0191\u0192"+
"\5\16\b\2\u0192\u0193\7A\2\2\u0193\u0196\7d\2\2\u0194\u0195\7\t\2\2\u0195"+
"\u0197\5,\27\2\u0196\u0194\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u0198\3\2"+
"\2\2\u0198\u0199\5 \21\2\u0199\37\3\2\2\2\u019a\u019c\7\22\2\2\u019b\u019d"+
"\5\"\22\2\u019c\u019b\3\2\2\2\u019c\u019d\3\2\2\2\u019d\u019f\3\2\2\2"+
"\u019e\u01a0\7\21\2\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2"+
"\3\2\2\2\u01a1\u01a3\5&\24\2\u01a2\u01a1\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a3"+
"\u01a4\3\2\2\2\u01a4\u01a5\7\23\2\2\u01a5!\3\2\2\2\u01a6\u01ab\5$\23\2"+
"\u01a7\u01a8\7\21\2\2\u01a8\u01aa\5$\23\2\u01a9\u01a7\3\2\2\2\u01aa\u01ad"+
"\3\2\2\2\u01ab\u01a9\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac#\3\2\2\2\u01ad"+
"\u01ab\3\2\2\2\u01ae\u01b0\5`\61\2\u01af\u01ae\3\2\2\2\u01af\u01b0\3\2"+
"\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b3\7d\2\2\u01b2\u01b4\5\u00eex\2\u01b3"+
"\u01b2\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4\u01b6\3\2\2\2\u01b5\u01b7\5."+
"\30\2\u01b6\u01b5\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7%\3\2\2\2\u01b8\u01bc"+
"\7\3\2\2\u01b9\u01bb\5\62\32\2\u01ba\u01b9\3\2\2\2\u01bb\u01be\3\2\2\2"+
"\u01bc\u01ba\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd\'\3\2\2\2\u01be\u01bc\3"+
"\2\2\2\u01bf\u01c2\5*\26\2\u01c0\u01c2\5r:\2\u01c1\u01bf\3\2\2\2\u01c1"+
"\u01c0\3\2\2\2\u01c2)\3\2\2\2\u01c3\u01c4\5\16\b\2\u01c4\u01c5\7\31\2"+
"\2\u01c5\u01c7\7d\2\2\u01c6\u01c8\5\30\r\2\u01c7\u01c6\3\2\2\2\u01c7\u01c8"+
"\3\2\2\2\u01c8\u01cb\3\2\2\2\u01c9\u01ca\7*\2\2\u01ca\u01cc\5,\27\2\u01cb"+
"\u01c9\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01ce\5\60"+
"\31\2\u01ce+\3\2\2\2\u01cf\u01d4\5F$\2\u01d0\u01d1\7\21\2\2\u01d1\u01d3"+
"\5F$\2\u01d2\u01d0\3\2\2\2\u01d3\u01d6\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d4"+
"\u01d5\3\2\2\2\u01d5-\3\2\2\2\u01d6\u01d4\3\2\2\2\u01d7\u01db\7\22\2\2"+
"\u01d8\u01da\5\62\32\2\u01d9\u01d8\3\2\2\2\u01da\u01dd\3\2\2\2\u01db\u01d9"+
"\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01de\3\2\2\2\u01dd\u01db\3\2\2\2\u01de"+
"\u01df\7\23\2\2\u01df/\3\2\2\2\u01e0\u01e4\7\22\2\2\u01e1\u01e3\5@!\2"+
"\u01e2\u01e1\3\2\2\2\u01e3\u01e6\3\2\2\2\u01e4\u01e2\3\2\2\2\u01e4\u01e5"+
"\3\2\2\2\u01e5\u01e7\3\2\2\2\u01e6\u01e4\3\2\2\2\u01e7\u01e8\7\23\2\2"+
"\u01e8\61\3\2\2\2\u01e9\u01f0\7\3\2\2\u01ea\u01ec\7\16\2\2\u01eb\u01ea"+
"\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01f0\5z>\2\u01ee"+
"\u01f0\5\64\33\2\u01ef\u01e9\3\2\2\2\u01ef\u01eb\3\2\2\2\u01ef\u01ee\3"+
"\2\2\2\u01f0\63\3\2\2\2\u01f1\u01f7\58\35\2\u01f2\u01f7\5<\37\2\u01f3"+
"\u01f7\5\66\34\2\u01f4\u01f7\5\24\13\2\u01f5\u01f7\5(\25\2\u01f6\u01f1"+
"\3\2\2\2\u01f6\u01f2\3\2\2\2\u01f6\u01f3\3\2\2\2\u01f6\u01f4\3\2\2\2\u01f6"+
"\u01f5\3\2\2\2\u01f7\65\3\2\2\2\u01f8\u01fa\5\16\b\2\u01f9\u01fb\5\30"+
"\r\2\u01fa\u01f9\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fe\3\2\2\2\u01fc"+
"\u01ff\5F$\2\u01fd\u01ff\7\30\2\2\u01fe\u01fc\3\2\2\2\u01fe\u01fd\3\2"+
"\2\2\u01ff\u0200\3\2\2\2\u0200\u0201\7d\2\2\u0201\u0206\5T+\2\u0202\u0203"+
"\7\24\2\2\u0203\u0205\7\25\2\2\u0204\u0202\3\2\2\2\u0205\u0208\3\2\2\2"+
"\u0206\u0204\3\2\2\2\u0206\u0207\3\2\2\2\u0207\u020b\3\2\2\2\u0208\u0206"+
"\3\2\2\2\u0209\u020a\7\33\2\2\u020a\u020c\5R*\2\u020b\u0209\3\2\2\2\u020b"+
"\u020c\3\2\2\2\u020c\u020f\3\2\2\2\u020d\u0210\5z>\2\u020e\u0210\7\3\2"+
"\2\u020f\u020d\3\2\2\2\u020f\u020e\3\2\2\2\u0210\67\3\2\2\2\u0211\u0213"+
"\5\16\b\2\u0212\u0214\5\30\r\2\u0213\u0212\3\2\2\2\u0213\u0214\3\2\2\2"+
"\u0214\u0215\3\2\2\2\u0215\u0216\7d\2\2\u0216\u0219\5T+\2\u0217\u0218"+
"\7\33\2\2\u0218\u021a\5R*\2\u0219\u0217\3\2\2\2\u0219\u021a\3\2\2\2\u021a"+
"\u021b\3\2\2\2\u021b\u021c\5:\36\2\u021c9\3\2\2\2\u021d\u021f\7\22\2\2"+
"\u021e\u0220\5\\/\2\u021f\u021e\3\2\2\2\u021f\u0220\3\2\2\2\u0220\u0224"+
"\3\2\2\2\u0221\u0223\5|?\2\u0222\u0221\3\2\2\2\u0223\u0226\3\2\2\2\u0224"+
"\u0222\3\2\2\2\u0224\u0225\3\2\2\2\u0225\u0227\3\2\2\2\u0226\u0224\3\2"+
"\2\2\u0227\u0228\7\23\2\2\u0228;\3\2\2\2\u0229\u022a\5\16\b\2\u022a\u022b"+
"\5F$\2\u022b\u0230\5> \2\u022c\u022d\7\21\2\2\u022d\u022f\5> \2\u022e"+
"\u022c\3\2\2\2\u022f\u0232\3\2\2\2\u0230\u022e\3\2\2\2\u0230\u0231\3\2"+
"\2\2\u0231\u0233\3\2\2\2\u0232\u0230\3\2\2\2\u0233\u0234\7\3\2\2\u0234"+
"=\3\2\2\2\u0235\u023a\7d\2\2\u0236\u0237\7\24\2\2\u0237\u0239\7\25\2\2"+
"\u0238\u0236\3\2\2\2\u0239\u023c\3\2\2\2\u023a\u0238\3\2\2\2\u023a\u023b"+
"\3\2\2\2\u023b\u023f\3\2\2\2\u023c\u023a\3\2\2\2\u023d\u023e\7\34\2\2"+
"\u023e\u0240\5\u00e2r\2\u023f\u023d\3\2\2\2\u023f\u0240\3\2\2\2\u0240"+
"?\3\2\2\2\u0241\u0247\5D#\2\u0242\u0247\5B\"\2\u0243\u0247\5(\25\2\u0244"+
"\u0247\5\24\13\2\u0245\u0247\7\3\2\2\u0246\u0241\3\2\2\2\u0246\u0242\3"+
"\2\2\2\u0246\u0243\3\2\2\2\u0246\u0244\3\2\2\2\u0246\u0245\3\2\2\2\u0247"+
"A\3\2\2\2\u0248\u024a\5\16\b\2\u0249\u024b\5\30\r\2\u024a\u0249\3\2\2"+
"\2\u024a\u024b\3\2\2\2\u024b\u024e\3\2\2\2\u024c\u024f\5F$\2\u024d\u024f"+
"\7\30\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2\2\2\u024f\u0250\3\2\2\2"+
"\u0250\u0251\7d\2\2\u0251\u0256\5T+\2\u0252\u0253\7\24\2\2\u0253\u0255"+
"\7\25\2\2\u0254\u0252\3\2\2\2\u0255\u0258\3\2\2\2\u0256\u0254\3\2\2\2"+
"\u0256\u0257\3\2\2\2\u0257\u025b\3\2\2\2\u0258\u0256\3\2\2\2\u0259\u025a"+
"\7\33\2\2\u025a\u025c\5R*\2\u025b\u0259\3\2\2\2\u025b\u025c\3\2\2\2\u025c"+
"\u025d\3\2\2\2\u025d\u025e\7\3\2\2\u025eC\3\2\2\2\u025f\u0260\5\16\b\2"+
"\u0260\u0261\5F$\2\u0261\u0266\5> \2\u0262\u0263\7\21\2\2\u0263\u0265"+
"\5> \2\u0264\u0262\3\2\2\2\u0265\u0268\3\2\2\2\u0266\u0264\3\2\2\2\u0266"+
"\u0267\3\2\2\2\u0267\u0269\3\2\2\2\u0268\u0266\3\2\2\2\u0269\u026a\7\3"+
"\2\2\u026aE\3\2\2\2\u026b\u0270\5H%\2\u026c\u026d\7\24\2\2\u026d\u026f"+
"\7\25\2\2\u026e\u026c\3\2\2\2\u026f\u0272\3\2\2\2\u0270\u026e\3\2\2\2"+
"\u0270\u0271\3\2\2\2\u0271\u027c\3\2\2\2\u0272\u0270\3\2\2\2\u0273\u0278"+
"\5L\'\2\u0274\u0275\7\24\2\2\u0275\u0277\7\25\2\2\u0276\u0274\3\2\2\2"+
"\u0277\u027a\3\2\2\2\u0278\u0276\3\2\2\2\u0278\u0279\3\2\2\2\u0279\u027c"+
"\3\2\2\2\u027a\u0278\3\2\2\2\u027b\u026b\3\2\2\2\u027b\u0273\3\2\2\2\u027c"+
"G\3\2\2\2\u027d\u0282\5J&\2\u027e\u027f\7\6\2\2\u027f\u0281\5J&\2\u0280"+
"\u027e\3\2\2\2\u0281\u0284\3\2\2\2\u0282\u0280\3\2\2\2\u0282\u0283\3\2"+
"\2\2\u0283I\3\2\2\2\u0284\u0282\3\2\2\2\u0285\u0287\7d\2\2\u0286\u0288"+
"\5N(\2\u0287\u0286\3\2\2\2\u0287\u0288\3\2\2\2\u0288K\3\2\2\2\u0289\u028a"+
"\t\2\2\2\u028aM\3\2\2\2\u028b\u028c\7\\\2\2\u028c\u0291\5P)\2\u028d\u028e"+
"\7\21\2\2\u028e\u0290\5P)\2\u028f\u028d\3\2\2\2\u0290\u0293\3\2\2\2\u0291"+
"\u028f\3\2\2\2\u0291\u0292\3\2\2\2\u0292\u0294\3\2\2\2\u0293\u0291\3\2"+
"\2\2\u0294\u0295\7[\2\2\u0295\u0299\3\2\2\2\u0296\u0297\7\\\2\2\u0297"+
"\u0299\7[\2\2\u0298\u028b\3\2\2\2\u0298\u0296\3\2\2\2\u0299O\3\2\2\2\u029a"+
"\u02a1\5F$\2\u029b\u029e\7)\2\2\u029c\u029d\t\3\2\2\u029d\u029f\5F$\2"+
"\u029e\u029c\3\2\2\2\u029e\u029f\3\2\2\2\u029f\u02a1\3\2\2\2\u02a0\u029a"+
"\3\2\2\2\u02a0\u029b\3\2\2\2\u02a1Q\3\2\2\2\u02a2\u02a7\5^\60\2\u02a3"+
"\u02a4\7\21\2\2\u02a4\u02a6\5^\60\2\u02a5\u02a3\3\2\2\2\u02a6\u02a9\3"+
"\2\2\2\u02a7\u02a5\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8S\3\2\2\2\u02a9\u02a7"+
"\3\2\2\2\u02aa\u02ac\7\26\2\2\u02ab\u02ad\5V,\2\u02ac\u02ab\3\2\2\2\u02ac"+
"\u02ad\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02af\7\27\2\2\u02afU\3\2\2\2"+
"\u02b0\u02b1\5Z.\2\u02b1\u02b2\b,\1\2\u02b2\u02c8\3\2\2\2\u02b3\u02b8"+
"\5X-\2\u02b4\u02b5\7\21\2\2\u02b5\u02b7\5X-\2\u02b6\u02b4\3\2\2\2\u02b7"+
"\u02ba\3\2\2\2\u02b8\u02b6\3\2\2\2\u02b8\u02b9\3\2\2\2\u02b9\u02bb\3\2"+
"\2\2\u02ba\u02b8\3\2\2\2\u02bb\u02bc\b,\1\2\u02bc\u02c8\3\2\2\2\u02bd"+
"\u02be\5X-\2\u02be\u02bf\7\21\2\2\u02bf\u02c1\3\2\2\2\u02c0\u02bd\3\2"+
"\2\2\u02c1\u02c2\3\2\2\2\u02c2\u02c0\3\2\2\2\u02c2\u02c3\3\2\2\2\u02c3"+
"\u02c4\3\2\2\2\u02c4\u02c5\5Z.\2\u02c5\u02c6\b,\1\2\u02c6\u02c8\3\2\2"+
"\2\u02c7\u02b0\3\2\2\2\u02c7\u02b3\3\2\2\2\u02c7\u02c0\3\2\2\2\u02c8W"+
"\3\2\2\2\u02c9\u02ca\5\22\n\2\u02ca\u02cb\5F$\2\u02cb\u02d0\7d\2\2\u02cc"+
"\u02cd\7\24\2\2\u02cd\u02cf\7\25\2\2\u02ce\u02cc\3\2\2\2\u02cf\u02d2\3"+
"\2\2\2\u02d0\u02ce\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1Y\3\2\2\2\u02d2\u02d0"+
"\3\2\2\2\u02d3\u02d4\5\22\n\2\u02d4\u02d5\5F$\2\u02d5\u02d6\7+\2\2\u02d6"+
"\u02d7\7d\2\2\u02d7[\3\2\2\2\u02d8\u02da\5\u00ecw\2\u02d9\u02d8\3\2\2"+
"\2\u02d9\u02da\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dc\t\4\2\2\u02dc\u02dd"+
"\5\u00eex\2\u02dd\u02de\7\3\2\2\u02de\u02e9\3\2\2\2\u02df\u02e0\5\u00d4"+
"k\2\u02e0\u02e2\7\6\2\2\u02e1\u02e3\5\u00ecw\2\u02e2\u02e1\3\2\2\2\u02e2"+
"\u02e3\3\2\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02e5\7-\2\2\u02e5\u02e6\5\u00ee"+
"x\2\u02e6\u02e7\7\3\2\2\u02e7\u02e9\3\2\2\2\u02e8\u02d9\3\2\2\2\u02e8"+
"\u02df\3\2\2\2\u02e9]\3\2\2\2\u02ea\u02ef\7d\2\2\u02eb\u02ec\7\6\2\2\u02ec"+
"\u02ee\7d\2\2\u02ed\u02eb\3\2\2\2\u02ee\u02f1\3\2\2\2\u02ef\u02ed\3\2"+
"\2\2\u02ef\u02f0\3\2\2\2\u02f0_\3\2\2\2\u02f1\u02ef\3\2\2\2\u02f2\u02f4"+
"\5b\62\2\u02f3\u02f2\3\2\2\2\u02f4\u02f5\3\2\2\2\u02f5\u02f3\3\2\2\2\u02f5"+
"\u02f6\3\2\2\2\u02f6a\3\2\2\2\u02f7\u02fb\5d\63\2\u02f8\u02fb\5f\64\2"+
"\u02f9\u02fb\5h\65\2\u02fa\u02f7\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fa\u02f9"+
"\3\2\2\2\u02fbc\3\2\2\2\u02fc\u02fd\7\61\2\2\u02fd\u02fe\5^\60\2\u02fe"+
"e\3\2\2\2\u02ff\u0300\7\61\2\2\u0300\u0301\5^\60\2\u0301\u0302\7\26\2"+
"\2\u0302\u0303\5n8\2\u0303\u0304\7\27\2\2\u0304g\3\2\2\2\u0305\u0306\7"+
"\61\2\2\u0306\u0307\5^\60\2\u0307\u0309\7\26\2\2\u0308\u030a\5j\66\2\u0309"+
"\u0308\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u030c\7\27"+
"\2\2\u030ci\3\2\2\2\u030d\u0312\5l\67\2\u030e\u030f\7\21\2\2\u030f\u0311"+
"\5l\67\2\u0310\u030e\3\2\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312"+
"\u0313\3\2\2\2\u0313k\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\7d\2\2\u0316"+
"\u0317\7\34\2\2\u0317\u0318\5n8\2\u0318m\3\2\2\2\u0319\u031d\5\u00acW"+
"\2\u031a\u031d\5b\62\2\u031b\u031d\5p9\2\u031c\u0319\3\2\2\2\u031c\u031a"+
"\3\2\2\2\u031c\u031b\3\2\2\2\u031do\3\2\2\2\u031e\u0327\7\22\2\2\u031f"+
"\u0324\5n8\2\u0320\u0321\7\21\2\2\u0321\u0323\5n8\2\u0322\u0320\3\2\2"+
"\2\u0323\u0326\3\2\2\2\u0324\u0322\3\2\2\2\u0324\u0325\3\2\2\2\u0325\u0328"+
"\3\2\2\2\u0326\u0324\3\2\2\2\u0327\u031f\3\2\2\2\u0327\u0328\3\2\2\2\u0328"+
"\u032a\3\2\2\2\u0329\u032b\7\21\2\2\u032a\u0329\3\2\2\2\u032a\u032b\3"+
"\2\2\2\u032b\u032c\3\2\2\2\u032c\u032d\7\23\2\2\u032dq\3\2\2\2\u032e\u032f"+
"\5\16\b\2\u032f\u0330\7\61\2\2\u0330\u0331\7\31\2\2\u0331\u0332\7d\2\2"+
"\u0332\u0333\5t;\2\u0333s\3\2\2\2\u0334\u0338\7\22\2\2\u0335\u0337\5v"+
"<\2\u0336\u0335\3\2\2\2\u0337\u033a\3\2\2\2\u0338\u0336\3\2\2\2\u0338"+
"\u0339\3\2\2\2\u0339\u033b\3\2\2\2\u033a\u0338\3\2\2\2\u033b\u033c\7\23"+
"\2\2\u033cu\3\2\2\2\u033d\u0345\5x=\2\u033e\u0345\5D#\2\u033f\u0345\5"+
"\26\f\2\u0340\u0345\5*\26\2\u0341\u0345\5\36\20\2\u0342\u0345\5r:\2\u0343"+
"\u0345\7\3\2\2\u0344\u033d\3\2\2\2\u0344\u033e\3\2\2\2\u0344\u033f\3\2"+
"\2\2\u0344\u0340\3\2\2\2\u0344\u0341\3\2\2\2\u0344\u0342\3\2\2\2\u0344"+
"\u0343\3\2\2\2\u0345w\3\2\2\2\u0346\u0347\5\16\b\2\u0347\u0348\5F$\2\u0348"+
"\u0349\7d\2\2\u0349\u034a\7\26\2\2\u034a\u034d\7\27\2\2\u034b\u034c\7"+
"\62\2\2\u034c\u034e\5n8\2\u034d\u034b\3\2\2\2\u034d\u034e\3\2\2\2\u034e"+
"\u034f\3\2\2\2\u034f\u0350\7\3\2\2\u0350y\3\2\2\2\u0351\u0355\7\22\2\2"+
"\u0352\u0354\5|?\2\u0353\u0352\3\2\2\2\u0354\u0357\3\2\2\2\u0355\u0353"+
"\3\2\2\2\u0355\u0356\3\2\2\2\u0356\u0358\3\2\2\2\u0357\u0355\3\2\2\2\u0358"+
"\u0359\7\23\2\2\u0359{\3\2\2\2\u035a\u035e\5~@\2\u035b\u035e\5\f\7\2\u035c"+
"\u035e\5\u0082B\2\u035d\u035a\3\2\2\2\u035d\u035b\3\2\2\2\u035d\u035c"+
"\3\2\2\2\u035e}\3\2\2\2\u035f\u0360\5\u0080A\2\u0360\u0361\7\3\2\2\u0361"+
"\177\3\2\2\2\u0362\u0363\5\22\n\2\u0363\u0364\5F$\2\u0364\u0369\5> \2"+
"\u0365\u0366\7\21\2\2\u0366\u0368\5> \2\u0367\u0365\3\2\2\2\u0368\u036b"+
"\3\2\2\2\u0369\u0367\3\2\2\2\u0369\u036a\3\2\2\2\u036a\u0081\3\2\2\2\u036b"+
"\u0369\3\2\2\2\u036c\u03ad\5z>\2\u036d\u036e\7B\2\2\u036e\u0371\5\u00a8"+
"U\2\u036f\u0370\7\63\2\2\u0370\u0372\5\u00a8U\2\u0371\u036f\3\2\2\2\u0371"+
"\u0372\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0374\7\3\2\2\u0374\u03ad\3\2"+
"\2\2\u0375\u0376\7\64\2\2\u0376\u0377\5\u00a4S\2\u0377\u037a\5\u0082B"+
"\2\u0378\u0379\7\65\2\2\u0379\u037b\5\u0082B\2\u037a\u0378\3\2\2\2\u037a"+
"\u037b\3\2\2\2\u037b\u03ad\3\2\2\2\u037c\u03ad\5\u009cO\2\u037d\u037e"+
"\7\67\2\2\u037e\u037f\5\u00a4S\2\u037f\u0380\5\u0082B\2\u0380\u03ad\3"+
"\2\2\2\u0381\u0382\78\2\2\u0382\u0383\5\u0082B\2\u0383\u0384\7\67\2\2"+
"\u0384\u0385\5\u00a4S\2\u0385\u0386\7\3\2\2\u0386\u03ad\3\2\2\2\u0387"+
"\u03ad\5\u008cG\2\u0388\u0389\7;\2\2\u0389\u038a\5\u00a4S\2\u038a\u038b"+
"\7\22\2\2\u038b\u038c\5\u0086D\2\u038c\u038d\7\23\2\2\u038d\u03ad\3\2"+
"\2\2\u038e\u038f\7\36\2\2\u038f\u0390\5\u00a4S\2\u0390\u0391\5z>\2\u0391"+
"\u03ad\3\2\2\2\u0392\u0394\7<\2\2\u0393\u0395\5\u00a8U\2\u0394\u0393\3"+
"\2\2\2\u0394\u0395\3\2\2\2\u0395\u0396\3\2\2\2\u0396\u03ad\7\3\2\2\u0397"+
"\u0398\7\32\2\2\u0398\u0399\5\u00a8U\2\u0399\u039a\7\3\2\2\u039a\u03ad"+
"\3\2\2\2\u039b\u039d\7=\2\2\u039c\u039e\7d\2\2\u039d\u039c\3\2\2\2\u039d"+
"\u039e\3\2\2\2\u039e\u039f\3\2\2\2\u039f\u03ad\7\3\2\2\u03a0\u03a2\7>"+
"\2\2\u03a1\u03a3\7d\2\2\u03a2\u03a1\3\2\2\2\u03a2\u03a3\3\2\2\2\u03a3"+
"\u03a4\3\2\2\2\u03a4\u03ad\7\3\2\2\u03a5\u03a6\5\u00a8U\2\u03a6\u03a7"+
"\7\3\2\2\u03a7\u03ad\3\2\2\2\u03a8\u03a9\7d\2\2\u03a9\u03aa\7\63\2\2\u03aa"+
"\u03ad\5\u0082B\2\u03ab\u03ad\5\u0084C\2\u03ac\u036c\3\2\2\2\u03ac\u036d"+
"\3\2\2\2\u03ac\u0375\3\2\2\2\u03ac\u037c\3\2\2\2\u03ac\u037d\3\2\2\2\u03ac"+
"\u0381\3\2\2\2\u03ac\u0387\3\2\2\2\u03ac\u0388\3\2\2\2\u03ac\u038e\3\2"+
"\2\2\u03ac\u0392\3\2\2\2\u03ac\u0397\3\2\2\2\u03ac\u039b\3\2\2\2\u03ac"+
"\u03a0\3\2\2\2\u03ac\u03a5\3\2\2\2\u03ac\u03a8\3\2\2\2\u03ac\u03ab\3\2"+
"\2\2\u03ad\u0083\3\2\2\2\u03ae\u03af\7\3\2\2\u03af\u0085\3\2\2\2\u03b0"+
"\u03b2\5\u0088E\2\u03b1\u03b0\3\2\2\2\u03b2\u03b5\3\2\2\2\u03b3\u03b1"+
"\3\2\2\2\u03b3\u03b4\3\2\2\2\u03b4\u0087\3\2\2\2\u03b5\u03b3\3\2\2\2\u03b6"+
"\u03ba\5\u008aF\2\u03b7\u03b9\5|?\2\u03b8\u03b7\3\2\2\2\u03b9\u03bc\3"+
"\2\2\2\u03ba\u03b8\3\2\2\2\u03ba\u03bb\3\2\2\2\u03bb\u0089\3\2\2\2\u03bc"+
"\u03ba\3\2\2\2\u03bd\u03be\7@\2\2\u03be\u03bf\5\u00a8U\2\u03bf\u03c0\7"+
"\63\2\2\u03c0\u03c4\3\2\2\2\u03c1\u03c2\7\62\2\2\u03c2\u03c4\7\63\2\2"+
"\u03c3\u03bd\3\2\2\2\u03c3\u03c1\3\2\2\2\u03c4\u008b\3\2\2\2\u03c5\u03c6"+
"\79\2\2\u03c6\u03c7\5z>\2\u03c7\u03c8\bG\1\2\u03c8\u03df\3\2\2\2\u03c9"+
"\u03ca\79\2\2\u03ca\u03cb\5z>\2\u03cb\u03cc\5\u0096L\2\u03cc\u03cd\7:"+
"\2\2\u03cd\u03ce\5z>\2\u03ce\u03cf\bG\1\2\u03cf\u03df\3\2\2\2\u03d0\u03d1"+
"\79\2\2\u03d1\u03d2\5z>\2\u03d2\u03d3\5\u0096L\2\u03d3\u03d4\bG\1\2\u03d4"+
"\u03df\3\2\2\2\u03d5\u03d6\79\2\2\u03d6\u03d7\5z>\2\u03d7\u03d8\7:\2\2"+
"\u03d8\u03d9\5z>\2\u03d9\u03da\bG\1\2\u03da\u03df\3\2\2\2\u03db\u03dc"+
"\5\u008eH\2\u03dc\u03dd\bG\1\2\u03dd\u03df\3\2\2\2\u03de\u03c5\3\2\2\2"+
"\u03de\u03c9\3\2\2\2\u03de\u03d0\3\2\2\2\u03de\u03d5\3\2\2\2\u03de\u03db"+
"\3\2\2\2\u03df\u008d\3\2\2\2\u03e0\u03e1\79\2\2\u03e1\u03e2\5\u0090I\2"+
"\u03e2\u03e4\5z>\2\u03e3\u03e5\5\u0096L\2\u03e4\u03e3\3\2\2\2\u03e4\u03e5"+
"\3\2\2\2\u03e5\u03e8\3\2\2\2\u03e6\u03e7\7:\2\2\u03e7\u03e9\5z>\2\u03e8"+
"\u03e6\3\2\2\2\u03e8\u03e9\3\2\2\2\u03e9\u008f\3\2\2\2\u03ea\u03eb\7\26"+
"\2\2\u03eb\u03ed\5\u0092J\2\u03ec\u03ee\7\3\2\2\u03ed\u03ec\3\2\2\2\u03ed"+
"\u03ee\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f0\7\27\2\2\u03f0\u0091\3"+
"\2\2\2\u03f1\u03f6\5\u0094K\2\u03f2\u03f3\7\3\2\2\u03f3\u03f5\5\u0094"+
"K\2\u03f4\u03f2\3\2\2\2\u03f5\u03f8\3\2\2\2\u03f6\u03f4\3\2\2\2\u03f6"+
"\u03f7\3\2\2\2\u03f7\u0093\3\2\2\2\u03f8\u03f6\3\2\2\2\u03f9\u03fb\5\22"+
"\n\2\u03fa\u03f9\3\2\2\2\u03fa\u03fb\3\2\2\2\u03fb\u03fc\3\2\2\2\u03fc"+
"\u03fd\5F$\2\u03fd\u03fe\7d\2\2\u03fe\u03ff\7\34\2\2\u03ff\u0400\5\u00a8"+
"U\2\u0400\u0095\3\2\2\2\u0401\u0405\5\u0098M\2\u0402\u0404\5\u0098M\2"+
"\u0403\u0402\3\2\2\2\u0404\u0407\3\2\2\2\u0405\u0403\3\2\2\2\u0405\u0406"+
"\3\2\2\2\u0406\u0097\3\2\2\2\u0407\u0405\3\2\2\2\u0408\u0409\7?\2\2\u0409"+
"\u040a\7\26\2\2\u040a\u040b\5\u009aN\2\u040b\u040c\7\27\2\2\u040c\u040d"+
"\5z>\2\u040d\u0099\3\2\2\2\u040e\u040f\5\22\n\2\u040f\u0414\5F$\2\u0410"+
"\u0411\7P\2\2\u0411\u0413\5F$\2\u0412\u0410\3\2\2\2\u0413\u0416\3\2\2"+
"\2\u0414\u0412\3\2\2\2\u0414\u0415\3\2\2\2\u0415\u0417\3\2\2\2\u0416\u0414"+
"\3\2\2\2\u0417\u041c\7d\2\2\u0418\u0419\7\24\2\2\u0419\u041b\7\25\2\2"+
"\u041a\u0418\3\2\2\2\u041b\u041e\3\2\2\2\u041c\u041a\3\2\2\2\u041c\u041d"+
"\3\2\2\2\u041d\u009b\3\2\2\2\u041e\u041c\3\2\2\2\u041f\u0422\5\u009eP"+
"\2\u0420\u0422\5\u00a0Q\2\u0421\u041f\3\2\2\2\u0421\u0420\3\2\2\2\u0422"+
"\u009d\3\2\2\2\u0423\u0424\7\66\2\2\u0424\u0425\7\26\2\2\u0425\u0426\5"+
"\22\n\2\u0426\u0427\5F$\2\u0427\u0428\7d\2\2\u0428\u0429\7\63\2\2\u0429"+
"\u042a\5\u00a8U\2\u042a\u042b\7\27\2\2\u042b\u042c\5\u0082B\2\u042c\u009f"+
"\3\2\2\2\u042d\u042e\7\66\2\2\u042e\u0430\7\26\2\2\u042f\u0431\5\u00a2"+
"R\2\u0430\u042f\3\2\2\2\u0430\u0431\3\2\2\2\u0431\u0432\3\2\2\2\u0432"+
"\u0434\7\3\2\2\u0433\u0435\5\u00a8U\2\u0434\u0433\3\2\2\2\u0434\u0435"+
"\3\2\2\2\u0435\u0436\3\2\2\2\u0436\u0438\7\3\2\2\u0437\u0439\5\u00a6T"+
"\2\u0438\u0437\3\2\2\2\u0438\u0439\3\2\2\2\u0439\u043a\3\2\2\2\u043a\u043b"+
"\7\27\2\2\u043b\u043c\5\u0082B\2\u043c\u00a1\3\2\2\2\u043d\u0440\5\u0080"+
"A\2\u043e\u0440\5\u00a6T\2\u043f\u043d\3\2\2\2\u043f\u043e\3\2\2\2\u0440"+
"\u00a3\3\2\2\2\u0441\u0442\7\26\2\2\u0442\u0443\5\u00a8U\2\u0443\u0444"+
"\7\27\2\2\u0444\u00a5\3\2\2\2\u0445\u044a\5\u00a8U\2\u0446\u0447\7\21"+
"\2\2\u0447\u0449\5\u00a8U\2\u0448\u0446\3\2\2\2\u0449\u044c\3\2\2\2\u044a"+
"\u0448\3\2\2\2\u044a\u044b\3\2\2\2\u044b\u00a7\3\2\2\2\u044c\u044a\3\2"+
"\2\2\u044d\u0451\5\u00acW\2\u044e\u044f\5\u00aaV\2\u044f\u0450\5\u00a8"+
"U\2\u0450\u0452\3\2\2\2\u0451\u044e\3\2\2\2\u0451\u0452\3\2\2\2\u0452"+
"\u00a9\3\2\2\2\u0453\u0454\7\34\2\2\u0454\u0473\bV\1\2\u0455\u0456\7T"+
"\2\2\u0456\u0473\bV\1\2\u0457\u0458\7U\2\2\u0458\u0473\bV\1\2\u0459\u045a"+
"\7V\2\2\u045a\u0473\bV\1\2\u045b\u045c\7W\2\2\u045c\u0473\bV\1\2\u045d"+
"\u045e\7X\2\2\u045e\u0473\bV\1\2\u045f\u0460\7Y\2\2\u0460\u0473\bV\1\2"+
"\u0461\u0462\7S\2\2\u0462\u0473\bV\1\2\u0463\u0464\7Z\2\2\u0464\u0473"+
"\bV\1\2\u0465\u0466\7\\\2\2\u0466\u0467\7\\\2\2\u0467\u0468\7\34\2\2\u0468"+
"\u0473\bV\1\2\u0469\u046a\7[\2\2\u046a\u046b\7[\2\2\u046b\u046c\7[\2\2"+
"\u046c\u046d\7\34\2\2\u046d\u0473\bV\1\2\u046e\u046f\7[\2\2\u046f\u0470"+
"\7[\2\2\u0470\u0471\7\34\2\2\u0471\u0473\bV\1\2\u0472\u0453\3\2\2\2\u0472"+
"\u0455\3\2\2\2\u0472\u0457\3\2\2\2\u0472\u0459\3\2\2\2\u0472\u045b\3\2"+
"\2\2\u0472\u045d\3\2\2\2\u0472\u045f\3\2\2\2\u0472\u0461\3\2\2\2\u0472"+
"\u0463\3\2\2\2\u0472\u0465\3\2\2\2\u0472\u0469\3\2\2\2\u0472\u046e\3\2"+
"\2\2\u0473\u00ab\3\2\2\2\u0474\u047a\5\u00aeX\2\u0475\u0476\7)\2\2\u0476"+
"\u0477\5\u00a8U\2\u0477\u0478\7\63\2\2\u0478\u0479\5\u00acW\2\u0479\u047b"+
"\3\2\2\2\u047a\u0475\3\2\2\2\u047a\u047b\3\2\2\2\u047b\u00ad\3\2\2\2\u047c"+
"\u0481\5\u00b0Y\2\u047d\u047e\7R\2\2\u047e\u0480\5\u00b0Y\2\u047f\u047d"+
"\3\2\2\2\u0480\u0483\3\2\2\2\u0481\u047f\3\2\2\2\u0481\u0482\3\2\2\2\u0482"+
"\u00af\3\2\2\2\u0483\u0481\3\2\2\2\u0484\u0489\5\u00b2Z\2\u0485\u0486"+
"\7Q\2\2\u0486\u0488\5\u00b2Z\2\u0487\u0485\3\2\2\2\u0488\u048b\3\2\2\2"+
"\u0489\u0487\3\2\2\2\u0489\u048a\3\2\2\2\u048a\u00b1\3\2\2\2\u048b\u0489"+
"\3\2\2\2\u048c\u0491\5\u00b4[\2\u048d\u048e\7P\2\2\u048e\u0490\5\u00b4"+
"[\2\u048f\u048d\3\2\2\2\u0490\u0493\3\2\2\2\u0491\u048f\3\2\2\2\u0491"+
"\u0492\3\2\2\2\u0492\u00b3\3\2\2\2\u0493\u0491\3\2\2\2\u0494\u0499\5\u00b6"+
"\\\2\u0495\u0496\7O\2\2\u0496\u0498\5\u00b6\\\2\u0497\u0495\3\2\2\2\u0498"+
"\u049b\3\2\2\2\u0499\u0497\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u00b5\3\2"+
"\2\2\u049b\u0499\3\2\2\2\u049c\u04a1\5\u00b8]\2\u049d\u049e\7N\2\2\u049e"+
"\u04a0\5\u00b8]\2\u049f\u049d\3\2\2\2\u04a0\u04a3\3\2\2\2\u04a1\u049f"+
"\3\2\2\2\u04a1\u04a2\3\2\2\2\u04a2\u00b7\3\2\2\2\u04a3\u04a1\3\2\2\2\u04a4"+
"\u04a9\5\u00ba^\2\u04a5\u04a6\7L\2\2\u04a6\u04a8\5\u00ba^\2\u04a7\u04a5"+
"\3\2\2\2\u04a8\u04ab\3\2\2\2\u04a9\u04a7\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa"+
"\u00b9\3\2\2\2\u04ab\u04a9\3\2\2\2\u04ac\u04b1\5\u00bc_\2\u04ad\u04ae"+
"\7M\2\2\u04ae\u04b0\5\u00bc_\2\u04af\u04ad\3\2\2\2\u04b0\u04b3\3\2\2\2"+
"\u04b1\u04af\3\2\2\2\u04b1\u04b2\3\2\2\2\u04b2\u00bb\3\2\2\2\u04b3\u04b1"+
"\3\2\2\2\u04b4\u04b7\5\u00be`\2\u04b5\u04b6\7]\2\2\u04b6\u04b8\5F$\2\u04b7"+
"\u04b5\3\2\2\2\u04b7\u04b8\3\2\2\2\u04b8\u00bd\3\2\2\2\u04b9\u04bf\5\u00c2"+
"b\2\u04ba\u04bb\5\u00c0a\2\u04bb\u04bc\5\u00c2b\2\u04bc\u04be\3\2\2\2"+
"\u04bd\u04ba\3\2\2\2\u04be\u04c1\3\2\2\2\u04bf\u04bd\3\2\2\2\u04bf\u04c0"+
"\3\2\2\2\u04c0\u00bf\3\2\2\2\u04c1\u04bf\3\2\2\2\u04c2\u04c3\7\\\2\2\u04c3"+
"\u04c4\7\34\2\2\u04c4\u04cd\ba\1\2\u04c5\u04c6\7[\2\2\u04c6\u04c7\7\34"+
"\2\2\u04c7\u04cd\ba\1\2\u04c8\u04c9\7\\\2\2\u04c9\u04cd\ba\1\2\u04ca\u04cb"+
"\7[\2\2\u04cb\u04cd\ba\1\2\u04cc\u04c2\3\2\2\2\u04cc\u04c5\3\2\2\2\u04cc"+
"\u04c8\3\2\2\2\u04cc\u04ca\3\2\2\2\u04cd\u00c1\3\2\2\2\u04ce\u04d4\5\u00c6"+
"d\2\u04cf\u04d0\5\u00c4c\2\u04d0\u04d1\5\u00c6d\2\u04d1\u04d3\3\2\2\2"+
"\u04d2\u04cf\3\2\2\2\u04d3\u04d6\3\2\2\2\u04d4\u04d2\3\2\2\2\u04d4\u04d5"+
"\3\2\2\2\u04d5\u00c3\3\2\2\2\u04d6\u04d4\3\2\2\2\u04d7\u04d8\7\\\2\2\u04d8"+
"\u04d9\7\\\2\2\u04d9\u04e2\bc\1\2\u04da\u04db\7[\2\2\u04db\u04dc\7[\2"+
"\2\u04dc\u04dd\7[\2\2\u04dd\u04e2\bc\1\2\u04de\u04df\7[\2\2\u04df\u04e0"+
"\7[\2\2\u04e0\u04e2\bc\1\2\u04e1\u04d7\3\2\2\2\u04e1\u04da\3\2\2\2\u04e1"+
"\u04de\3\2\2\2\u04e2\u00c5\3\2\2\2\u04e3\u04e9\5\u00caf\2\u04e4\u04e5"+
"\5\u00c8e\2\u04e5\u04e6\5\u00caf\2\u04e6\u04e8\3\2\2\2\u04e7\u04e4\3\2"+
"\2\2\u04e8\u04eb\3\2\2\2\u04e9\u04e7\3\2\2\2\u04e9\u04ea\3\2\2\2\u04ea"+
"\u00c7\3\2\2\2\u04eb\u04e9\3\2\2\2\u04ec\u04ed\7J\2\2\u04ed\u04f1\be\1"+
"\2\u04ee\u04ef\7K\2\2\u04ef\u04f1\be\1\2\u04f0\u04ec\3\2\2\2\u04f0\u04ee"+
"\3\2\2\2\u04f1\u00c9\3\2\2\2\u04f2\u04f8\5\u00ceh\2\u04f3\u04f4\5\u00cc"+
"g\2\u04f4\u04f5\5\u00ceh\2\u04f5\u04f7\3\2\2\2\u04f6\u04f3\3\2\2\2\u04f7"+
"\u04fa\3\2\2\2\u04f8\u04f6\3\2\2\2\u04f8\u04f9\3\2\2\2\u04f9\u00cb\3\2"+
"\2\2\u04fa\u04f8\3\2\2\2\u04fb\u04fc\7\7\2\2\u04fc\u0502\bg\1\2\u04fd"+
"\u04fe\7H\2\2\u04fe\u0502\bg\1\2\u04ff\u0500\7I\2\2\u0500\u0502\bg\1\2"+
"\u0501\u04fb\3\2\2\2\u0501\u04fd\3\2\2\2\u0501\u04ff\3\2\2\2\u0502\u00cd"+
"\3\2\2\2\u0503\u0504\7J\2\2\u0504\u0511\5\u00ceh\2\u0505\u0506\7K\2\2"+
"\u0506\u0511\5\u00ceh\2\u0507\u0508\7C\2\2\u0508\u0511\5\u00ceh\2\u0509"+
"\u050a\7D\2\2\u050a\u0511\5\u00ceh\2\u050b\u050c\7E\2\2\u050c\u0511\5"+
"\u00ceh\2\u050d\u050e\7F\2\2\u050e\u0511\5\u00ceh\2\u050f\u0511\5\u00d0"+
"i\2\u0510\u0503\3\2\2\2\u0510\u0505\3\2\2\2\u0510\u0507\3\2\2\2\u0510"+
"\u0509\3\2\2\2\u0510\u050b\3\2\2\2\u0510\u050d\3\2\2\2\u0510\u050f\3\2"+
"\2\2\u0511\u00cf\3\2\2\2\u0512\u051e\5\u00d2j\2\u0513\u0517\5\u00d4k\2"+
"\u0514\u0516\5\u00dco\2\u0515\u0514\3\2\2\2\u0516\u0519\3\2\2\2\u0517"+
"\u0515\3\2\2\2\u0517\u0518\3\2\2\2\u0518\u051b\3\2\2\2\u0519\u0517\3\2"+
"\2\2\u051a\u051c\t\5\2\2\u051b\u051a\3\2\2\2\u051b\u051c\3\2\2\2\u051c"+
"\u051e\3\2\2\2\u051d\u0512\3\2\2\2\u051d\u0513\3\2\2\2\u051e\u00d1\3\2"+
"\2\2\u051f\u0520\7\26\2\2\u0520\u0521\5L\'\2\u0521\u0522\7\27\2\2\u0522"+
"\u0523\5\u00ceh\2\u0523\u052a\3\2\2\2\u0524\u0525\7\26\2\2\u0525\u0526"+
"\5F$\2\u0526\u0527\7\27\2\2\u0527\u0528\5\u00d0i\2\u0528\u052a\3\2\2\2"+
"\u0529\u051f\3\2\2\2\u0529\u0524\3\2\2\2\u052a\u00d3\3\2\2\2\u052b\u052c"+
"\5\u00a4S\2\u052c\u052d\bk\1\2\u052d\u0561\3\2\2\2\u052e\u0533\7,\2\2"+
"\u052f\u0530\7\6\2\2\u0530\u0532\7d\2\2\u0531\u052f\3\2\2\2\u0532\u0535"+
"\3\2\2\2\u0533\u0531\3\2\2\2\u0533\u0534\3\2\2\2\u0534\u0537\3\2\2\2\u0535"+
"\u0533\3\2\2\2\u0536\u0538\5\u00d8m\2\u0537\u0536\3\2\2\2\u0537\u0538"+
"\3\2\2\2\u0538\u0539\3\2\2\2\u0539\u0561\bk\1\2\u053a\u053f\7d\2\2\u053b"+
"\u053c\7\6\2\2\u053c\u053e\7d\2\2\u053d\u053b\3\2\2\2\u053e\u0541\3\2"+
"\2\2\u053f\u053d\3\2\2\2\u053f\u0540\3\2\2\2\u0540\u0543\3\2\2\2\u0541"+
"\u053f\3\2\2\2\u0542\u0544\5\u00dan\2\u0543\u0542\3\2\2\2\u0543\u0544"+
"\3\2\2\2\u0544\u0545\3\2\2\2\u0545\u0561\bk\1\2\u0546\u0547\7-\2\2\u0547"+
"\u0548\5\u00d6l\2\u0548\u0549\bk\1\2\u0549\u0561\3\2\2\2\u054a\u054b\5"+
"\u00f0y\2\u054b\u054c\bk\1\2\u054c\u0561\3\2\2\2\u054d\u054e\5\u00dep"+
"\2\u054e\u054f\bk\1\2\u054f\u0561\3\2\2\2\u0550\u0555\5L\'\2\u0551\u0552"+
"\7\24\2\2\u0552\u0554\7\25\2\2\u0553\u0551\3\2\2\2\u0554\u0557\3\2\2\2"+
"\u0555\u0553\3\2\2\2\u0555\u0556\3\2\2\2\u0556\u0558\3\2\2\2\u0557\u0555"+
"\3\2\2\2\u0558\u0559\7\6\2\2\u0559\u055a\7\b\2\2\u055a\u055b\bk\1\2\u055b"+
"\u0561\3\2\2\2\u055c\u055d\7\30\2\2\u055d\u055e\7\6\2\2\u055e\u055f\7"+
"\b\2\2\u055f\u0561\bk\1\2\u0560\u052b\3\2\2\2\u0560\u052e\3\2\2\2\u0560"+
"\u053a\3\2\2\2\u0560\u0546\3\2\2\2\u0560\u054a\3\2\2\2\u0560\u054d\3\2"+
"\2\2\u0560\u0550\3\2\2\2\u0560\u055c\3\2\2\2\u0561\u00d5\3\2\2\2\u0562"+
"\u0564\7\6\2\2\u0563\u0565\5N(\2\u0564\u0563\3\2\2\2\u0564\u0565\3\2\2"+
"\2\u0565\u0566\3\2\2\2\u0566\u0568\7d\2\2\u0567\u0569\5\u00eex\2\u0568"+
"\u0567\3\2\2\2\u0568\u0569\3\2\2\2\u0569\u00d7\3\2\2\2\u056a\u056b\7\24"+
"\2\2\u056b\u056c\5\u00a8U\2\u056c\u056d\7\25\2\2\u056d\u056f\3\2\2\2\u056e"+
"\u056a\3\2\2\2\u056f\u0570\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u0571\3\2"+
"\2\2\u0571\u0572\3\2\2\2\u0572\u0573\bm\1\2\u0573\u0581\3\2\2\2\u0574"+
"\u0575\5\u00eex\2\u0575\u0576\bm\1\2\u0576\u0581\3\2\2\2\u0577\u0578\7"+
"\6\2\2\u0578\u0579\5\u00ecw\2\u0579\u057a\7d\2\2\u057a\u057b\5\u00eex"+
"\2\u057b\u057c\bm\1\2\u057c\u0581\3\2\2\2\u057d\u057e\5\u00e8u\2\u057e"+
"\u057f\bm\1\2\u057f\u0581\3\2\2\2\u0580\u056e\3\2\2\2\u0580\u0574\3\2"+
"\2\2\u0580\u0577\3\2\2\2\u0580\u057d\3\2\2\2\u0581\u00d9\3\2\2\2\u0582"+
"\u0583\7\24\2\2\u0583\u0585\7\25\2\2\u0584\u0582\3\2\2\2\u0585\u0586\3"+
"\2\2\2\u0586\u0584\3\2\2\2\u0586\u0587\3\2\2\2\u0587\u0588\3\2\2\2\u0588"+
"\u0589\7\6\2\2\u0589\u058a\7\b\2\2\u058a\u05a8\bn\1\2\u058b\u058c\7\24"+
"\2\2\u058c\u058d\5\u00a8U\2\u058d\u058e\7\25\2\2\u058e\u0590\3\2\2\2\u058f"+
"\u058b\3\2\2\2\u0590\u0591\3\2\2\2\u0591\u058f\3\2\2\2\u0591\u0592\3\2"+
"\2\2\u0592\u0593\3\2\2\2\u0593\u0594\bn\1\2\u0594\u05a8\3\2\2\2\u0595"+
"\u0596\5\u00eex\2\u0596\u0597\bn\1\2\u0597\u05a8\3\2\2\2\u0598\u0599\7"+
"\6\2\2\u0599\u059a\7\b\2\2\u059a\u05a8\bn\1\2\u059b\u059c\7\6\2\2\u059c"+
"\u059d\5\u00ecw\2\u059d\u059e\7d\2\2\u059e\u059f\5\u00eex\2\u059f\u05a0"+
"\bn\1\2\u05a0\u05a8\3\2\2\2\u05a1\u05a2\7\6\2\2\u05a2\u05a3\7,\2\2\u05a3"+
"\u05a8\bn\1\2\u05a4\u05a5\5\u00e8u\2\u05a5\u05a6\bn\1\2\u05a6\u05a8\3"+
"\2\2\2\u05a7\u0584\3\2\2\2\u05a7\u058f\3\2\2\2\u05a7\u0595\3\2\2\2\u05a7"+
"\u0598\3\2\2\2\u05a7\u059b\3\2\2\2\u05a7\u05a1\3\2\2\2\u05a7\u05a4\3\2"+
"\2\2\u05a8\u00db\3\2\2\2\u05a9\u05aa\7\6\2\2\u05aa\u05ac\7d\2\2\u05ab"+
"\u05ad\5\u00eex\2\u05ac\u05ab\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad\u05ae"+
"\3\2\2\2\u05ae\u05c0\bo\1\2\u05af\u05b0\7\6\2\2\u05b0\u05b1\7,\2\2\u05b1"+
"\u05c0\bo\1\2\u05b2\u05b3\7\6\2\2\u05b3\u05b4\7-\2\2\u05b4\u05b5\5\u00d6"+
"l\2\u05b5\u05b6\bo\1\2\u05b6\u05c0\3\2\2\2\u05b7\u05b8\5\u00e8u\2\u05b8"+
"\u05b9\bo\1\2\u05b9\u05c0\3\2\2\2\u05ba\u05bb\7\24\2\2\u05bb\u05bc\5\u00a8"+
"U\2\u05bc\u05bd\7\25\2\2\u05bd\u05be\bo\1\2\u05be\u05c0\3\2\2\2\u05bf"+
"\u05a9\3\2\2\2\u05bf\u05af\3\2\2\2\u05bf\u05b2\3\2\2\2\u05bf\u05b7\3\2"+
"\2\2\u05bf\u05ba\3\2\2\2\u05c0\u00dd\3\2\2\2\u05c1\u05c2\7G\2\2\u05c2"+
"\u05c3\5\u00ecw\2\u05c3\u05c4\5H%\2\u05c4\u05c5\5\u00eav\2\u05c5\u05cc"+
"\3\2\2\2\u05c6\u05c7\7G\2\2\u05c7\u05c8\5H%\2\u05c8\u05c9\5\u00eav\2\u05c9"+
"\u05cc\3\2\2\2\u05ca\u05cc\5\u00e0q\2\u05cb\u05c1\3\2\2\2\u05cb\u05c6"+
"\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u00df\3\2\2\2\u05cd\u05ce\7G\2\2\u05ce"+
"\u05cf\5\u00e6t\2\u05cf\u05d0\7\24\2\2\u05d0\u05d5\7\25\2\2\u05d1\u05d2"+
"\7\24\2\2\u05d2\u05d4\7\25\2\2\u05d3\u05d1\3\2\2\2\u05d4\u05d7\3\2\2\2"+
"\u05d5\u05d3\3\2\2\2\u05d5\u05d6\3\2\2\2\u05d6\u05d8\3\2\2\2\u05d7\u05d5"+
"\3\2\2\2\u05d8\u05d9\5\u00e4s\2\u05d9\u05f0\3\2\2\2\u05da\u05db\7G\2\2"+
"\u05db\u05dc\5\u00e6t\2\u05dc\u05dd\7\24\2\2\u05dd\u05de\5\u00a8U\2\u05de"+
"\u05e5\7\25\2\2\u05df\u05e0\7\24\2\2\u05e0\u05e1\5\u00a8U\2\u05e1\u05e2"+
"\7\25\2\2\u05e2\u05e4\3\2\2\2\u05e3\u05df\3\2\2\2\u05e4\u05e7\3\2\2\2"+
"\u05e5\u05e3\3\2\2\2\u05e5\u05e6\3\2\2\2\u05e6\u05ec\3\2\2\2\u05e7\u05e5"+
"\3\2\2\2\u05e8\u05e9\7\24\2\2\u05e9\u05eb\7\25\2\2\u05ea\u05e8\3\2\2\2"+
"\u05eb\u05ee\3\2\2\2\u05ec\u05ea\3\2\2\2\u05ec\u05ed\3\2\2\2\u05ed\u05f0"+
"\3\2\2\2\u05ee\u05ec\3\2\2\2\u05ef\u05cd\3\2\2\2\u05ef\u05da\3\2\2\2\u05f0"+
"\u00e1\3\2\2\2\u05f1\u05f4\5\u00e4s\2\u05f2\u05f4\5\u00a8U\2\u05f3\u05f1"+
"\3\2\2\2\u05f3\u05f2\3\2\2\2\u05f4\u00e3\3\2\2\2\u05f5\u05fe\7\22\2\2"+
"\u05f6\u05fb\5\u00e2r\2\u05f7\u05f8\7\21\2\2\u05f8\u05fa\5\u00e2r\2\u05f9"+
"\u05f7\3\2\2\2\u05fa\u05fd\3\2\2\2\u05fb\u05f9\3\2\2\2\u05fb\u05fc\3\2"+
"\2\2\u05fc\u05ff\3\2\2\2\u05fd\u05fb\3\2\2\2\u05fe\u05f6\3\2\2\2\u05fe"+
"\u05ff\3\2\2\2\u05ff\u0601\3\2\2\2\u0600\u0602\7\21\2\2\u0601\u0600\3"+
"\2\2\2\u0601\u0602\3\2\2\2\u0602\u0603\3\2\2\2\u0603\u0604\7\23\2\2\u0604"+
"\u00e5\3\2\2\2\u0605\u0608\5H%\2\u0606\u0608\5L\'\2\u0607\u0605\3\2\2"+
"\2\u0607\u0606\3\2\2\2\u0608\u00e7\3\2\2\2\u0609\u060a\7\6\2\2\u060a\u060c"+
"\7G\2\2\u060b\u060d\5\u00ecw\2\u060c\u060b\3\2\2\2\u060c\u060d\3\2\2\2"+
"\u060d\u060e\3\2\2\2\u060e\u060f\5J&\2\u060f\u0610\5\u00eav\2\u0610\u00e9"+
"\3\2\2\2\u0611\u0613\5\u00eex\2\u0612\u0614\5.\30\2\u0613\u0612\3\2\2"+
"\2\u0613\u0614\3\2\2\2\u0614\u00eb\3\2\2\2\u0615\u0616\7\\\2\2\u0616\u0617"+
"\5,\27\2\u0617\u0618\7[\2\2\u0618\u00ed\3\2\2\2\u0619\u061b\7\26\2\2\u061a"+
"\u061c\5\u00a6T\2\u061b\u061a\3\2\2\2\u061b\u061c\3\2\2\2\u061c\u061d"+
"\3\2\2\2\u061d\u061e\7\27\2\2\u061e\u00ef\3\2\2\2\u061f\u0620\t\6\2\2"+
"\u0620\u00f1\3\2\2\2\u0621\u0622\5\16\b\2\u0622\u0623\7\b\2\2\u0623\u0624"+
"\7d\2\2\u0624\u00f3\3\2\2\2\u0625\u0626\5\16\b\2\u0626\u0627\t\7\2\2\u0627"+
"\u0628\7d\2\2\u0628\u00f5\3\2\2\2\u0629\u062a\5\16\b\2\u062a\u062b\7\31"+
"\2\2\u062b\u062c\7d\2\2\u062c\u00f7\3\2\2\2\u062d\u062e\5\16\b\2\u062e"+
"\u062f\7\61\2\2\u062f\u0630\7\31\2\2\u0630\u0631\7d\2\2\u0631\u00f9\3"+
"\2\2\2\u0632\u0639\5\16\b\2\u0633\u063a\7\b\2\2\u0634\u063a\7A\2\2\u0635"+
"\u0637\7\61\2\2\u0636\u0635\3\2\2\2\u0636\u0637\3\2\2\2\u0637\u0638\3"+
"\2\2\2\u0638\u063a\7\31\2\2\u0639\u0633\3\2\2\2\u0639\u0634\3\2\2\2\u0639"+
"\u0636\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063c\7d\2\2\u063c\u00fb\3\2"+
"\2\2\u063d\u063f\5\16\b\2\u063e\u0640\5\30\r\2\u063f\u063e\3\2\2\2\u063f"+
"\u0640\3\2\2\2\u0640\u0643\3\2\2\2\u0641\u0644\5F$\2\u0642\u0644\7\30"+
"\2\2\u0643\u0641\3\2\2\2\u0643\u0642\3\2\2\2\u0643\u0644\3\2\2\2\u0644"+
"\u0645\3\2\2\2\u0645\u0646\7d\2\2\u0646\u0647\7\27\2\2\u0647\u00fd\3\2"+
"\2\2\u0648\u0649\5\16\b\2\u0649\u064a\5F$\2\u064a\u064f\7d\2\2\u064b\u064c"+
"\7\24\2\2\u064c\u064e\7\25\2\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\u0652\3\2\2\2\u0651\u064f"+
"\3\2\2\2\u0652\u0653\t\b\2\2\u0653\u00ff\3\2\2\2\u0654\u0655\5\22\n\2"+
"\u0655\u0656\5F$\2\u0656\u065b\7d\2\2\u0657\u0658\7\24\2\2\u0658\u065a"+
"\7\25\2\2\u0659\u0657\3\2\2\2\u065a\u065d\3\2\2\2\u065b\u0659\3\2\2\2"+
"\u065b\u065c\3\2\2\2\u065c\u065e\3\2\2\2\u065d\u065b\3\2\2\2\u065e\u065f"+
"\t\t\2\2\u065f\u0101\3\2\2\2\u00b1\u0103\u0108\u010e\u0112\u011a\u0122"+
"\u0129\u012d\u0130\u0137\u013c\u0140\u0145\u0154\u0159\u015d\u0162\u0167"+
"\u016d\u0171\u0175\u017f\u0187\u018e\u0196\u019c\u019f\u01a2\u01ab\u01af"+
"\u01b3\u01b6\u01bc\u01c1\u01c7\u01cb\u01d4\u01db\u01e4\u01eb\u01ef\u01f6"+
"\u01fa\u01fe\u0206\u020b\u020f\u0213\u0219\u021f\u0224\u0230\u023a\u023f"+
"\u0246\u024a\u024e\u0256\u025b\u0266\u0270\u0278\u027b\u0282\u0287\u0291"+
"\u0298\u029e\u02a0\u02a7\u02ac\u02b8\u02c2\u02c7\u02d0\u02d9\u02e2\u02e8"+
"\u02ef\u02f5\u02fa\u0309\u0312\u031c\u0324\u0327\u032a\u0338\u0344\u034d"+
"\u0355\u035d\u0369\u0371\u037a\u0394\u039d\u03a2\u03ac\u03b3\u03ba\u03c3"+
"\u03de\u03e4\u03e8\u03ed\u03f6\u03fa\u0405\u0414\u041c\u0421\u0430\u0434"+
"\u0438\u043f\u044a\u0451\u0472\u047a\u0481\u0489\u0491\u0499\u04a1\u04a9"+
"\u04b1\u04b7\u04bf\u04cc\u04d4\u04e1\u04e9\u04f0\u04f8\u0501\u0510\u0517"+
"\u051b\u051d\u0529\u0533\u0537\u053f\u0543\u0555\u0560\u0564\u0568\u0570"+
"\u0580\u0586\u0591\u05a7\u05ac\u05bf\u05cb\u05d5\u05e5\u05ec\u05ef\u05f3"+
"\u05fb\u05fe\u0601\u0607\u060c\u0613\u061b\u0636\u0639\u063f\u0643\u064f"+
"\u065b";
public static final ATN _ATN =
ATNSimulator.deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy