gdx-studio

package gdxstudio.parser;

// Generated from Java.g4 by ANTLR 4.2

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 JavaParser extends Parser {

	protected static final DFA[] _decisionToDFA;

	protected static final PredictionContextCache _sharedContextCache =

		new PredictionContextCache();

	public static final int

		ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, 

		CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, 

		ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, 

		IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, 

		NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, 

		SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, 

		THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, 

		WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, 

		CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, 

		LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, 

		ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, 

		LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, 

		MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ADD_ASSIGN=89, 

		SUB_ASSIGN=90, MUL_ASSIGN=91, DIV_ASSIGN=92, AND_ASSIGN=93, OR_ASSIGN=94, 

		XOR_ASSIGN=95, MOD_ASSIGN=96, LSHIFT_ASSIGN=97, RSHIFT_ASSIGN=98, URSHIFT_ASSIGN=99, 

		Identifier=100, AT=101, ELLIPSIS=102, WS=103, COMMENT=104, LINE_COMMENT=105;

	public static final String[] tokenNames = {

		"<INVALID>", "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", 

		"'case'", "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", 

		"'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", 

		"'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", 

		"'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", 

		"'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", 

		"'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", 

		"'transient'", "'try'", "'void'", "'volatile'", "'while'", "IntegerLiteral", 

		"FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", 

		"'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", "';'", "','", "'.'", 

		"'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", "'=='", "'<='", "'>='", 

		"'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", "'-'", "'*'", "'/'", "'&'", 

		"'|'", "'^'", "'%'", "'+='", "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", 

		"'%='", "'<<='", "'>>='", "'>>>='", "Identifier", "'@'", "'...'", "WS", 

		"COMMENT", "LINE_COMMENT"

	};

	public static final int

		RULE_compilationUnit = 0, RULE_packageDeclaration = 1, RULE_importDeclaration = 2, 

		RULE_typeDeclaration = 3, RULE_modifier = 4, RULE_classOrInterfaceModifier = 5, 

		RULE_variableModifier = 6, RULE_classDeclaration = 7, RULE_typeParameters = 8, 

		RULE_typeParameter = 9, RULE_typeBound = 10, RULE_enumDeclaration = 11, 

		RULE_enumConstants = 12, RULE_enumConstant = 13, RULE_enumBodyDeclarations = 14, 

		RULE_interfaceDeclaration = 15, RULE_typeList = 16, RULE_classBody = 17, 

		RULE_interfaceBody = 18, RULE_classBodyDeclaration = 19, RULE_memberDeclaration = 20, 

		RULE_methodDeclaration = 21, RULE_genericMethodDeclaration = 22, RULE_constructorDeclaration = 23, 

		RULE_genericConstructorDeclaration = 24, RULE_fieldDeclaration = 25, RULE_interfaceBodyDeclaration = 26, 

		RULE_interfaceMemberDeclaration = 27, RULE_constDeclaration = 28, RULE_constantDeclarator = 29, 

		RULE_interfaceMethodDeclaration = 30, RULE_genericInterfaceMethodDeclaration = 31, 

		RULE_variableDeclarators = 32, RULE_variableDeclarator = 33, RULE_variableDeclaratorId = 34, 

		RULE_variableInitializer = 35, RULE_arrayInitializer = 36, RULE_enumConstantName = 37, 

		RULE_type = 38, RULE_classOrInterfaceType = 39, RULE_primitiveType = 40, 

		RULE_typeArguments = 41, RULE_typeArgument = 42, RULE_qualifiedNameList = 43, 

		RULE_formalParameters = 44, RULE_formalParameterList = 45, RULE_formalParameter = 46, 

		RULE_lastFormalParameter = 47, RULE_methodBody = 48, RULE_constructorBody = 49, 

		RULE_qualifiedName = 50, RULE_literal = 51, RULE_annotation = 52, RULE_annotationName = 53, 

		RULE_elementValuePairs = 54, RULE_elementValuePair = 55, RULE_elementValue = 56, 

		RULE_elementValueArrayInitializer = 57, RULE_annotationTypeDeclaration = 58, 

		RULE_annotationTypeBody = 59, RULE_annotationTypeElementDeclaration = 60, 

		RULE_annotationTypeElementRest = 61, RULE_annotationMethodOrConstantRest = 62, 

		RULE_annotationMethodRest = 63, RULE_annotationConstantRest = 64, RULE_defaultValue = 65, 

		RULE_block = 66, RULE_blockStatement = 67, RULE_localVariableDeclarationStatement = 68, 

		RULE_localVariableDeclaration = 69, RULE_statement = 70, RULE_catchClause = 71, 

		RULE_catchType = 72, RULE_finallyBlock = 73, RULE_resourceSpecification = 74, 

		RULE_resources = 75, RULE_resource = 76, RULE_switchBlockStatementGroup = 77, 

		RULE_switchLabel = 78, RULE_forControl = 79, RULE_forInit = 80, RULE_enhancedForControl = 81, 

		RULE_forUpdate = 82, RULE_parExpression = 83, RULE_expressionList = 84, 

		RULE_statementExpression = 85, RULE_constantExpression = 86, RULE_expression = 87, 

		RULE_primary = 88, RULE_creator = 89, RULE_createdName = 90, RULE_innerCreator = 91, 

		RULE_arrayCreatorRest = 92, RULE_classCreatorRest = 93, RULE_explicitGenericInvocation = 94, 

		RULE_nonWildcardTypeArguments = 95, RULE_typeArgumentsOrDiamond = 96, 

		RULE_nonWildcardTypeArgumentsOrDiamond = 97, RULE_superSuffix = 98, RULE_explicitGenericInvocationSuffix = 99, 

		RULE_arguments = 100;

	public static final String[] ruleNames = {

		"compilationUnit", "packageDeclaration", "importDeclaration", "typeDeclaration", 

		"modifier", "classOrInterfaceModifier", "variableModifier", "classDeclaration", 

		"typeParameters", "typeParameter", "typeBound", "enumDeclaration", "enumConstants", 

		"enumConstant", "enumBodyDeclarations", "interfaceDeclaration", "typeList", 

		"classBody", "interfaceBody", "classBodyDeclaration", "memberDeclaration", 

		"methodDeclaration", "genericMethodDeclaration", "constructorDeclaration", 

		"genericConstructorDeclaration", "fieldDeclaration", "interfaceBodyDeclaration", 

		"interfaceMemberDeclaration", "constDeclaration", "constantDeclarator", 

		"interfaceMethodDeclaration", "genericInterfaceMethodDeclaration", "variableDeclarators", 

		"variableDeclarator", "variableDeclaratorId", "variableInitializer", "arrayInitializer", 

		"enumConstantName", "type", "classOrInterfaceType", "primitiveType", "typeArguments", 

		"typeArgument", "qualifiedNameList", "formalParameters", "formalParameterList", 

		"formalParameter", "lastFormalParameter", "methodBody", "constructorBody", 

		"qualifiedName", "literal", "annotation", "annotationName", "elementValuePairs", 

		"elementValuePair", "elementValue", "elementValueArrayInitializer", "annotationTypeDeclaration", 

		"annotationTypeBody", "annotationTypeElementDeclaration", "annotationTypeElementRest", 

		"annotationMethodOrConstantRest", "annotationMethodRest", "annotationConstantRest", 

		"defaultValue", "block", "blockStatement", "localVariableDeclarationStatement", 

		"localVariableDeclaration", "statement", "catchClause", "catchType", "finallyBlock", 

		"resourceSpecification", "resources", "resource", "switchBlockStatementGroup", 

		"switchLabel", "forControl", "forInit", "enhancedForControl", "forUpdate", 

		"parExpression", "expressionList", "statementExpression", "constantExpression", 

		"expression", "primary", "creator", "createdName", "innerCreator", "arrayCreatorRest", 

		"classCreatorRest", "explicitGenericInvocation", "nonWildcardTypeArguments", 

		"typeArgumentsOrDiamond", "nonWildcardTypeArgumentsOrDiamond", "superSuffix", 

		"explicitGenericInvocationSuffix", "arguments"

	};

	@Override

	public String getGrammarFileName() { return "Java.g4"; }

	@Override

	public String[] getTokenNames() { return tokenNames; }

	@Override

	public String[] getRuleNames() { return ruleNames; }

	@Override

	public String getSerializedATN() { return _serializedATN; }

	@Override

	public ATN getATN() { return _ATN; }

	public JavaParser(TokenStream input) {

		super(input);

		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);

	}

	public static class CompilationUnitContext extends ParserRuleContext {

		public List<ImportDeclarationContext> importDeclaration() {

			return getRuleContexts(ImportDeclarationContext.class);

		}

		public TerminalNode EOF() { return getToken(JavaParser.EOF, 0); }

		public PackageDeclarationContext packageDeclaration() {

			return getRuleContext(PackageDeclarationContext.class,0);

		}

		public ImportDeclarationContext importDeclaration(int i) {

			return getRuleContext(ImportDeclarationContext.class,i);

		}

		public List<TypeDeclarationContext> typeDeclaration() {

			return getRuleContexts(TypeDeclarationContext.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 JavaListener ) ((JavaListener)listener).enterCompilationUnit(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)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(203);

			switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {

			case 1:

				{

				setState(202); packageDeclaration();

				}

				break;

			}

			setState(208);

			_errHandler.sync(this);

			_la = _input.LA(1);

			while (_la==IMPORT) {

				{

				{

				setState(205); importDeclaration();

				}

				}

				setState(210);

				_errHandler.sync(this);

				_la = _input.LA(1);

			}

			setState(214);

			_errHandler.sync(this);

			_la = _input.LA(1);

			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SEMI))) != 0) || _la==AT) {

				{

				{

				setState(211); typeDeclaration();

				}

				}

				setState(216);

				_errHandler.sync(this);

				_la = _input.LA(1);

			}

			setState(217); match(EOF);

			}

		}

		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 AnnotationContext annotation(int i) {

			return getRuleContext(AnnotationContext.class,i);

		}

		public QualifiedNameContext qualifiedName() {

			return getRuleContext(QualifiedNameContext.class,0);

		}

		public List<AnnotationContext> annotation() {

			return getRuleContexts(AnnotationContext.class);

		}

		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 JavaListener ) ((JavaListener)listener).enterPackageDeclaration(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)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(222);

			_errHandler.sync(this);

			_la = _input.LA(1);

			while (_la==AT) {

				{

				{

				setState(219); annotation();

				}

				}

				setState(224);

				_errHandler.sync(this);

				_la = _input.LA(1);

			}

			setState(225); match(PACKAGE);

			setState(226); qualifiedName();

			setState(227); 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 QualifiedNameContext qualifiedName() {

			return getRuleContext(QualifiedNameContext.class,0);

		}

		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 JavaListener ) ((JavaListener)listener).enterImportDeclaration(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitImportDeclaration(this);

		}

	}

	public final ImportDeclarationContext importDeclaration() throws RecognitionException {

		ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());

		enterRule(_localctx, 4, RULE_importDeclaration);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{

			setState(229); match(IMPORT);

			setState(231);

			_la = _input.LA(1);

			if (_la==STATIC) {

				{

				setState(230); match(STATIC);

				}

			}

			setState(233); qualifiedName();

			setState(236);

			_la = _input.LA(1);

			if (_la==DOT) {

				{

				setState(234); match(DOT);

				setState(235); match(MUL);

				}

			}

			setState(238); match(SEMI);

			}

		}

		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 InterfaceDeclarationContext interfaceDeclaration() {

			return getRuleContext(InterfaceDeclarationContext.class,0);

		}

		public AnnotationTypeDeclarationContext annotationTypeDeclaration() {

			return getRuleContext(AnnotationTypeDeclarationContext.class,0);

		}

		public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) {

			return getRuleContext(ClassOrInterfaceModifierContext.class,i);

		}

		public EnumDeclarationContext enumDeclaration() {

			return getRuleContext(EnumDeclarationContext.class,0);

		}

		public List<ClassOrInterfaceModifierContext> classOrInterfaceModifier() {

			return getRuleContexts(ClassOrInterfaceModifierContext.class);

		}

		public ClassDeclarationContext classDeclaration() {

			return getRuleContext(ClassDeclarationContext.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 JavaListener ) ((JavaListener)listener).enterTypeDeclaration(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeDeclaration(this);

		}

	}

	public final TypeDeclarationContext typeDeclaration() throws RecognitionException {

		TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());

		enterRule(_localctx, 6, RULE_typeDeclaration);

		int _la;

		try {

			int _alt;

			setState(269);

			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {

			case 1:

				enterOuterAlt(_localctx, 1);

				{

				setState(243);

				_errHandler.sync(this);

				_la = _input.LA(1);

				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {

					{

					{

					setState(240); classOrInterfaceModifier();

					}

					}

					setState(245);

					_errHandler.sync(this);

					_la = _input.LA(1);

				}

				setState(246); classDeclaration();

				}

				break;

			case 2:

				enterOuterAlt(_localctx, 2);

				{

				setState(250);

				_errHandler.sync(this);

				_la = _input.LA(1);

				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {

					{

					{

					setState(247); classOrInterfaceModifier();

					}

					}

					setState(252);

					_errHandler.sync(this);

					_la = _input.LA(1);

				}

				setState(253); enumDeclaration();

				}

				break;

			case 3:

				enterOuterAlt(_localctx, 3);

				{

				setState(257);

				_errHandler.sync(this);

				_la = _input.LA(1);

				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {

					{

					{

					setState(254); classOrInterfaceModifier();

					}

					}

					setState(259);

					_errHandler.sync(this);

					_la = _input.LA(1);

				}

				setState(260); interfaceDeclaration();

				}

				break;

			case 4:

				enterOuterAlt(_localctx, 4);

				{

				setState(264);

				_errHandler.sync(this);

				_alt = getInterpreter().adaptivePredict(_input,9,_ctx);

				while ( _alt!=2 && _alt!=-1 ) {

					if ( _alt==1 ) {

						{

						{

						setState(261); classOrInterfaceModifier();

						}

						} 

					}

					setState(266);

					_errHandler.sync(this);

					_alt = getInterpreter().adaptivePredict(_input,9,_ctx);

				}

				setState(267); annotationTypeDeclaration();

				}

				break;

			case 5:

				enterOuterAlt(_localctx, 5);

				{

				setState(268); match(SEMI);

				}

				break;

			}

		}

		catch (RecognitionException re) {

			_localctx.exception = re;

			_errHandler.reportError(this, re);

			_errHandler.recover(this, re);

		}

		finally {

			exitRule();

		}

		return _localctx;

	}

	public static class ModifierContext extends ParserRuleContext {

		public ClassOrInterfaceModifierContext classOrInterfaceModifier() {

			return getRuleContext(ClassOrInterfaceModifierContext.class,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 JavaListener ) ((JavaListener)listener).enterModifier(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitModifier(this);

		}

	}

	public final ModifierContext modifier() throws RecognitionException {

		ModifierContext _localctx = new ModifierContext(_ctx, getState());

		enterRule(_localctx, 8, RULE_modifier);

		int _la;

		try {

			setState(273);

			switch (_input.LA(1)) {

			case ABSTRACT:

			case FINAL:

			case PRIVATE:

			case PROTECTED:

			case PUBLIC:

			case STATIC:

			case STRICTFP:

			case AT:

				enterOuterAlt(_localctx, 1);

				{

				setState(271); classOrInterfaceModifier();

				}

				break;

			case NATIVE:

			case SYNCHRONIZED:

			case TRANSIENT:

			case VOLATILE:

				enterOuterAlt(_localctx, 2);

				{

				setState(272);

				_la = _input.LA(1);

				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NATIVE) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE))) != 0)) ) {

				_errHandler.recoverInline(this);

				}

				consume();

				}

				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 ClassOrInterfaceModifierContext extends ParserRuleContext {

		public AnnotationContext annotation() {

			return getRuleContext(AnnotationContext.class,0);

		}

		public ClassOrInterfaceModifierContext(ParserRuleContext parent, int invokingState) {

			super(parent, invokingState);

		}

		@Override public int getRuleIndex() { return RULE_classOrInterfaceModifier; }

		@Override

		public void enterRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).enterClassOrInterfaceModifier(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitClassOrInterfaceModifier(this);

		}

	}

	public final ClassOrInterfaceModifierContext classOrInterfaceModifier() throws RecognitionException {

		ClassOrInterfaceModifierContext _localctx = new ClassOrInterfaceModifierContext(_ctx, getState());

		enterRule(_localctx, 10, RULE_classOrInterfaceModifier);

		int _la;

		try {

			setState(277);

			switch (_input.LA(1)) {

			case AT:

				enterOuterAlt(_localctx, 1);

				{

				setState(275); annotation();

				}

				break;

			case ABSTRACT:

			case FINAL:

			case PRIVATE:

			case PROTECTED:

			case PUBLIC:

			case STATIC:

			case STRICTFP:

				enterOuterAlt(_localctx, 2);

				{

				setState(276);

				_la = _input.LA(1);

				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0)) ) {

				_errHandler.recoverInline(this);

				}

				consume();

				}

				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 VariableModifierContext extends ParserRuleContext {

		public AnnotationContext annotation() {

			return getRuleContext(AnnotationContext.class,0);

		}

		public VariableModifierContext(ParserRuleContext parent, int invokingState) {

			super(parent, invokingState);

		}

		@Override public int getRuleIndex() { return RULE_variableModifier; }

		@Override

		public void enterRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).enterVariableModifier(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitVariableModifier(this);

		}

	}

	public final VariableModifierContext variableModifier() throws RecognitionException {

		VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());

		enterRule(_localctx, 12, RULE_variableModifier);

		try {

			setState(281);

			switch (_input.LA(1)) {

			case FINAL:

				enterOuterAlt(_localctx, 1);

				{

				setState(279); match(FINAL);

				}

				break;

			case AT:

				enterOuterAlt(_localctx, 2);

				{

				setState(280); annotation();

				}

				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 ClassDeclarationContext extends ParserRuleContext {

		public TypeParametersContext typeParameters() {

			return getRuleContext(TypeParametersContext.class,0);

		}

		public ClassBodyContext classBody() {

			return getRuleContext(ClassBodyContext.class,0);

		}

		public TypeListContext typeList() {

			return getRuleContext(TypeListContext.class,0);

		}

		public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); }

		public TypeContext type() {

			return getRuleContext(TypeContext.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 JavaListener ) ((JavaListener)listener).enterClassDeclaration(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitClassDeclaration(this);

		}

	}

	public final ClassDeclarationContext classDeclaration() throws RecognitionException {

		ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());

		enterRule(_localctx, 14, RULE_classDeclaration);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{

			setState(283); match(CLASS);

			setState(284); match(Identifier);

			setState(286);

			_la = _input.LA(1);

			if (_la==LT) {

				{

				setState(285); typeParameters();

				}

			}

			setState(290);

			_la = _input.LA(1);

			if (_la==EXTENDS) {

				{

				setState(288); match(EXTENDS);

				setState(289); type();

				}

			}

			setState(294);

			_la = _input.LA(1);

			if (_la==IMPLEMENTS) {

				{

				setState(292); match(IMPLEMENTS);

				setState(293); typeList();

				}

			}

			setState(296); 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<TypeParameterContext> typeParameter() {

			return getRuleContexts(TypeParameterContext.class);

		}

		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 JavaListener ) ((JavaListener)listener).enterTypeParameters(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeParameters(this);

		}

	}

	public final TypeParametersContext typeParameters() throws RecognitionException {

		TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());

		enterRule(_localctx, 16, RULE_typeParameters);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{

			setState(298); match(LT);

			setState(299); typeParameter();

			setState(304);

			_errHandler.sync(this);

			_la = _input.LA(1);

			while (_la==COMMA) {

				{

				{

				setState(300); match(COMMA);

				setState(301); typeParameter();

				}

				}

				setState(306);

				_errHandler.sync(this);

				_la = _input.LA(1);

			}

			setState(307); 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 TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); }

		public TypeBoundContext typeBound() {

			return getRuleContext(TypeBoundContext.class,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 JavaListener ) ((JavaListener)listener).enterTypeParameter(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeParameter(this);

		}

	}

	public final TypeParameterContext typeParameter() throws RecognitionException {

		TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());

		enterRule(_localctx, 18, RULE_typeParameter);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{

			setState(309); match(Identifier);

			setState(312);

			_la = _input.LA(1);

			if (_la==EXTENDS) {

				{

				setState(310); match(EXTENDS);

				setState(311); 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 TypeContext type(int i) {

			return getRuleContext(TypeContext.class,i);

		}

		public List<TypeContext> 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 JavaListener ) ((JavaListener)listener).enterTypeBound(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeBound(this);

		}

	}

	public final TypeBoundContext typeBound() throws RecognitionException {

		TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());

		enterRule(_localctx, 20, RULE_typeBound);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{

			setState(314); type();

			setState(319);

			_errHandler.sync(this);

			_la = _input.LA(1);

			while (_la==BITAND) {

				{

				{

				setState(315); match(BITAND);

				setState(316); type();

				}

				}

				setState(321);

				_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(JavaParser.ENUM, 0); }

		public TypeListContext typeList() {

			return getRuleContext(TypeListContext.class,0);

		}

		public EnumConstantsContext enumConstants() {

			return getRuleContext(EnumConstantsContext.class,0);

		}

		public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); }

		public EnumBodyDeclarationsContext enumBodyDeclarations() {

			return getRuleContext(EnumBodyDeclarationsContext.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 JavaListener ) ((JavaListener)listener).enterEnumDeclaration(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitEnumDeclaration(this);

		}

	}

	public final EnumDeclarationContext enumDeclaration() throws RecognitionException {

		EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());

		enterRule(_localctx, 22, RULE_enumDeclaration);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{

			setState(322); match(ENUM);

			setState(323); match(Identifier);

			setState(326);

			_la = _input.LA(1);

			if (_la==IMPLEMENTS) {

				{

				setState(324); match(IMPLEMENTS);

				setState(325); typeList();

				}

			}

			setState(328); match(LBRACE);

			setState(330);

			_la = _input.LA(1);

			if (_la==Identifier || _la==AT) {

				{

				setState(329); enumConstants();

				}

			}

			setState(333);

			_la = _input.LA(1);

			if (_la==COMMA) {

				{

				setState(332); match(COMMA);

				}

			}

			setState(336);

			_la = _input.LA(1);

			if (_la==SEMI) {

				{

				setState(335); enumBodyDeclarations();

				}

			}

			setState(338); 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<EnumConstantContext> enumConstant() {

			return getRuleContexts(EnumConstantContext.class);

		}

		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 JavaListener ) ((JavaListener)listener).enterEnumConstants(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitEnumConstants(this);

		}

	}

	public final EnumConstantsContext enumConstants() throws RecognitionException {

		EnumConstantsContext _localctx = new EnumConstantsContext(_ctx, getState());

		enterRule(_localctx, 24, RULE_enumConstants);

		try {

			int _alt;

			enterOuterAlt(_localctx, 1);

			{

			setState(340); enumConstant();

			setState(345);

			_errHandler.sync(this);

			_alt = getInterpreter().adaptivePredict(_input,24,_ctx);

			while ( _alt!=2 && _alt!=-1 ) {

				if ( _alt==1 ) {

					{

					{

					setState(341); match(COMMA);

					setState(342); enumConstant();

					}

					} 

				}

				setState(347);

				_errHandler.sync(this);

				_alt = getInterpreter().adaptivePredict(_input,24,_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 AnnotationContext annotation(int i) {

			return getRuleContext(AnnotationContext.class,i);

		}

		public ClassBodyContext classBody() {

			return getRuleContext(ClassBodyContext.class,0);

		}

		public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); }

		public List<AnnotationContext> annotation() {

			return getRuleContexts(AnnotationContext.class);

		}

		public ArgumentsContext arguments() {

			return getRuleContext(ArgumentsContext.class,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 JavaListener ) ((JavaListener)listener).enterEnumConstant(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitEnumConstant(this);

		}

	}

	public final EnumConstantContext enumConstant() throws RecognitionException {

		EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());

		enterRule(_localctx, 26, RULE_enumConstant);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{

			setState(351);

			_errHandler.sync(this);

			_la = _input.LA(1);

			while (_la==AT) {

				{

				{

				setState(348); annotation();

				}

				}

				setState(353);

				_errHandler.sync(this);

				_la = _input.LA(1);

			}

			setState(354); match(Identifier);

			setState(356);

			_la = _input.LA(1);

			if (_la==LPAREN) {

				{

				setState(355); arguments();

				}

			}

			setState(359);

			_la = _input.LA(1);

			if (_la==LBRACE) {

				{

				setState(358); 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<ClassBodyDeclarationContext> classBodyDeclaration() {

			return getRuleContexts(ClassBodyDeclarationContext.class);

		}

		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 JavaListener ) ((JavaListener)listener).enterEnumBodyDeclarations(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitEnumBodyDeclarations(this);

		}

	}

	public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {

		EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());

		enterRule(_localctx, 28, RULE_enumBodyDeclarations);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{

			setState(361); match(SEMI);

			setState(365);

			_errHandler.sync(this);

			_la = _input.LA(1);

			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 0)) {

				{

				{

				setState(362); classBodyDeclaration();

				}

				}

				setState(367);

				_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 TypeParametersContext typeParameters() {

			return getRuleContext(TypeParametersContext.class,0);

		}

		public TypeListContext typeList() {

			return getRuleContext(TypeListContext.class,0);

		}

		public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); }

		public InterfaceBodyContext interfaceBody() {

			return getRuleContext(InterfaceBodyContext.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 JavaListener ) ((JavaListener)listener).enterInterfaceDeclaration(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitInterfaceDeclaration(this);

		}

	}

	public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {

		InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());

		enterRule(_localctx, 30, RULE_interfaceDeclaration);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{

			setState(368); match(INTERFACE);

			setState(369); match(Identifier);

			setState(371);

			_la = _input.LA(1);

			if (_la==LT) {

				{

				setState(370); typeParameters();

				}

			}

			setState(375);

			_la = _input.LA(1);

			if (_la==EXTENDS) {

				{

				setState(373); match(EXTENDS);

				setState(374); typeList();

				}

			}

			setState(377); 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 TypeContext type(int i) {

			return getRuleContext(TypeContext.class,i);

		}

		public List<TypeContext> 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 JavaListener ) ((JavaListener)listener).enterTypeList(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeList(this);

		}

	}

	public final TypeListContext typeList() throws RecognitionException {

		TypeListContext _localctx = new TypeListContext(_ctx, getState());

		enterRule(_localctx, 32, RULE_typeList);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{

			setState(379); type();

			setState(384);

			_errHandler.sync(this);

			_la = _input.LA(1);

			while (_la==COMMA) {

				{

				{

				setState(380); match(COMMA);

				setState(381); type();

				}

				}

				setState(386);

				_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 List<ClassBodyDeclarationContext> classBodyDeclaration() {

			return getRuleContexts(ClassBodyDeclarationContext.class);

		}

		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 JavaListener ) ((JavaListener)listener).enterClassBody(this);

		}

		@Override

		public void exitRule(ParseTreeListener listener) {

			if ( listener instanceof JavaListener ) ((JavaListener)listener).exitClassBody(this);

		}

	}

	public final ClassBodyContext classBody() throws RecognitionException {

		ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());

		enterRule(_localctx, 34, RULE_classBody);

		int _la;

		try {

			enterOuterAlt(_localctx, 1);

			{