Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.lorentzos.pj.PJParser Maven / Gradle / Ivy
// Generated from /Users/Dionysis_Lorentzos/Projects/untitled1/PJ Grammar/PJ.g4 by ANTLR 4.4.1-dev
package com.lorentzos.pj;
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 PJParser extends Parser {
static { RuntimeMetaData.checkVersion("4.4.1-dev", RuntimeMetaData.VERSION); }
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, LPAREN=51, RPAREN=52, LBRACE=53, RBRACE=54, LBRACK=55, RBRACK=56,
SEMI=57, COMMA=58, DOT=59, ASSIGN=60, GT=61, LT=62, BANG=63, TILDE=64,
QUESTION=65, COLON=66, EQUAL=67, LE=68, GE=69, NOTEQUAL=70, AND=71, OR=72,
INC=73, DEC=74, ADD=75, SUB=76, MUL=77, DIV=78, BITAND=79, BITOR=80, CARET=81,
MOD=82, ADD_ASSIGN=83, SUB_ASSIGN=84, MUL_ASSIGN=85, DIV_ASSIGN=86, AND_ASSIGN=87,
OR_ASSIGN=88, XOR_ASSIGN=89, MOD_ASSIGN=90, LSHIFT_ASSIGN=91, RSHIFT_ASSIGN=92,
URSHIFT_ASSIGN=93, AT=94, ELLIPSIS=95, NullLiteral=96, BooleanLiteral=97,
CharacterLiteral=98, StringLiteral=99, IntegerLiteral=100, FloatingPointLiteral=101,
Identifier=102, NEWLINE=103, SKIP=104, INDENT=105, DEDENT=106;
public static final String[] tokenNames = {
"", "'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'", "'('", "')'",
"'{'", "'}'", "'['", "']'", "';'", "','", "'.'", "'='", "'>'", "'<'",
"'!'", "'~'", "'?'", "':'", "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'",
"'++'", "'--'", "'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'",
"'+='", "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='",
"'>>='", "'>>>='", "'@'", "'...'", "'null'", "BooleanLiteral", "CharacterLiteral",
"StringLiteral", "IntegerLiteral", "FloatingPointLiteral", "Identifier",
"NEWLINE", "SKIP", "INDENT", "DEDENT"
};
public static final int
RULE_pj = 0, RULE_packageDeclaration = 1, RULE_importDeclaration = 2,
RULE_typeDeclaration = 3, RULE_testingRule = 4, RULE_elementValue = 5,
RULE_elementValueArrayInitializer = 6, RULE_formalParameters = 7, RULE_formalParameterList = 8,
RULE_formalParameter = 9, RULE_lastFormalParameter = 10, RULE_constDeclaration = 11,
RULE_constantDeclarator = 12, RULE_qualifiedNameList = 13, RULE_qualifiedName = 14,
RULE_identifierRule = 15, RULE_classDeclaration = 16, RULE_classBody = 17,
RULE_classBodyDeclaration = 18, RULE_modifier = 19, RULE_classOrInterfaceModifier = 20,
RULE_memberDeclaration = 21, RULE_genericMethodDeclaration = 22, RULE_methodDeclaration = 23,
RULE_methodBody = 24, RULE_fieldDeclaration = 25, RULE_genericConstructorDeclaration = 26,
RULE_constructorDeclaration = 27, RULE_constructorBody = 28, RULE_genericInterfaceMethodDeclaration = 29,
RULE_interfaceMethodDeclaration = 30, RULE_interfaceDeclaration = 31,
RULE_interfaceBody = 32, RULE_interfaceBodyDeclaration = 33, RULE_interfaceMemberDeclaration = 34,
RULE_annotationTypeDeclaration = 35, RULE_annotationTypeBody = 36, RULE_annotationTypeElementDeclaration = 37,
RULE_annotationTypeElementRest = 38, RULE_annotationMethodOrConstantRest = 39,
RULE_annotationMethodRest = 40, RULE_annotationConstantRest = 41, RULE_defaultValue = 42,
RULE_annotation = 43, RULE_annotationName = 44, RULE_elementValuePairs = 45,
RULE_elementValuePair = 46, RULE_enumDeclaration = 47, RULE_enumConstants = 48,
RULE_enumConstant = 49, RULE_enumBodyDeclarations = 50, RULE_block = 51,
RULE_blockStatement = 52, RULE_localVariableDeclaration = 53, RULE_statement = 54,
RULE_statementsCommaless = 55, RULE_parExpression = 56, RULE_catchClause = 57,
RULE_catchDeclaration = 58, RULE_catchType = 59, RULE_finallyBlock = 60,
RULE_resourceSpecification = 61, RULE_resources = 62, RULE_resource = 63,
RULE_switchBlockStatementGroup = 64, RULE_switchLabel = 65, RULE_constantExpression = 66,
RULE_enumConstantName = 67, RULE_forControl = 68, RULE_forInit = 69, RULE_enhancedForControl = 70,
RULE_forUpdate = 71, RULE_variableDeclarators = 72, RULE_variableDeclarator = 73,
RULE_variableDeclaratorId = 74, RULE_variableInitializer = 75, RULE_arrayInitializer = 76,
RULE_variableModifier = 77, RULE_typeParameters = 78, RULE_typeParameter = 79,
RULE_typeBound = 80, RULE_typeList = 81, RULE_type = 82, RULE_classOrInterfaceType = 83,
RULE_typeArguments = 84, RULE_typeArgument = 85, RULE_typeArgumentsOrDiamond = 86,
RULE_primitiveType = 87, RULE_expressionList = 88, RULE_expression = 89,
RULE_primary = 90, RULE_literal = 91, RULE_nonWildcardTypeArgumentsOrDiamond = 92,
RULE_nonWildcardTypeArguments = 93, RULE_explicitGenericInvocation = 94,
RULE_explicitGenericInvocationSuffix = 95, RULE_superSuffix = 96, RULE_arguments = 97,
RULE_creator = 98, RULE_createdName = 99, RULE_classCreatorRest = 100,
RULE_arrayCreatorRest = 101, RULE_innerCreator = 102, RULE_abstractRule = 103,
RULE_assertRule = 104, RULE_booleanRule = 105, RULE_breakRule = 106, RULE_byteRule = 107,
RULE_caseRule = 108, RULE_catchRule = 109, RULE_charRule = 110, RULE_classRule = 111,
RULE_constRule = 112, RULE_continueRule = 113, RULE_defaultRule = 114,
RULE_doRule = 115, RULE_doubleRule = 116, RULE_elseRule = 117, RULE_enumRule = 118,
RULE_extendsRule = 119, RULE_finalRule = 120, RULE_finallyRule = 121,
RULE_floatRule = 122, RULE_forRule = 123, RULE_ifRule = 124, RULE_gotoRule = 125,
RULE_implementsRule = 126, RULE_importRule = 127, RULE_instanceofRule = 128,
RULE_intRule = 129, RULE_interfaceRule = 130, RULE_longRule = 131, RULE_nativeRule = 132,
RULE_newRule = 133, RULE_packageRule = 134, RULE_privateRule = 135, RULE_protectedRule = 136,
RULE_publicRule = 137, RULE_returnRule = 138, RULE_shortRule = 139, RULE_staticRule = 140,
RULE_strictfpRule = 141, RULE_superRule = 142, RULE_switchRule = 143,
RULE_synchronizedRule = 144, RULE_thisRule = 145, RULE_throwRule = 146,
RULE_throwsRule = 147, RULE_transientRule = 148, RULE_tryRule = 149, RULE_voidRule = 150,
RULE_volatileRule = 151, RULE_whileRule = 152, RULE_lparenRule = 153,
RULE_rparenRule = 154, RULE_lbraceRule = 155, RULE_rbraceRule = 156, RULE_lbrackRule = 157,
RULE_rbrackRule = 158, RULE_semiRule = 159, RULE_commaRule = 160, RULE_dotRule = 161,
RULE_assignRule = 162, RULE_gtRule = 163, RULE_ltRule = 164, RULE_bangRule = 165,
RULE_tildeRule = 166, RULE_questionRule = 167, RULE_colonRule = 168, RULE_equalRule = 169,
RULE_leRule = 170, RULE_geRule = 171, RULE_notEqualRule = 172, RULE_andRule = 173,
RULE_orRule = 174, RULE_incRule = 175, RULE_decRule = 176, RULE_addRule = 177,
RULE_subRule = 178, RULE_mulRule = 179, RULE_divRule = 180, RULE_bitandRule = 181,
RULE_bitorRule = 182, RULE_caretRule = 183, RULE_modRule = 184, RULE_add_assignRule = 185,
RULE_sub_assignRule = 186, RULE_mul_assignRule = 187, RULE_div_assignRule = 188,
RULE_and_assignRule = 189, RULE_or_assignRule = 190, RULE_xor_assignRule = 191,
RULE_mod_assignRule = 192, RULE_lshift_assignRule = 193, RULE_rshift_assignRule = 194,
RULE_urshift_assignRule = 195, RULE_atRule = 196, RULE_ellipsisRule = 197;
public static final String[] ruleNames = {
"pj", "packageDeclaration", "importDeclaration", "typeDeclaration", "testingRule",
"elementValue", "elementValueArrayInitializer", "formalParameters", "formalParameterList",
"formalParameter", "lastFormalParameter", "constDeclaration", "constantDeclarator",
"qualifiedNameList", "qualifiedName", "identifierRule", "classDeclaration",
"classBody", "classBodyDeclaration", "modifier", "classOrInterfaceModifier",
"memberDeclaration", "genericMethodDeclaration", "methodDeclaration",
"methodBody", "fieldDeclaration", "genericConstructorDeclaration", "constructorDeclaration",
"constructorBody", "genericInterfaceMethodDeclaration", "interfaceMethodDeclaration",
"interfaceDeclaration", "interfaceBody", "interfaceBodyDeclaration", "interfaceMemberDeclaration",
"annotationTypeDeclaration", "annotationTypeBody", "annotationTypeElementDeclaration",
"annotationTypeElementRest", "annotationMethodOrConstantRest", "annotationMethodRest",
"annotationConstantRest", "defaultValue", "annotation", "annotationName",
"elementValuePairs", "elementValuePair", "enumDeclaration", "enumConstants",
"enumConstant", "enumBodyDeclarations", "block", "blockStatement", "localVariableDeclaration",
"statement", "statementsCommaless", "parExpression", "catchClause", "catchDeclaration",
"catchType", "finallyBlock", "resourceSpecification", "resources", "resource",
"switchBlockStatementGroup", "switchLabel", "constantExpression", "enumConstantName",
"forControl", "forInit", "enhancedForControl", "forUpdate", "variableDeclarators",
"variableDeclarator", "variableDeclaratorId", "variableInitializer", "arrayInitializer",
"variableModifier", "typeParameters", "typeParameter", "typeBound", "typeList",
"type", "classOrInterfaceType", "typeArguments", "typeArgument", "typeArgumentsOrDiamond",
"primitiveType", "expressionList", "expression", "primary", "literal",
"nonWildcardTypeArgumentsOrDiamond", "nonWildcardTypeArguments", "explicitGenericInvocation",
"explicitGenericInvocationSuffix", "superSuffix", "arguments", "creator",
"createdName", "classCreatorRest", "arrayCreatorRest", "innerCreator",
"abstractRule", "assertRule", "booleanRule", "breakRule", "byteRule",
"caseRule", "catchRule", "charRule", "classRule", "constRule", "continueRule",
"defaultRule", "doRule", "doubleRule", "elseRule", "enumRule", "extendsRule",
"finalRule", "finallyRule", "floatRule", "forRule", "ifRule", "gotoRule",
"implementsRule", "importRule", "instanceofRule", "intRule", "interfaceRule",
"longRule", "nativeRule", "newRule", "packageRule", "privateRule", "protectedRule",
"publicRule", "returnRule", "shortRule", "staticRule", "strictfpRule",
"superRule", "switchRule", "synchronizedRule", "thisRule", "throwRule",
"throwsRule", "transientRule", "tryRule", "voidRule", "volatileRule",
"whileRule", "lparenRule", "rparenRule", "lbraceRule", "rbraceRule", "lbrackRule",
"rbrackRule", "semiRule", "commaRule", "dotRule", "assignRule", "gtRule",
"ltRule", "bangRule", "tildeRule", "questionRule", "colonRule", "equalRule",
"leRule", "geRule", "notEqualRule", "andRule", "orRule", "incRule", "decRule",
"addRule", "subRule", "mulRule", "divRule", "bitandRule", "bitorRule",
"caretRule", "modRule", "add_assignRule", "sub_assignRule", "mul_assignRule",
"div_assignRule", "and_assignRule", "or_assignRule", "xor_assignRule",
"mod_assignRule", "lshift_assignRule", "rshift_assignRule", "urshift_assignRule",
"atRule", "ellipsisRule"
};
@Override
public String getGrammarFileName() { return "PJ.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 PJParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class PjContext extends ParserRuleContext {
public List importDeclaration() {
return getRuleContexts(ImportDeclarationContext.class);
}
public TerminalNode EOF() { return getToken(PJParser.EOF, 0); }
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 TypeDeclarationContext typeDeclaration(int i) {
return getRuleContext(TypeDeclarationContext.class,i);
}
public PjContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pj; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterPj(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitPj(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitPj(this);
else return visitor.visitChildren(this);
}
}
public final PjContext pj() throws RecognitionException {
PjContext _localctx = new PjContext(_ctx, getState());
enterRule(_localctx, 0, RULE_pj);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(397);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(396); packageDeclaration();
}
break;
}
setState(402);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IMPORT) {
{
{
setState(399); importDeclaration();
}
}
setState(404);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(408);
_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))) != 0) || _la==AT) {
{
{
setState(405); typeDeclaration();
}
}
setState(410);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(411); 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 PackageRuleContext packageRule() {
return getRuleContext(PackageRuleContext.class,0);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public List 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 PJListener ) ((PJListener)listener).enterPackageDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitPackageDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitPackageDeclaration(this);
else return visitor.visitChildren(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(416);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(413); annotation();
}
}
setState(418);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(419); packageRule();
setState(420); qualifiedName();
}
}
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 DotRuleContext dotRule() {
return getRuleContext(DotRuleContext.class,0);
}
public ImportRuleContext importRule() {
return getRuleContext(ImportRuleContext.class,0);
}
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public MulRuleContext mulRule() {
return getRuleContext(MulRuleContext.class,0);
}
public StaticRuleContext staticRule() {
return getRuleContext(StaticRuleContext.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 PJListener ) ((PJListener)listener).enterImportDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitImportDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitImportDeclaration(this);
else return visitor.visitChildren(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(422); importRule();
setState(424);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(423); staticRule();
}
}
setState(426); qualifiedName();
setState(430);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(427); dotRule();
setState(428); mulRule();
}
}
}
}
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 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 PJListener ) ((PJListener)listener).enterTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTypeDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTypeDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 6, RULE_typeDeclaration);
int _la;
try {
int _alt;
setState(460);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(435);
_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(432); classOrInterfaceModifier();
}
}
setState(437);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(438); classDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(442);
_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(439); classOrInterfaceModifier();
}
}
setState(444);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(445); interfaceDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(449);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(446); classOrInterfaceModifier();
}
}
}
setState(451);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
}
setState(452); annotationTypeDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(456);
_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(453); classOrInterfaceModifier();
}
}
setState(458);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(459); enumDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TestingRuleContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TestingRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testingRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterTestingRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTestingRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTestingRule(this);
else return visitor.visitChildren(this);
}
}
public final TestingRuleContext testingRule() throws RecognitionException {
TestingRuleContext _localctx = new TestingRuleContext(_ctx, getState());
enterRule(_localctx, 8, RULE_testingRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(462); expression(0);
}
}
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 AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public ElementValueArrayInitializerContext elementValueArrayInitializer() {
return getRuleContext(ElementValueArrayInitializerContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.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 PJListener ) ((PJListener)listener).enterElementValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitElementValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitElementValue(this);
else return visitor.visitChildren(this);
}
}
public final ElementValueContext elementValue() throws RecognitionException {
ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
enterRule(_localctx, 10, RULE_elementValue);
try {
setState(467);
switch (_input.LA(1)) {
case LBRACE:
enterOuterAlt(_localctx, 1);
{
setState(464); elementValueArrayInitializer();
}
break;
case AT:
enterOuterAlt(_localctx, 2);
{
setState(465); annotation();
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case LPAREN:
case LT:
case BANG:
case TILDE:
case INC:
case DEC:
case ADD:
case SUB:
case NullLiteral:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case IntegerLiteral:
case FloatingPointLiteral:
case Identifier:
enterOuterAlt(_localctx, 3);
{
setState(466); expression(0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValueArrayInitializerContext extends ParserRuleContext {
public ElementValueContext elementValue(int i) {
return getRuleContext(ElementValueContext.class,i);
}
public List elementValue() {
return getRuleContexts(ElementValueContext.class);
}
public List commaRule() {
return getRuleContexts(CommaRuleContext.class);
}
public CommaRuleContext commaRule(int i) {
return getRuleContext(CommaRuleContext.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 PJListener ) ((PJListener)listener).enterElementValueArrayInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitElementValueArrayInitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitElementValueArrayInitializer(this);
else return visitor.visitChildren(this);
}
}
public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException {
ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState());
enterRule(_localctx, 12, RULE_elementValueArrayInitializer);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(469); match(LBRACE);
setState(479);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << LPAREN) | (1L << LBRACE) | (1L << LT) | (1L << BANG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (AT - 64)) | (1L << (NullLiteral - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(470); elementValue();
setState(476);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(471); commaRule();
setState(472); elementValue();
}
}
}
setState(478);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
}
}
}
setState(482);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(481); commaRule();
}
}
setState(484); match(RBRACE);
}
}
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 LparenRuleContext lparenRule() {
return getRuleContext(LparenRuleContext.class,0);
}
public RparenRuleContext rparenRule() {
return getRuleContext(RparenRuleContext.class,0);
}
public FormalParameterListContext formalParameterList() {
return getRuleContext(FormalParameterListContext.class,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 PJListener ) ((PJListener)listener).enterFormalParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitFormalParameters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitFormalParameters(this);
else return visitor.visitChildren(this);
}
}
public final FormalParametersContext formalParameters() throws RecognitionException {
FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
enterRule(_localctx, 14, RULE_formalParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(486); lparenRule();
setState(488);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==AT || _la==Identifier) {
{
setState(487); formalParameterList();
}
}
setState(490); rparenRule();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FormalParameterListContext extends ParserRuleContext {
public List commaRule() {
return getRuleContexts(CommaRuleContext.class);
}
public List formalParameter() {
return getRuleContexts(FormalParameterContext.class);
}
public CommaRuleContext commaRule(int i) {
return getRuleContext(CommaRuleContext.class,i);
}
public LastFormalParameterContext lastFormalParameter() {
return getRuleContext(LastFormalParameterContext.class,0);
}
public FormalParameterContext formalParameter(int i) {
return getRuleContext(FormalParameterContext.class,i);
}
public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterFormalParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitFormalParameterList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitFormalParameterList(this);
else return visitor.visitChildren(this);
}
}
public final FormalParameterListContext formalParameterList() throws RecognitionException {
FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
enterRule(_localctx, 16, RULE_formalParameterList);
int _la;
try {
int _alt;
setState(507);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(492); formalParameter();
setState(498);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(493); commaRule();
setState(494); formalParameter();
}
}
}
setState(500);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
}
setState(504);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(501); commaRule();
setState(502); lastFormalParameter();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(506); lastFormalParameter();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FormalParameterContext extends ParserRuleContext {
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public FormalParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterFormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitFormalParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitFormalParameter(this);
else return visitor.visitChildren(this);
}
}
public final FormalParameterContext formalParameter() throws RecognitionException {
FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
enterRule(_localctx, 18, RULE_formalParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(512);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(509); variableModifier();
}
}
setState(514);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(515); type();
setState(516); variableDeclaratorId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LastFormalParameterContext extends ParserRuleContext {
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public LastFormalParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lastFormalParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterLastFormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitLastFormalParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitLastFormalParameter(this);
else return visitor.visitChildren(this);
}
}
public final LastFormalParameterContext lastFormalParameter() throws RecognitionException {
LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState());
enterRule(_localctx, 20, RULE_lastFormalParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(521);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(518); variableModifier();
}
}
setState(523);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(524); type();
setState(525); match(ELLIPSIS);
setState(526); variableDeclaratorId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstDeclarationContext extends ParserRuleContext {
public List commaRule() {
return getRuleContexts(CommaRuleContext.class);
}
public List constantDeclarator() {
return getRuleContexts(ConstantDeclaratorContext.class);
}
public ConstantDeclaratorContext constantDeclarator(int i) {
return getRuleContext(ConstantDeclaratorContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public CommaRuleContext commaRule(int i) {
return getRuleContext(CommaRuleContext.class,i);
}
public ConstDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterConstDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitConstDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitConstDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ConstDeclarationContext constDeclaration() throws RecognitionException {
ConstDeclarationContext _localctx = new ConstDeclarationContext(_ctx, getState());
enterRule(_localctx, 22, RULE_constDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(528); type();
setState(529); constantDeclarator();
setState(535);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(530); commaRule();
setState(531); constantDeclarator();
}
}
setState(537);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(538); match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantDeclaratorContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(PJParser.Identifier, 0); }
public VariableInitializerContext variableInitializer() {
return getRuleContext(VariableInitializerContext.class,0);
}
public ConstantDeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantDeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterConstantDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitConstantDeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitConstantDeclarator(this);
else return visitor.visitChildren(this);
}
}
public final ConstantDeclaratorContext constantDeclarator() throws RecognitionException {
ConstantDeclaratorContext _localctx = new ConstantDeclaratorContext(_ctx, getState());
enterRule(_localctx, 24, RULE_constantDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(540); match(Identifier);
setState(545);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(541); match(LBRACK);
setState(542); match(RBRACK);
}
}
setState(547);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(548); match(ASSIGN);
setState(549); variableInitializer();
}
}
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 QualifiedNameContext qualifiedName(int i) {
return getRuleContext(QualifiedNameContext.class,i);
}
public List commaRule() {
return getRuleContexts(CommaRuleContext.class);
}
public List qualifiedName() {
return getRuleContexts(QualifiedNameContext.class);
}
public CommaRuleContext commaRule(int i) {
return getRuleContext(CommaRuleContext.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 PJListener ) ((PJListener)listener).enterQualifiedNameList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitQualifiedNameList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitQualifiedNameList(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedNameListContext qualifiedNameList() throws RecognitionException {
QualifiedNameListContext _localctx = new QualifiedNameListContext(_ctx, getState());
enterRule(_localctx, 26, RULE_qualifiedNameList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(551); qualifiedName();
setState(557);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(552); commaRule();
setState(553); qualifiedName();
}
}
setState(559);
_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 QualifiedNameContext extends ParserRuleContext {
public TerminalNode Identifier(int i) {
return getToken(PJParser.Identifier, i);
}
public List Identifier() { return getTokens(PJParser.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 PJListener ) ((PJListener)listener).enterQualifiedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitQualifiedName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitQualifiedName(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedNameContext qualifiedName() throws RecognitionException {
QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState());
enterRule(_localctx, 28, RULE_qualifiedName);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(560); match(Identifier);
setState(565);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(561); match(DOT);
setState(562); match(Identifier);
}
}
}
setState(567);
_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 IdentifierRuleContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(PJParser.Identifier, 0); }
public IdentifierRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterIdentifierRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitIdentifierRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitIdentifierRule(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierRuleContext identifierRule() throws RecognitionException {
IdentifierRuleContext _localctx = new IdentifierRuleContext(_ctx, getState());
enterRule(_localctx, 30, RULE_identifierRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(568); match(Identifier);
}
}
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 IdentifierRuleContext identifierRule() {
return getRuleContext(IdentifierRuleContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public ImplementsRuleContext implementsRule() {
return getRuleContext(ImplementsRuleContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ClassRuleContext classRule() {
return getRuleContext(ClassRuleContext.class,0);
}
public ExtendsRuleContext extendsRule() {
return getRuleContext(ExtendsRuleContext.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 PJListener ) ((PJListener)listener).enterClassDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitClassDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitClassDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ClassDeclarationContext classDeclaration() throws RecognitionException {
ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
enterRule(_localctx, 32, RULE_classDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(570); classRule();
setState(571); identifierRule();
setState(573);
_la = _input.LA(1);
if (_la==LT) {
{
setState(572); typeParameters();
}
}
setState(578);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(575); extendsRule();
setState(576); type();
}
}
setState(583);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(580); implementsRule();
setState(581); typeList();
}
}
setState(585); classBody();
}
}
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 TerminalNode INDENT() { return getToken(PJParser.INDENT, 0); }
public ClassBodyDeclarationContext classBodyDeclaration(int i) {
return getRuleContext(ClassBodyDeclarationContext.class,i);
}
public TerminalNode DEDENT() { return getToken(PJParser.DEDENT, 0); }
public List 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 PJListener ) ((PJListener)listener).enterClassBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitClassBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitClassBody(this);
else return visitor.visitChildren(this);
}
}
public final ClassBodyContext classBody() throws RecognitionException {
ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
enterRule(_localctx, 34, RULE_classBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(588);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(587); match(COLON);
}
}
setState(590); match(INDENT);
setState(594);
_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 << LT))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (COLON - 66)) | (1L << (AT - 66)) | (1L << (Identifier - 66)) | (1L << (INDENT - 66)))) != 0)) {
{
{
setState(591); classBodyDeclaration();
}
}
setState(596);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(597); match(DEDENT);
}
}
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 MemberDeclarationContext memberDeclaration() {
return getRuleContext(MemberDeclarationContext.class,0);
}
public List modifier() {
return getRuleContexts(ModifierContext.class);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public ModifierContext modifier(int i) {
return getRuleContext(ModifierContext.class,i);
}
public StaticRuleContext staticRule() {
return getRuleContext(StaticRuleContext.class,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 PJListener ) ((PJListener)listener).enterClassBodyDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitClassBodyDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitClassBodyDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
enterRule(_localctx, 36, RULE_classBodyDeclaration);
int _la;
try {
int _alt;
setState(610);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(600);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(599); staticRule();
}
}
setState(602); block();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(606);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(603); modifier();
}
}
}
setState(608);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
}
setState(609); memberDeclaration();
}
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 NativeRuleContext nativeRule() {
return getRuleContext(NativeRuleContext.class,0);
}
public SynchronizedRuleContext synchronizedRule() {
return getRuleContext(SynchronizedRuleContext.class,0);
}
public VolatileRuleContext volatileRule() {
return getRuleContext(VolatileRuleContext.class,0);
}
public TransientRuleContext transientRule() {
return getRuleContext(TransientRuleContext.class,0);
}
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 PJListener ) ((PJListener)listener).enterModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitModifier(this);
else return visitor.visitChildren(this);
}
}
public final ModifierContext modifier() throws RecognitionException {
ModifierContext _localctx = new ModifierContext(_ctx, getState());
enterRule(_localctx, 38, RULE_modifier);
try {
setState(619);
switch (_input.LA(1)) {
case ABSTRACT:
case FINAL:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case STATIC:
case STRICTFP:
case AT:
enterOuterAlt(_localctx, 1);
{
setState(612); classOrInterfaceModifier();
}
break;
case NATIVE:
case SYNCHRONIZED:
case TRANSIENT:
case VOLATILE:
enterOuterAlt(_localctx, 2);
{
setState(617);
switch (_input.LA(1)) {
case NATIVE:
{
setState(613); nativeRule();
}
break;
case SYNCHRONIZED:
{
setState(614); synchronizedRule();
}
break;
case TRANSIENT:
{
setState(615); transientRule();
}
break;
case VOLATILE:
{
setState(616); volatileRule();
}
break;
default:
throw new NoViableAltException(this);
}
}
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 StrictfpRuleContext strictfpRule() {
return getRuleContext(StrictfpRuleContext.class,0);
}
public PrivateRuleContext privateRule() {
return getRuleContext(PrivateRuleContext.class,0);
}
public PublicRuleContext publicRule() {
return getRuleContext(PublicRuleContext.class,0);
}
public ProtectedRuleContext protectedRule() {
return getRuleContext(ProtectedRuleContext.class,0);
}
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public AbstractRuleContext abstractRule() {
return getRuleContext(AbstractRuleContext.class,0);
}
public FinalRuleContext finalRule() {
return getRuleContext(FinalRuleContext.class,0);
}
public StaticRuleContext staticRule() {
return getRuleContext(StaticRuleContext.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 PJListener ) ((PJListener)listener).enterClassOrInterfaceModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitClassOrInterfaceModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitClassOrInterfaceModifier(this);
else return visitor.visitChildren(this);
}
}
public final ClassOrInterfaceModifierContext classOrInterfaceModifier() throws RecognitionException {
ClassOrInterfaceModifierContext _localctx = new ClassOrInterfaceModifierContext(_ctx, getState());
enterRule(_localctx, 40, RULE_classOrInterfaceModifier);
try {
setState(631);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(621); annotation();
}
break;
case ABSTRACT:
case FINAL:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case STATIC:
case STRICTFP:
enterOuterAlt(_localctx, 2);
{
setState(629);
switch (_input.LA(1)) {
case PUBLIC:
{
setState(622); publicRule();
}
break;
case PROTECTED:
{
setState(623); protectedRule();
}
break;
case PRIVATE:
{
setState(624); privateRule();
}
break;
case STATIC:
{
setState(625); staticRule();
}
break;
case ABSTRACT:
{
setState(626); abstractRule();
}
break;
case FINAL:
{
setState(627); finalRule();
}
break;
case STRICTFP:
{
setState(628); strictfpRule();
}
break;
default:
throw new NoViableAltException(this);
}
}
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 MemberDeclarationContext extends ParserRuleContext {
public MemberDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_memberDeclaration; }
public MemberDeclarationContext() { }
public void copyFrom(MemberDeclarationContext ctx) {
super.copyFrom(ctx);
}
}
public static class MemberDeclarationNLContext extends MemberDeclarationContext {
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
}
public ConstructorDeclarationContext constructorDeclaration() {
return getRuleContext(ConstructorDeclarationContext.class,0);
}
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public MethodDeclarationContext methodDeclaration() {
return getRuleContext(MethodDeclarationContext.class,0);
}
public GenericMethodDeclarationContext genericMethodDeclaration() {
return getRuleContext(GenericMethodDeclarationContext.class,0);
}
public GenericConstructorDeclarationContext genericConstructorDeclaration() {
return getRuleContext(GenericConstructorDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public MemberDeclarationNLContext(MemberDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterMemberDeclarationNL(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitMemberDeclarationNL(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitMemberDeclarationNL(this);
else return visitor.visitChildren(this);
}
}
public static class MemberDeclarationNoNLContext extends MemberDeclarationContext {
public FieldDeclarationContext fieldDeclaration() {
return getRuleContext(FieldDeclarationContext.class,0);
}
public MemberDeclarationNoNLContext(MemberDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterMemberDeclarationNoNL(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitMemberDeclarationNoNL(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitMemberDeclarationNoNL(this);
else return visitor.visitChildren(this);
}
}
public final MemberDeclarationContext memberDeclaration() throws RecognitionException {
MemberDeclarationContext _localctx = new MemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 42, RULE_memberDeclaration);
try {
setState(642);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
_localctx = new MemberDeclarationNLContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(633); classDeclaration();
}
break;
case 2:
_localctx = new MemberDeclarationNLContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(634); genericMethodDeclaration();
}
break;
case 3:
_localctx = new MemberDeclarationNLContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(635); methodDeclaration();
}
break;
case 4:
_localctx = new MemberDeclarationNoNLContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(636); fieldDeclaration();
}
break;
case 5:
_localctx = new MemberDeclarationNLContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(637); genericConstructorDeclaration();
}
break;
case 6:
_localctx = new MemberDeclarationNLContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(638); constructorDeclaration();
}
break;
case 7:
_localctx = new MemberDeclarationNLContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(639); interfaceDeclaration();
}
break;
case 8:
_localctx = new MemberDeclarationNLContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(640); annotationTypeDeclaration();
}
break;
case 9:
_localctx = new MemberDeclarationNLContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(641); enumDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GenericMethodDeclarationContext extends ParserRuleContext {
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public MethodDeclarationContext methodDeclaration() {
return getRuleContext(MethodDeclarationContext.class,0);
}
public GenericMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericMethodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterGenericMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitGenericMethodDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitGenericMethodDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final GenericMethodDeclarationContext genericMethodDeclaration() throws RecognitionException {
GenericMethodDeclarationContext _localctx = new GenericMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 44, RULE_genericMethodDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(644); typeParameters();
setState(645); methodDeclaration();
}
}
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 MethodBodyContext methodBody() {
return getRuleContext(MethodBodyContext.class,0);
}
public IdentifierRuleContext identifierRule() {
return getRuleContext(IdentifierRuleContext.class,0);
}
public VoidRuleContext voidRule() {
return getRuleContext(VoidRuleContext.class,0);
}
public FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ThrowsRuleContext throwsRule() {
return getRuleContext(ThrowsRuleContext.class,0);
}
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 PJListener ) ((PJListener)listener).enterMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitMethodDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitMethodDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 46, RULE_methodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(649);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
{
setState(647); type();
}
break;
case VOID:
{
setState(648); voidRule();
}
break;
default:
throw new NoViableAltException(this);
}
setState(651); identifierRule();
setState(652); formalParameters();
setState(657);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(653); match(LBRACK);
setState(654); match(RBRACK);
}
}
setState(659);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(663);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(660); throwsRule();
setState(661); qualifiedNameList();
}
}
setState(666);
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
case 1:
{
setState(665); methodBody();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodBodyContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public MethodBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterMethodBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitMethodBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitMethodBody(this);
else return visitor.visitChildren(this);
}
}
public final MethodBodyContext methodBody() throws RecognitionException {
MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
enterRule(_localctx, 48, RULE_methodBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(668); block();
}
}
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 VariableDeclaratorsContext variableDeclarators() {
return getRuleContext(VariableDeclaratorsContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.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 PJListener ) ((PJListener)listener).enterFieldDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitFieldDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitFieldDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
enterRule(_localctx, 50, RULE_fieldDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(670); type();
setState(671); variableDeclarators();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GenericConstructorDeclarationContext extends ParserRuleContext {
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public ConstructorDeclarationContext constructorDeclaration() {
return getRuleContext(ConstructorDeclarationContext.class,0);
}
public GenericConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericConstructorDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterGenericConstructorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitGenericConstructorDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitGenericConstructorDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final GenericConstructorDeclarationContext genericConstructorDeclaration() throws RecognitionException {
GenericConstructorDeclarationContext _localctx = new GenericConstructorDeclarationContext(_ctx, getState());
enterRule(_localctx, 52, RULE_genericConstructorDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(673); typeParameters();
setState(674); constructorDeclaration();
}
}
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 FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public TerminalNode Identifier() { return getToken(PJParser.Identifier, 0); }
public ConstructorBodyContext constructorBody() {
return getRuleContext(ConstructorBodyContext.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 PJListener ) ((PJListener)listener).enterConstructorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitConstructorDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitConstructorDeclaration(this);
else return visitor.visitChildren(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(676); match(Identifier);
setState(677); formalParameters();
setState(680);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(678); match(THROWS);
setState(679); qualifiedNameList();
}
}
setState(682); constructorBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorBodyContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public ConstructorBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterConstructorBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitConstructorBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitConstructorBody(this);
else return visitor.visitChildren(this);
}
}
public final ConstructorBodyContext constructorBody() throws RecognitionException {
ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState());
enterRule(_localctx, 56, RULE_constructorBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(684); block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GenericInterfaceMethodDeclarationContext extends ParserRuleContext {
public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
return getRuleContext(InterfaceMethodDeclarationContext.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public GenericInterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericInterfaceMethodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterGenericInterfaceMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitGenericInterfaceMethodDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitGenericInterfaceMethodDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() throws RecognitionException {
GenericInterfaceMethodDeclarationContext _localctx = new GenericInterfaceMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 58, RULE_genericInterfaceMethodDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(686); typeParameters();
setState(687); interfaceMethodDeclaration();
}
}
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 FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public TerminalNode Identifier() { return getToken(PJParser.Identifier, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
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 PJListener ) ((PJListener)listener).enterInterfaceMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitInterfaceMethodDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitInterfaceMethodDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 60, RULE_interfaceMethodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(691);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
{
setState(689); type();
}
break;
case VOID:
{
setState(690); match(VOID);
}
break;
default:
throw new NoViableAltException(this);
}
setState(693); match(Identifier);
setState(694); formalParameters();
setState(699);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(695); match(LBRACK);
setState(696); match(RBRACK);
}
}
setState(701);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(704);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(702); match(THROWS);
setState(703); qualifiedNameList();
}
}
setState(706); match(SEMI);
}
}
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(PJParser.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 PJListener ) ((PJListener)listener).enterInterfaceDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitInterfaceDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitInterfaceDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
enterRule(_localctx, 62, RULE_interfaceDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(708); match(INTERFACE);
setState(709); match(Identifier);
setState(711);
_la = _input.LA(1);
if (_la==LT) {
{
setState(710); typeParameters();
}
}
setState(715);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(713); match(EXTENDS);
setState(714); typeList();
}
}
setState(717); interfaceBody();
}
}
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 InterfaceBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterInterfaceBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitInterfaceBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitInterfaceBody(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceBodyContext interfaceBody() throws RecognitionException {
InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
enterRule(_localctx, 64, RULE_interfaceBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(719); match(LBRACE);
setState(723);
_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 << SEMI) | (1L << LT))) != 0) || _la==AT || _la==Identifier) {
{
{
setState(720); interfaceBodyDeclaration();
}
}
setState(725);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(726); match(RBRACE);
}
}
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 InterfaceMemberDeclarationContext interfaceMemberDeclaration() {
return getRuleContext(InterfaceMemberDeclarationContext.class,0);
}
public List modifier() {
return getRuleContexts(ModifierContext.class);
}
public ModifierContext modifier(int i) {
return getRuleContext(ModifierContext.class,i);
}
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 PJListener ) ((PJListener)listener).enterInterfaceBodyDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitInterfaceBodyDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitInterfaceBodyDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceBodyDeclarationContext interfaceBodyDeclaration() throws RecognitionException {
InterfaceBodyDeclarationContext _localctx = new InterfaceBodyDeclarationContext(_ctx, getState());
enterRule(_localctx, 66, RULE_interfaceBodyDeclaration);
try {
int _alt;
setState(736);
switch (_input.LA(1)) {
case ABSTRACT:
case BOOLEAN:
case BYTE:
case CHAR:
case CLASS:
case DOUBLE:
case ENUM:
case FINAL:
case FLOAT:
case INT:
case INTERFACE:
case LONG:
case NATIVE:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case SHORT:
case STATIC:
case STRICTFP:
case SYNCHRONIZED:
case TRANSIENT:
case VOID:
case VOLATILE:
case LT:
case AT:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(731);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,49,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(728); modifier();
}
}
}
setState(733);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,49,_ctx);
}
setState(734); interfaceMemberDeclaration();
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(735); 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 InterfaceMemberDeclarationContext extends ParserRuleContext {
public GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() {
return getRuleContext(GenericInterfaceMethodDeclarationContext.class,0);
}
public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
return getRuleContext(InterfaceMethodDeclarationContext.class,0);
}
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
}
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public ConstDeclarationContext constDeclaration() {
return getRuleContext(ConstDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterInterfaceMemberDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitInterfaceMemberDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitInterfaceMemberDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException {
InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 68, RULE_interfaceMemberDeclaration);
try {
setState(745);
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(738); constDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(739); interfaceMethodDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(740); genericInterfaceMethodDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(741); interfaceDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(742); annotationTypeDeclaration();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(743); classDeclaration();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(744); enumDeclaration();
}
break;
}
}
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 AnnotationTypeBodyContext annotationTypeBody() {
return getRuleContext(AnnotationTypeBodyContext.class,0);
}
public IdentifierRuleContext identifierRule() {
return getRuleContext(IdentifierRuleContext.class,0);
}
public AtRuleContext atRule() {
return getRuleContext(AtRuleContext.class,0);
}
public InterfaceRuleContext interfaceRule() {
return getRuleContext(InterfaceRuleContext.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 PJListener ) ((PJListener)listener).enterAnnotationTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAnnotationTypeDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAnnotationTypeDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 70, RULE_annotationTypeDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(747); atRule();
setState(748); interfaceRule();
setState(749); identifierRule();
setState(750); 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 List annotationTypeElementDeclaration() {
return getRuleContexts(AnnotationTypeElementDeclarationContext.class);
}
public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration(int i) {
return getRuleContext(AnnotationTypeElementDeclarationContext.class,i);
}
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 PJListener ) ((PJListener)listener).enterAnnotationTypeBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAnnotationTypeBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAnnotationTypeBody(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException {
AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState());
enterRule(_localctx, 72, RULE_annotationTypeBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(752); match(LBRACE);
setState(756);
_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 << VOLATILE) | (1L << SEMI))) != 0) || _la==AT || _la==Identifier) {
{
{
setState(753); annotationTypeElementDeclaration();
}
}
setState(758);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(759); 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 List modifier() {
return getRuleContexts(ModifierContext.class);
}
public AnnotationTypeElementRestContext annotationTypeElementRest() {
return getRuleContext(AnnotationTypeElementRestContext.class,0);
}
public ModifierContext modifier(int i) {
return getRuleContext(ModifierContext.class,i);
}
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 PJListener ) ((PJListener)listener).enterAnnotationTypeElementDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAnnotationTypeElementDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAnnotationTypeElementDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException {
AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState());
enterRule(_localctx, 74, RULE_annotationTypeElementDeclaration);
try {
int _alt;
setState(769);
switch (_input.LA(1)) {
case ABSTRACT:
case BOOLEAN:
case BYTE:
case CHAR:
case CLASS:
case DOUBLE:
case ENUM:
case FINAL:
case FLOAT:
case INT:
case INTERFACE:
case LONG:
case NATIVE:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case SHORT:
case STATIC:
case STRICTFP:
case SYNCHRONIZED:
case TRANSIENT:
case VOLATILE:
case AT:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(764);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(761); modifier();
}
}
}
setState(766);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
}
setState(767); annotationTypeElementRest();
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(768); 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 AnnotationTypeElementRestContext extends ParserRuleContext {
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
}
public AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() {
return getRuleContext(AnnotationMethodOrConstantRestContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public AnnotationTypeElementRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeElementRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterAnnotationTypeElementRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAnnotationTypeElementRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAnnotationTypeElementRest(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationTypeElementRestContext annotationTypeElementRest() throws RecognitionException {
AnnotationTypeElementRestContext _localctx = new AnnotationTypeElementRestContext(_ctx, getState());
enterRule(_localctx, 76, RULE_annotationTypeElementRest);
try {
setState(791);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(771); annotationTypeDeclaration();
setState(773);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
{
setState(772); match(SEMI);
}
break;
}
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(775); type();
setState(776); annotationMethodOrConstantRest();
setState(777); match(SEMI);
}
break;
case CLASS:
enterOuterAlt(_localctx, 3);
{
setState(779); classDeclaration();
setState(781);
switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
case 1:
{
setState(780); match(SEMI);
}
break;
}
}
break;
case INTERFACE:
enterOuterAlt(_localctx, 4);
{
setState(783); interfaceDeclaration();
setState(785);
switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
case 1:
{
setState(784); match(SEMI);
}
break;
}
}
break;
case ENUM:
enterOuterAlt(_localctx, 5);
{
setState(787); enumDeclaration();
setState(789);
switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
case 1:
{
setState(788); match(SEMI);
}
break;
}
}
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 AnnotationMethodOrConstantRestContext extends ParserRuleContext {
public AnnotationConstantRestContext annotationConstantRest() {
return getRuleContext(AnnotationConstantRestContext.class,0);
}
public AnnotationMethodRestContext annotationMethodRest() {
return getRuleContext(AnnotationMethodRestContext.class,0);
}
public AnnotationMethodOrConstantRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationMethodOrConstantRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterAnnotationMethodOrConstantRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAnnotationMethodOrConstantRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAnnotationMethodOrConstantRest(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() throws RecognitionException {
AnnotationMethodOrConstantRestContext _localctx = new AnnotationMethodOrConstantRestContext(_ctx, getState());
enterRule(_localctx, 78, RULE_annotationMethodOrConstantRest);
try {
setState(795);
switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(793); annotationMethodRest();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(794); annotationConstantRest();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationMethodRestContext extends ParserRuleContext {
public DefaultValueContext defaultValue() {
return getRuleContext(DefaultValueContext.class,0);
}
public LparenRuleContext lparenRule() {
return getRuleContext(LparenRuleContext.class,0);
}
public TerminalNode Identifier() { return getToken(PJParser.Identifier, 0); }
public RparenRuleContext rparenRule() {
return getRuleContext(RparenRuleContext.class,0);
}
public AnnotationMethodRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationMethodRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterAnnotationMethodRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAnnotationMethodRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAnnotationMethodRest(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationMethodRestContext annotationMethodRest() throws RecognitionException {
AnnotationMethodRestContext _localctx = new AnnotationMethodRestContext(_ctx, getState());
enterRule(_localctx, 80, RULE_annotationMethodRest);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(797); match(Identifier);
setState(798); lparenRule();
setState(799); rparenRule();
setState(801);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(800); defaultValue();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationConstantRestContext extends ParserRuleContext {
public VariableDeclaratorsContext variableDeclarators() {
return getRuleContext(VariableDeclaratorsContext.class,0);
}
public AnnotationConstantRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationConstantRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterAnnotationConstantRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAnnotationConstantRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAnnotationConstantRest(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationConstantRestContext annotationConstantRest() throws RecognitionException {
AnnotationConstantRestContext _localctx = new AnnotationConstantRestContext(_ctx, getState());
enterRule(_localctx, 82, RULE_annotationConstantRest);
try {
enterOuterAlt(_localctx, 1);
{
setState(803); variableDeclarators();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultValueContext extends ParserRuleContext {
public ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,0);
}
public DefaultValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterDefaultValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitDefaultValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitDefaultValue(this);
else return visitor.visitChildren(this);
}
}
public final DefaultValueContext defaultValue() throws RecognitionException {
DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState());
enterRule(_localctx, 84, RULE_defaultValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(805); match(DEFAULT);
setState(806); elementValue();
}
}
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 ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,0);
}
public LparenRuleContext lparenRule() {
return getRuleContext(LparenRuleContext.class,0);
}
public AtRuleContext atRule() {
return getRuleContext(AtRuleContext.class,0);
}
public ElementValuePairsContext elementValuePairs() {
return getRuleContext(ElementValuePairsContext.class,0);
}
public RparenRuleContext rparenRule() {
return getRuleContext(RparenRuleContext.class,0);
}
public AnnotationNameContext annotationName() {
return getRuleContext(AnnotationNameContext.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 PJListener ) ((PJListener)listener).enterAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAnnotation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAnnotation(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationContext annotation() throws RecognitionException {
AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
enterRule(_localctx, 86, RULE_annotation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(808); atRule();
setState(809); annotationName();
setState(817);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(810); lparenRule();
setState(813);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
{
setState(811); elementValuePairs();
}
break;
case 2:
{
setState(812); elementValue();
}
break;
}
setState(815); rparenRule();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationNameContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public AnnotationNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterAnnotationName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAnnotationName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAnnotationName(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationNameContext annotationName() throws RecognitionException {
AnnotationNameContext _localctx = new AnnotationNameContext(_ctx, getState());
enterRule(_localctx, 88, RULE_annotationName);
try {
enterOuterAlt(_localctx, 1);
{
setState(819); qualifiedName();
}
}
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 List elementValuePair() {
return getRuleContexts(ElementValuePairContext.class);
}
public ElementValuePairContext elementValuePair(int i) {
return getRuleContext(ElementValuePairContext.class,i);
}
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 PJListener ) ((PJListener)listener).enterElementValuePairs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitElementValuePairs(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitElementValuePairs(this);
else return visitor.visitChildren(this);
}
}
public final ElementValuePairsContext elementValuePairs() throws RecognitionException {
ElementValuePairsContext _localctx = new ElementValuePairsContext(_ctx, getState());
enterRule(_localctx, 90, RULE_elementValuePairs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(821); elementValuePair();
setState(826);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(822); match(COMMA);
setState(823); elementValuePair();
}
}
setState(828);
_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 Identifier() { return getToken(PJParser.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 PJListener ) ((PJListener)listener).enterElementValuePair(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitElementValuePair(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitElementValuePair(this);
else return visitor.visitChildren(this);
}
}
public final ElementValuePairContext elementValuePair() throws RecognitionException {
ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState());
enterRule(_localctx, 92, RULE_elementValuePair);
try {
enterOuterAlt(_localctx, 1);
{
setState(829); match(Identifier);
setState(830); match(ASSIGN);
setState(831); elementValue();
}
}
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(PJParser.ENUM, 0); }
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public EnumConstantsContext enumConstants() {
return getRuleContext(EnumConstantsContext.class,0);
}
public TerminalNode Identifier() { return getToken(PJParser.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 PJListener ) ((PJListener)listener).enterEnumDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitEnumDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitEnumDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
enterRule(_localctx, 94, RULE_enumDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(833); match(ENUM);
setState(834); match(Identifier);
setState(837);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(835); match(IMPLEMENTS);
setState(836); typeList();
}
}
setState(839); match(LBRACE);
setState(841);
_la = _input.LA(1);
if (_la==AT || _la==Identifier) {
{
setState(840); enumConstants();
}
}
setState(844);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(843); match(COMMA);
}
}
setState(847);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(846); enumBodyDeclarations();
}
}
setState(849); 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 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 PJListener ) ((PJListener)listener).enterEnumConstants(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitEnumConstants(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitEnumConstants(this);
else return visitor.visitChildren(this);
}
}
public final EnumConstantsContext enumConstants() throws RecognitionException {
EnumConstantsContext _localctx = new EnumConstantsContext(_ctx, getState());
enterRule(_localctx, 96, RULE_enumConstants);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(851); enumConstant();
setState(856);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,69,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(852); match(COMMA);
setState(853); enumConstant();
}
}
}
setState(858);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,69,_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(PJParser.Identifier, 0); }
public List 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 PJListener ) ((PJListener)listener).enterEnumConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitEnumConstant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitEnumConstant(this);
else return visitor.visitChildren(this);
}
}
public final EnumConstantContext enumConstant() throws RecognitionException {
EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
enterRule(_localctx, 98, RULE_enumConstant);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(862);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(859); annotation();
}
}
setState(864);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(865); match(Identifier);
setState(867);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(866); arguments();
}
}
setState(870);
_la = _input.LA(1);
if (_la==COLON || _la==INDENT) {
{
setState(869); 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 EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumBodyDeclarations; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterEnumBodyDeclarations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitEnumBodyDeclarations(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitEnumBodyDeclarations(this);
else return visitor.visitChildren(this);
}
}
public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
enterRule(_localctx, 100, RULE_enumBodyDeclarations);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(872); match(SEMI);
setState(876);
_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 << LT))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (COLON - 66)) | (1L << (AT - 66)) | (1L << (Identifier - 66)) | (1L << (INDENT - 66)))) != 0)) {
{
{
setState(873); classBodyDeclaration();
}
}
setState(878);
_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 BlockContext extends ParserRuleContext {
public List blockStatement() {
return getRuleContexts(BlockStatementContext.class);
}
public TerminalNode INDENT() { return getToken(PJParser.INDENT, 0); }
public BlockStatementContext blockStatement(int i) {
return getRuleContext(BlockStatementContext.class,i);
}
public TerminalNode DEDENT() { return getToken(PJParser.DEDENT, 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 PJListener ) ((PJListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitBlock(this);
else return visitor.visitChildren(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 102, RULE_block);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(880);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(879); match(COLON);
}
}
setState(882); match(INDENT);
setState(886);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TRY) | (1L << VOID) | (1L << WHILE) | (1L << LPAREN) | (1L << LT) | (1L << BANG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TILDE - 64)) | (1L << (COLON - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (AT - 64)) | (1L << (NullLiteral - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (Identifier - 64)) | (1L << (INDENT - 64)))) != 0)) {
{
{
setState(883); blockStatement();
}
}
setState(888);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(889); match(DEDENT);
}
}
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 TypeDeclarationContext typeDeclaration() {
return getRuleContext(TypeDeclarationContext.class,0);
}
public LocalVariableDeclarationContext localVariableDeclaration() {
return getRuleContext(LocalVariableDeclarationContext.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 PJListener ) ((PJListener)listener).enterBlockStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitBlockStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitBlockStatement(this);
else return visitor.visitChildren(this);
}
}
public final BlockStatementContext blockStatement() throws RecognitionException {
BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState());
enterRule(_localctx, 104, RULE_blockStatement);
try {
setState(894);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(891); localVariableDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(892); statement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(893); typeDeclaration();
}
break;
}
}
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 variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableDeclaratorsContext variableDeclarators() {
return getRuleContext(VariableDeclaratorsContext.class,0);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.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 PJListener ) ((PJListener)listener).enterLocalVariableDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitLocalVariableDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitLocalVariableDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException {
LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState());
enterRule(_localctx, 106, RULE_localVariableDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(899);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(896); variableModifier();
}
}
setState(901);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(902); type();
setState(903); variableDeclarators();
}
}
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 StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
public StatementContext() { }
public void copyFrom(StatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class CommalessStatementContext extends StatementContext {
public StatementsCommalessContext statementsCommaless() {
return getRuleContext(StatementsCommalessContext.class,0);
}
public CommalessStatementContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterCommalessStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitCommalessStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitCommalessStatement(this);
else return visitor.visitChildren(this);
}
}
public static class IdentifierStamentContext extends StatementContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public IdentifierRuleContext identifierRule() {
return getRuleContext(IdentifierRuleContext.class,0);
}
public IdentifierStamentContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterIdentifierStament(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitIdentifierStament(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitIdentifierStament(this);
else return visitor.visitChildren(this);
}
}
public static class SwitchStatementContext extends StatementContext {
public SwitchLabelContext switchLabel(int i) {
return getRuleContext(SwitchLabelContext.class,i);
}
public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) {
return getRuleContext(SwitchBlockStatementGroupContext.class,i);
}
public List switchLabel() {
return getRuleContexts(SwitchLabelContext.class);
}
public ParExpressionContext parExpression() {
return getRuleContext(ParExpressionContext.class,0);
}
public List switchBlockStatementGroup() {
return getRuleContexts(SwitchBlockStatementGroupContext.class);
}
public SwitchStatementContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterSwitchStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitSwitchStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitSwitchStatement(this);
else return visitor.visitChildren(this);
}
}
public static class TryStatementContext extends StatementContext {
public ResourceSpecificationContext resourceSpecification() {
return getRuleContext(ResourceSpecificationContext.class,0);
}
public TryRuleContext tryRule() {
return getRuleContext(TryRuleContext.class,0);
}
public CatchClauseContext catchClause(int i) {
return getRuleContext(CatchClauseContext.class,i);
}
public List catchClause() {
return getRuleContexts(CatchClauseContext.class);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public FinallyBlockContext finallyBlock() {
return getRuleContext(FinallyBlockContext.class,0);
}
public TryStatementContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterTryStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTryStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTryStatement(this);
else return visitor.visitChildren(this);
}
}
public static class ForStatementContext extends StatementContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public ForControlContext forControl() {
return getRuleContext(ForControlContext.class,0);
}
public ForRuleContext forRule() {
return getRuleContext(ForRuleContext.class,0);
}
public ForStatementContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterForStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitForStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitForStatement(this);
else return visitor.visitChildren(this);
}
}
public static class WhileStatementContext extends StatementContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public ParExpressionContext parExpression() {
return getRuleContext(ParExpressionContext.class,0);
}
public WhileStatementContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterWhileStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitWhileStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitWhileStatement(this);
else return visitor.visitChildren(this);
}
}
public static class SynchronizedStatementContext extends StatementContext {
public ParExpressionContext parExpression() {
return getRuleContext(ParExpressionContext.class,0);
}
public SynchronizedRuleContext synchronizedRule() {
return getRuleContext(SynchronizedRuleContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public SynchronizedStatementContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterSynchronizedStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitSynchronizedStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitSynchronizedStatement(this);
else return visitor.visitChildren(this);
}
}
public static class SimpleBlockStatementContext extends StatementContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public SimpleBlockStatementContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterSimpleBlockStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitSimpleBlockStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitSimpleBlockStatement(this);
else return visitor.visitChildren(this);
}
}
public static class IfStatementContext extends StatementContext {
public List statement() {
return getRuleContexts(StatementContext.class);
}
public IfRuleContext ifRule() {
return getRuleContext(IfRuleContext.class,0);
}
public ParExpressionContext parExpression() {
return getRuleContext(ParExpressionContext.class,0);
}
public ElseRuleContext elseRule() {
return getRuleContext(ElseRuleContext.class,0);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public IfStatementContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterIfStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitIfStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitIfStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 108, RULE_statement);
int _la;
try {
int _alt;
setState(973);
switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
case 1:
_localctx = new SimpleBlockStatementContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(905); block();
}
break;
case 2:
_localctx = new CommalessStatementContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(906); statementsCommaless();
}
break;
case 3:
_localctx = new IfStatementContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(907); ifRule();
setState(908); parExpression();
setState(909); statement();
setState(913);
switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
case 1:
{
setState(910); elseRule();
setState(911); statement();
}
break;
}
}
break;
case 4:
_localctx = new ForStatementContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(915); forRule();
setState(916); forControl();
setState(917); statement();
}
break;
case 5:
_localctx = new WhileStatementContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(919); match(WHILE);
setState(920); parExpression();
setState(921); statement();
}
break;
case 6:
_localctx = new TryStatementContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(923); tryRule();
setState(924); block();
setState(934);
switch (_input.LA(1)) {
case CATCH:
{
setState(926);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(925); catchClause();
}
}
setState(928);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==CATCH );
setState(931);
_la = _input.LA(1);
if (_la==FINALLY) {
{
setState(930); finallyBlock();
}
}
}
break;
case FINALLY:
{
setState(933); finallyBlock();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 7:
_localctx = new TryStatementContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(936); tryRule();
setState(937); resourceSpecification();
setState(938); block();
setState(942);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CATCH) {
{
{
setState(939); catchClause();
}
}
setState(944);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(946);
_la = _input.LA(1);
if (_la==FINALLY) {
{
setState(945); finallyBlock();
}
}
}
break;
case 8:
_localctx = new SwitchStatementContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(948); match(SWITCH);
setState(949); parExpression();
setState(950); match(LBRACE);
setState(954);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,84,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(951); switchBlockStatementGroup();
}
}
}
setState(956);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,84,_ctx);
}
setState(960);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CASE || _la==DEFAULT) {
{
{
setState(957); switchLabel();
}
}
setState(962);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(963); match(RBRACE);
}
break;
case 9:
_localctx = new SynchronizedStatementContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(965); synchronizedRule();
setState(966); parExpression();
setState(967); block();
}
break;
case 10:
_localctx = new IdentifierStamentContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(969); identifierRule();
setState(970); match(COLON);
setState(971); statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementsCommalessContext extends ParserRuleContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public ReturnRuleContext returnRule() {
return getRuleContext(ReturnRuleContext.class,0);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public IdentifierRuleContext identifierRule() {
return getRuleContext(IdentifierRuleContext.class,0);
}
public ThrowRuleContext throwRule() {
return getRuleContext(ThrowRuleContext.class,0);
}
public ParExpressionContext parExpression() {
return getRuleContext(ParExpressionContext.class,0);
}
public AssertRuleContext assertRule() {
return getRuleContext(AssertRuleContext.class,0);
}
public BreakRuleContext breakRule() {
return getRuleContext(BreakRuleContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public WhileRuleContext whileRule() {
return getRuleContext(WhileRuleContext.class,0);
}
public ContinueRuleContext continueRule() {
return getRuleContext(ContinueRuleContext.class,0);
}
public DoRuleContext doRule() {
return getRuleContext(DoRuleContext.class,0);
}
public StatementsCommalessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statementsCommaless; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterStatementsCommaless(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitStatementsCommaless(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitStatementsCommaless(this);
else return visitor.visitChildren(this);
}
}
public final StatementsCommalessContext statementsCommaless() throws RecognitionException {
StatementsCommalessContext _localctx = new StatementsCommalessContext(_ctx, getState());
enterRule(_localctx, 110, RULE_statementsCommaless);
try {
setState(1002);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case LPAREN:
case LT:
case BANG:
case TILDE:
case INC:
case DEC:
case ADD:
case SUB:
case NullLiteral:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case IntegerLiteral:
case FloatingPointLiteral:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(975); expression(0);
}
break;
case RETURN:
enterOuterAlt(_localctx, 2);
{
setState(976); returnRule();
setState(978);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(977); expression(0);
}
break;
}
}
break;
case THROW:
enterOuterAlt(_localctx, 3);
{
setState(980); throwRule();
setState(981); expression(0);
}
break;
case BREAK:
enterOuterAlt(_localctx, 4);
{
setState(983); breakRule();
setState(985);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(984); identifierRule();
}
break;
}
}
break;
case CONTINUE:
enterOuterAlt(_localctx, 5);
{
setState(987); continueRule();
setState(989);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
{
setState(988); identifierRule();
}
break;
}
}
break;
case ASSERT:
enterOuterAlt(_localctx, 6);
{
setState(991); assertRule();
setState(992); expression(0);
setState(995);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
{
setState(993); match(COLON);
setState(994); expression(0);
}
break;
}
}
break;
case DO:
enterOuterAlt(_localctx, 7);
{
setState(997); doRule();
setState(998); statement();
setState(999); whileRule();
setState(1000); parExpression();
}
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 ParExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,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 PJListener ) ((PJListener)listener).enterParExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitParExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitParExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParExpressionContext parExpression() throws RecognitionException {
ParExpressionContext _localctx = new ParExpressionContext(_ctx, getState());
enterRule(_localctx, 112, RULE_parExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1004); expression(0);
}
}
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 CatchDeclarationContext catchDeclaration() {
return getRuleContext(CatchDeclarationContext.class,0);
}
public CatchRuleContext catchRule() {
return getRuleContext(CatchRuleContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.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 PJListener ) ((PJListener)listener).enterCatchClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitCatchClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitCatchClause(this);
else return visitor.visitChildren(this);
}
}
public final CatchClauseContext catchClause() throws RecognitionException {
CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState());
enterRule(_localctx, 114, RULE_catchClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1006); catchRule();
setState(1007); catchDeclaration();
setState(1008); block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchDeclarationContext extends ParserRuleContext {
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public IdentifierRuleContext identifierRule() {
return getRuleContext(IdentifierRuleContext.class,0);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public CatchTypeContext catchType() {
return getRuleContext(CatchTypeContext.class,0);
}
public CatchDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterCatchDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitCatchDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitCatchDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final CatchDeclarationContext catchDeclaration() throws RecognitionException {
CatchDeclarationContext _localctx = new CatchDeclarationContext(_ctx, getState());
enterRule(_localctx, 116, RULE_catchDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1013);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1010); variableModifier();
}
}
setState(1015);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1016); catchType();
setState(1017); identifierRule();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchTypeContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName(int i) {
return getRuleContext(QualifiedNameContext.class,i);
}
public List qualifiedName() {
return getRuleContexts(QualifiedNameContext.class);
}
public CatchTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterCatchType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitCatchType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitCatchType(this);
else return visitor.visitChildren(this);
}
}
public final CatchTypeContext catchType() throws RecognitionException {
CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState());
enterRule(_localctx, 118, RULE_catchType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1019); qualifiedName();
setState(1024);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BITOR) {
{
{
setState(1020); match(BITOR);
setState(1021); qualifiedName();
}
}
setState(1026);
_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 FinallyBlockContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public FinallyRuleContext finallyRule() {
return getRuleContext(FinallyRuleContext.class,0);
}
public FinallyBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_finallyBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterFinallyBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitFinallyBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitFinallyBlock(this);
else return visitor.visitChildren(this);
}
}
public final FinallyBlockContext finallyBlock() throws RecognitionException {
FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState());
enterRule(_localctx, 120, RULE_finallyBlock);
try {
enterOuterAlt(_localctx, 1);
{
setState(1027); finallyRule();
setState(1028); 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 PJListener ) ((PJListener)listener).enterResourceSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitResourceSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitResourceSpecification(this);
else return visitor.visitChildren(this);
}
}
public final ResourceSpecificationContext resourceSpecification() throws RecognitionException {
ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState());
enterRule(_localctx, 122, RULE_resourceSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1030); match(LPAREN);
setState(1031); resources();
setState(1033);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(1032); match(SEMI);
}
}
setState(1035); 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 List resource() {
return getRuleContexts(ResourceContext.class);
}
public ResourceContext resource(int i) {
return getRuleContext(ResourceContext.class,i);
}
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 PJListener ) ((PJListener)listener).enterResources(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitResources(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitResources(this);
else return visitor.visitChildren(this);
}
}
public final ResourcesContext resources() throws RecognitionException {
ResourcesContext _localctx = new ResourcesContext(_ctx, getState());
enterRule(_localctx, 124, RULE_resources);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1037); resource();
setState(1042);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1038); match(SEMI);
setState(1039); resource();
}
}
}
setState(1044);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_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 List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.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 PJListener ) ((PJListener)listener).enterResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitResource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitResource(this);
else return visitor.visitChildren(this);
}
}
public final ResourceContext resource() throws RecognitionException {
ResourceContext _localctx = new ResourceContext(_ctx, getState());
enterRule(_localctx, 126, RULE_resource);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1048);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1045); variableModifier();
}
}
setState(1050);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1051); classOrInterfaceType();
setState(1052); variableDeclaratorId();
setState(1053); match(ASSIGN);
setState(1054); expression(0);
}
}
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 List blockStatement() {
return getRuleContexts(BlockStatementContext.class);
}
public SwitchLabelContext switchLabel(int i) {
return getRuleContext(SwitchLabelContext.class,i);
}
public List switchLabel() {
return getRuleContexts(SwitchLabelContext.class);
}
public BlockStatementContext blockStatement(int i) {
return getRuleContext(BlockStatementContext.class,i);
}
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 PJListener ) ((PJListener)listener).enterSwitchBlockStatementGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitSwitchBlockStatementGroup(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitSwitchBlockStatementGroup(this);
else return visitor.visitChildren(this);
}
}
public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException {
SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState());
enterRule(_localctx, 128, RULE_switchBlockStatementGroup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1057);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1056); switchLabel();
}
}
setState(1059);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==CASE || _la==DEFAULT );
setState(1062);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1061); blockStatement();
}
}
setState(1064);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TRY) | (1L << VOID) | (1L << WHILE) | (1L << LPAREN) | (1L << LT) | (1L << BANG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TILDE - 64)) | (1L << (COLON - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (AT - 64)) | (1L << (NullLiteral - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (Identifier - 64)) | (1L << (INDENT - 64)))) != 0) );
}
}
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 ConstantExpressionContext constantExpression() {
return getRuleContext(ConstantExpressionContext.class,0);
}
public EnumConstantNameContext enumConstantName() {
return getRuleContext(EnumConstantNameContext.class,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 PJListener ) ((PJListener)listener).enterSwitchLabel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitSwitchLabel(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitSwitchLabel(this);
else return visitor.visitChildren(this);
}
}
public final SwitchLabelContext switchLabel() throws RecognitionException {
SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState());
enterRule(_localctx, 130, RULE_switchLabel);
try {
setState(1076);
switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1066); match(CASE);
setState(1067); constantExpression();
setState(1068); match(COLON);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1070); match(CASE);
setState(1071); enumConstantName();
setState(1072); match(COLON);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1074); match(DEFAULT);
setState(1075); match(COLON);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ConstantExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterConstantExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitConstantExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitConstantExpression(this);
else return visitor.visitChildren(this);
}
}
public final ConstantExpressionContext constantExpression() throws RecognitionException {
ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState());
enterRule(_localctx, 132, RULE_constantExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1078); expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantNameContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(PJParser.Identifier, 0); }
public EnumConstantNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstantName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterEnumConstantName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitEnumConstantName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitEnumConstantName(this);
else return visitor.visitChildren(this);
}
}
public final EnumConstantNameContext enumConstantName() throws RecognitionException {
EnumConstantNameContext _localctx = new EnumConstantNameContext(_ctx, getState());
enterRule(_localctx, 134, RULE_enumConstantName);
try {
enterOuterAlt(_localctx, 1);
{
setState(1080); match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForControlContext extends ParserRuleContext {
public ForInitContext forInit() {
return getRuleContext(ForInitContext.class,0);
}
public EnhancedForControlContext enhancedForControl() {
return getRuleContext(EnhancedForControlContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ForUpdateContext forUpdate() {
return getRuleContext(ForUpdateContext.class,0);
}
public ForControlContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forControl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterForControl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitForControl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitForControl(this);
else return visitor.visitChildren(this);
}
}
public final ForControlContext forControl() throws RecognitionException {
ForControlContext _localctx = new ForControlContext(_ctx, getState());
enterRule(_localctx, 136, RULE_forControl);
int _la;
try {
setState(1094);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1082); enhancedForControl();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1084);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << LPAREN) | (1L << LT) | (1L << BANG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (AT - 64)) | (1L << (NullLiteral - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(1083); forInit();
}
}
setState(1086); match(SEMI);
setState(1088);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << LPAREN) | (1L << LT) | (1L << BANG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (NullLiteral - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(1087); expression(0);
}
}
setState(1090); match(SEMI);
setState(1092);
switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
case 1:
{
setState(1091); forUpdate();
}
break;
}
}
break;
}
}
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 PJListener ) ((PJListener)listener).enterForInit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitForInit(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitForInit(this);
else return visitor.visitChildren(this);
}
}
public final ForInitContext forInit() throws RecognitionException {
ForInitContext _localctx = new ForInitContext(_ctx, getState());
enterRule(_localctx, 138, RULE_forInit);
try {
setState(1098);
switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1096); localVariableDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1097); expressionList();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnhancedForControlContext extends ParserRuleContext {
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public ColonRuleContext colonRule() {
return getRuleContext(ColonRuleContext.class,0);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public EnhancedForControlContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enhancedForControl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterEnhancedForControl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitEnhancedForControl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitEnhancedForControl(this);
else return visitor.visitChildren(this);
}
}
public final EnhancedForControlContext enhancedForControl() throws RecognitionException {
EnhancedForControlContext _localctx = new EnhancedForControlContext(_ctx, getState());
enterRule(_localctx, 140, RULE_enhancedForControl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1103);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1100); variableModifier();
}
}
setState(1105);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1106); type();
setState(1107); variableDeclaratorId();
setState(1108); colonRule();
setState(1109); expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForUpdateContext extends ParserRuleContext {
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public ForUpdateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forUpdate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterForUpdate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitForUpdate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitForUpdate(this);
else return visitor.visitChildren(this);
}
}
public final ForUpdateContext forUpdate() throws RecognitionException {
ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState());
enterRule(_localctx, 142, RULE_forUpdate);
try {
enterOuterAlt(_localctx, 1);
{
setState(1111); expressionList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableDeclaratorsContext extends ParserRuleContext {
public VariableDeclaratorContext variableDeclarator(int i) {
return getRuleContext(VariableDeclaratorContext.class,i);
}
public List variableDeclarator() {
return getRuleContexts(VariableDeclaratorContext.class);
}
public VariableDeclaratorsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclarators; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterVariableDeclarators(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitVariableDeclarators(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitVariableDeclarators(this);
else return visitor.visitChildren(this);
}
}
public final VariableDeclaratorsContext variableDeclarators() throws RecognitionException {
VariableDeclaratorsContext _localctx = new VariableDeclaratorsContext(_ctx, getState());
enterRule(_localctx, 144, RULE_variableDeclarators);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1113); variableDeclarator();
setState(1118);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1114); match(COMMA);
setState(1115); variableDeclarator();
}
}
setState(1120);
_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 VariableDeclaratorContext extends ParserRuleContext {
public AssignRuleContext assignRule() {
return getRuleContext(AssignRuleContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public VariableInitializerContext variableInitializer() {
return getRuleContext(VariableInitializerContext.class,0);
}
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 PJListener ) ((PJListener)listener).enterVariableDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitVariableDeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitVariableDeclarator(this);
else return visitor.visitChildren(this);
}
}
public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
enterRule(_localctx, 146, RULE_variableDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1121); variableDeclaratorId();
setState(1125);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(1122); assignRule();
setState(1123); variableInitializer();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableDeclaratorIdContext extends ParserRuleContext {
public RbraceRuleContext rbraceRule(int i) {
return getRuleContext(RbraceRuleContext.class,i);
}
public List rbraceRule() {
return getRuleContexts(RbraceRuleContext.class);
}
public IdentifierRuleContext identifierRule() {
return getRuleContext(IdentifierRuleContext.class,0);
}
public LbraceRuleContext lbraceRule(int i) {
return getRuleContext(LbraceRuleContext.class,i);
}
public List lbraceRule() {
return getRuleContexts(LbraceRuleContext.class);
}
public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclaratorId; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterVariableDeclaratorId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitVariableDeclaratorId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitVariableDeclaratorId(this);
else return visitor.visitChildren(this);
}
}
public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
enterRule(_localctx, 148, RULE_variableDeclaratorId);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1127); identifierRule();
setState(1133);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACE) {
{
{
setState(1128); lbraceRule();
setState(1129); rbraceRule();
}
}
setState(1135);
_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 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 PJListener ) ((PJListener)listener).enterVariableInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitVariableInitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitVariableInitializer(this);
else return visitor.visitChildren(this);
}
}
public final VariableInitializerContext variableInitializer() throws RecognitionException {
VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
enterRule(_localctx, 150, RULE_variableInitializer);
try {
setState(1138);
switch (_input.LA(1)) {
case LBRACE:
enterOuterAlt(_localctx, 1);
{
setState(1136); arrayInitializer();
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case LPAREN:
case LT:
case BANG:
case TILDE:
case INC:
case DEC:
case ADD:
case SUB:
case NullLiteral:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case IntegerLiteral:
case FloatingPointLiteral:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(1137); expression(0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayInitializerContext extends ParserRuleContext {
public VariableInitializerContext variableInitializer(int i) {
return getRuleContext(VariableInitializerContext.class,i);
}
public List variableInitializer() {
return getRuleContexts(VariableInitializerContext.class);
}
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 PJListener ) ((PJListener)listener).enterArrayInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitArrayInitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitArrayInitializer(this);
else return visitor.visitChildren(this);
}
}
public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
enterRule(_localctx, 152, RULE_arrayInitializer);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1140); match(LBRACE);
setState(1152);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << LPAREN) | (1L << LBRACE) | (1L << LT) | (1L << BANG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (NullLiteral - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(1141); variableInitializer();
setState(1146);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,110,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1142); match(COMMA);
setState(1143); variableInitializer();
}
}
}
setState(1148);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,110,_ctx);
}
setState(1150);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1149); match(COMMA);
}
}
}
}
setState(1154); match(RBRACE);
}
}
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 FinalRuleContext finalRule() {
return getRuleContext(FinalRuleContext.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 PJListener ) ((PJListener)listener).enterVariableModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitVariableModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitVariableModifier(this);
else return visitor.visitChildren(this);
}
}
public final VariableModifierContext variableModifier() throws RecognitionException {
VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());
enterRule(_localctx, 154, RULE_variableModifier);
try {
setState(1158);
switch (_input.LA(1)) {
case FINAL:
enterOuterAlt(_localctx, 1);
{
setState(1156); finalRule();
}
break;
case AT:
enterOuterAlt(_localctx, 2);
{
setState(1157); 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 TypeParametersContext extends ParserRuleContext {
public List 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 PJListener ) ((PJListener)listener).enterTypeParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTypeParameters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTypeParameters(this);
else return visitor.visitChildren(this);
}
}
public final TypeParametersContext typeParameters() throws RecognitionException {
TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
enterRule(_localctx, 156, RULE_typeParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1160); match(LT);
setState(1161); typeParameter();
setState(1166);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1162); match(COMMA);
setState(1163); typeParameter();
}
}
setState(1168);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1169); 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(PJParser.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 PJListener ) ((PJListener)listener).enterTypeParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTypeParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTypeParameter(this);
else return visitor.visitChildren(this);
}
}
public final TypeParameterContext typeParameter() throws RecognitionException {
TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
enterRule(_localctx, 158, RULE_typeParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1171); match(Identifier);
setState(1174);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(1172); match(EXTENDS);
setState(1173); 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 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 PJListener ) ((PJListener)listener).enterTypeBound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTypeBound(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTypeBound(this);
else return visitor.visitChildren(this);
}
}
public final TypeBoundContext typeBound() throws RecognitionException {
TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());
enterRule(_localctx, 160, RULE_typeBound);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1176); type();
setState(1181);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BITAND) {
{
{
setState(1177); match(BITAND);
setState(1178); type();
}
}
setState(1183);
_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 TypeListContext extends ParserRuleContext {
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 PJListener ) ((PJListener)listener).enterTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTypeList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTypeList(this);
else return visitor.visitChildren(this);
}
}
public final TypeListContext typeList() throws RecognitionException {
TypeListContext _localctx = new TypeListContext(_ctx, getState());
enterRule(_localctx, 162, RULE_typeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1184); type();
setState(1189);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1185); match(COMMA);
setState(1186); type();
}
}
setState(1191);
_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 TypeContext extends ParserRuleContext {
public List rbrackRule() {
return getRuleContexts(RbrackRuleContext.class);
}
public List lbrackRule() {
return getRuleContexts(LbrackRuleContext.class);
}
public RbrackRuleContext rbrackRule(int i) {
return getRuleContext(RbrackRuleContext.class,i);
}
public LbrackRuleContext lbrackRule(int i) {
return getRuleContext(LbrackRuleContext.class,i);
}
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
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 PJListener ) ((PJListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitType(this);
else return visitor.visitChildren(this);
}
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 164, RULE_type);
try {
int _alt;
setState(1210);
switch (_input.LA(1)) {
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1192); classOrInterfaceType();
setState(1198);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,118,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1193); lbrackRule();
setState(1194); rbrackRule();
}
}
}
setState(1200);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,118,_ctx);
}
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
enterOuterAlt(_localctx, 2);
{
setState(1201); primitiveType();
setState(1207);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,119,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1202); lbrackRule();
setState(1203); rbrackRule();
}
}
}
setState(1209);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,119,_ctx);
}
}
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 List dotRule() {
return getRuleContexts(DotRuleContext.class);
}
public TypeArgumentsContext typeArguments(int i) {
return getRuleContext(TypeArgumentsContext.class,i);
}
public List identifierRule() {
return getRuleContexts(IdentifierRuleContext.class);
}
public IdentifierRuleContext identifierRule(int i) {
return getRuleContext(IdentifierRuleContext.class,i);
}
public List typeArguments() {
return getRuleContexts(TypeArgumentsContext.class);
}
public DotRuleContext dotRule(int i) {
return getRuleContext(DotRuleContext.class,i);
}
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 PJListener ) ((PJListener)listener).enterClassOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitClassOrInterfaceType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitClassOrInterfaceType(this);
else return visitor.visitChildren(this);
}
}
public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 166, RULE_classOrInterfaceType);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1212); identifierRule();
setState(1214);
switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
case 1:
{
setState(1213); typeArguments();
}
break;
}
setState(1223);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,123,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1216); dotRule();
setState(1217); identifierRule();
setState(1219);
switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
case 1:
{
setState(1218); typeArguments();
}
break;
}
}
}
}
setState(1225);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,123,_ctx);
}
}
}
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 List commaRule() {
return getRuleContexts(CommaRuleContext.class);
}
public List typeArgument() {
return getRuleContexts(TypeArgumentContext.class);
}
public LtRuleContext ltRule() {
return getRuleContext(LtRuleContext.class,0);
}
public GtRuleContext gtRule() {
return getRuleContext(GtRuleContext.class,0);
}
public TypeArgumentContext typeArgument(int i) {
return getRuleContext(TypeArgumentContext.class,i);
}
public CommaRuleContext commaRule(int i) {
return getRuleContext(CommaRuleContext.class,i);
}
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 PJListener ) ((PJListener)listener).enterTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTypeArguments(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTypeArguments(this);
else return visitor.visitChildren(this);
}
}
public final TypeArgumentsContext typeArguments() throws RecognitionException {
TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 168, RULE_typeArguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1226); ltRule();
setState(1227); typeArgument();
setState(1233);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1228); commaRule();
setState(1229); typeArgument();
}
}
setState(1235);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1236); gtRule();
}
}
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 TypeContext type() {
return getRuleContext(TypeContext.class,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 PJListener ) ((PJListener)listener).enterTypeArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTypeArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTypeArgument(this);
else return visitor.visitChildren(this);
}
}
public final TypeArgumentContext typeArgument() throws RecognitionException {
TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
enterRule(_localctx, 170, RULE_typeArgument);
int _la;
try {
setState(1244);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1238); type();
}
break;
case QUESTION:
enterOuterAlt(_localctx, 2);
{
setState(1239); match(QUESTION);
setState(1242);
_la = _input.LA(1);
if (_la==EXTENDS || _la==SUPER) {
{
setState(1240);
_la = _input.LA(1);
if ( !(_la==EXTENDS || _la==SUPER) ) {
_errHandler.recoverInline(this);
}
consume();
setState(1241); 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 TypeArgumentsOrDiamondContext extends ParserRuleContext {
public LtRuleContext ltRule() {
return getRuleContext(LtRuleContext.class,0);
}
public GtRuleContext gtRule() {
return getRuleContext(GtRuleContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterTypeArgumentsOrDiamond(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTypeArgumentsOrDiamond(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTypeArgumentsOrDiamond(this);
else return visitor.visitChildren(this);
}
}
public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException {
TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState());
enterRule(_localctx, 172, RULE_typeArgumentsOrDiamond);
try {
setState(1250);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1246); ltRule();
setState(1247); gtRule();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1249); 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 PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primitiveType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterPrimitiveType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitPrimitiveType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitPrimitiveType(this);
else return visitor.visitChildren(this);
}
}
public final PrimitiveTypeContext primitiveType() throws RecognitionException {
PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
enterRule(_localctx, 174, RULE_primitiveType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1252);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 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 ExpressionListContext extends ParserRuleContext {
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List commaRule() {
return getRuleContexts(CommaRuleContext.class);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public CommaRuleContext commaRule(int i) {
return getRuleContext(CommaRuleContext.class,i);
}
public ExpressionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitExpressionList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitExpressionList(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionListContext expressionList() throws RecognitionException {
ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
enterRule(_localctx, 176, RULE_expressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1254); expression(0);
setState(1260);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1255); commaRule();
setState(1256); expression(0);
}
}
setState(1262);
_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 ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public RbrackRuleContext rbrackRule() {
return getRuleContext(RbrackRuleContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public GtRuleContext gtRule(int i) {
return getRuleContext(GtRuleContext.class,i);
}
public EqualRuleContext equalRule() {
return getRuleContext(EqualRuleContext.class,0);
}
public NotEqualRuleContext notEqualRule() {
return getRuleContext(NotEqualRuleContext.class,0);
}
public AddRuleContext addRule() {
return getRuleContext(AddRuleContext.class,0);
}
public GeRuleContext geRule() {
return getRuleContext(GeRuleContext.class,0);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public AssignRuleContext assignRule() {
return getRuleContext(AssignRuleContext.class,0);
}
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public ColonRuleContext colonRule() {
return getRuleContext(ColonRuleContext.class,0);
}
public LeRuleContext leRule() {
return getRuleContext(LeRuleContext.class,0);
}
public SuperSuffixContext superSuffix() {
return getRuleContext(SuperSuffixContext.class,0);
}
public List gtRule() {
return getRuleContexts(GtRuleContext.class);
}
public NewRuleContext newRule() {
return getRuleContext(NewRuleContext.class,0);
}
public DecRuleContext decRule() {
return getRuleContext(DecRuleContext.class,0);
}
public RparenRuleContext rparenRule() {
return getRuleContext(RparenRuleContext.class,0);
}
public InnerCreatorContext innerCreator() {
return getRuleContext(InnerCreatorContext.class,0);
}
public List ltRule() {
return getRuleContexts(LtRuleContext.class);
}
public LtRuleContext ltRule(int i) {
return getRuleContext(LtRuleContext.class,i);
}
public LparenRuleContext lparenRule() {
return getRuleContext(LparenRuleContext.class,0);
}
public LbrackRuleContext lbrackRule() {
return getRuleContext(LbrackRuleContext.class,0);
}
public CreatorContext creator() {
return getRuleContext(CreatorContext.class,0);
}
public DotRuleContext dotRule() {
return getRuleContext(DotRuleContext.class,0);
}
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public ExplicitGenericInvocationContext explicitGenericInvocation() {
return getRuleContext(ExplicitGenericInvocationContext.class,0);
}
public IdentifierRuleContext identifierRule() {
return getRuleContext(IdentifierRuleContext.class,0);
}
public IncRuleContext incRule() {
return getRuleContext(IncRuleContext.class,0);
}
public QuestionRuleContext questionRule() {
return getRuleContext(QuestionRuleContext.class,0);
}
public SubRuleContext subRule() {
return getRuleContext(SubRuleContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.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 PJListener ) ((PJListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 178;
enterRecursionRule(_localctx, 178, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1283);
switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
case 1:
{
setState(1264); lparenRule();
setState(1265); type();
setState(1266); rparenRule();
setState(1267); expression(17);
}
break;
case 2:
{
setState(1273);
switch (_input.LA(1)) {
case ADD:
{
setState(1269); addRule();
}
break;
case SUB:
{
setState(1270); subRule();
}
break;
case INC:
{
setState(1271); incRule();
}
break;
case DEC:
{
setState(1272); decRule();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1275); expression(15);
}
break;
case 3:
{
setState(1277);
_la = _input.LA(1);
if ( !(_la==BANG || _la==TILDE) ) {
_errHandler.recoverInline(this);
}
consume();
setState(1278); expression(14);
}
break;
case 4:
{
setState(1279); primary();
}
break;
case 5:
{
setState(1280); newRule();
setState(1281); creator();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1410);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,140,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1408);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1285);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(1286);
_la = _input.LA(1);
if ( !(((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (MUL - 77)) | (1L << (DIV - 77)) | (1L << (MOD - 77)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
setState(1287); expression(14);
}
break;
case 2:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1288);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(1291);
switch (_input.LA(1)) {
case ADD:
{
setState(1289); addRule();
}
break;
case SUB:
{
setState(1290); subRule();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1293); expression(13);
}
break;
case 3:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1295);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(1306);
switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
case 1:
{
setState(1296); ltRule();
setState(1297); ltRule();
}
break;
case 2:
{
setState(1299); gtRule();
setState(1300); gtRule();
setState(1301); gtRule();
}
break;
case 3:
{
setState(1303); gtRule();
setState(1304); gtRule();
}
break;
}
setState(1308); expression(12);
}
break;
case 4:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1310);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(1315);
switch (_input.LA(1)) {
case LE:
{
setState(1311); leRule();
}
break;
case GE:
{
setState(1312); geRule();
}
break;
case GT:
{
setState(1313); gtRule();
}
break;
case LT:
{
setState(1314); ltRule();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1317); expression(11);
}
break;
case 5:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1319);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(1322);
switch (_input.LA(1)) {
case EQUAL:
{
setState(1320); equalRule();
}
break;
case NOTEQUAL:
{
setState(1321); notEqualRule();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1324); expression(9);
}
break;
case 6:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1326);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(1327); match(BITAND);
setState(1328); expression(8);
}
break;
case 7:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1329);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(1330); match(CARET);
setState(1331); expression(7);
}
break;
case 8:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1332);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(1333); match(BITOR);
setState(1334); expression(6);
}
break;
case 9:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1335);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(1336); match(AND);
setState(1337); expression(5);
}
break;
case 10:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1338);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1339); match(OR);
setState(1340); expression(4);
}
break;
case 11:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1341);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1342); questionRule();
setState(1343); expression(0);
setState(1344); colonRule();
setState(1345); expression(3);
}
break;
case 12:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1347);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1360);
switch (_input.LA(1)) {
case ASSIGN:
{
setState(1348); assignRule();
}
break;
case ADD_ASSIGN:
{
setState(1349); match(ADD_ASSIGN);
}
break;
case SUB_ASSIGN:
{
setState(1350); match(SUB_ASSIGN);
}
break;
case MUL_ASSIGN:
{
setState(1351); match(MUL_ASSIGN);
}
break;
case DIV_ASSIGN:
{
setState(1352); match(DIV_ASSIGN);
}
break;
case AND_ASSIGN:
{
setState(1353); match(AND_ASSIGN);
}
break;
case OR_ASSIGN:
{
setState(1354); match(OR_ASSIGN);
}
break;
case XOR_ASSIGN:
{
setState(1355); match(XOR_ASSIGN);
}
break;
case RSHIFT_ASSIGN:
{
setState(1356); match(RSHIFT_ASSIGN);
}
break;
case URSHIFT_ASSIGN:
{
setState(1357); match(URSHIFT_ASSIGN);
}
break;
case LSHIFT_ASSIGN:
{
setState(1358); match(LSHIFT_ASSIGN);
}
break;
case MOD_ASSIGN:
{
setState(1359); match(MOD_ASSIGN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1362); expression(1);
}
break;
case 13:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1363);
if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)");
setState(1364); dotRule();
setState(1365); identifierRule();
}
break;
case 14:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1367);
if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)");
setState(1368); dotRule();
setState(1369); match(THIS);
}
break;
case 15:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1371);
if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)");
setState(1372); dotRule();
setState(1373); newRule();
setState(1375);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1374); nonWildcardTypeArguments();
}
}
setState(1377); innerCreator();
}
break;
case 16:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1379);
if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)");
setState(1380); dotRule();
setState(1381); match(SUPER);
setState(1382); superSuffix();
}
break;
case 17:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1384);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(1385); dotRule();
setState(1386); explicitGenericInvocation();
}
break;
case 18:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1388);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(1389); lbrackRule();
setState(1390); expression(0);
setState(1391); rbrackRule();
}
break;
case 19:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1393);
if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
setState(1394); lparenRule();
setState(1396);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << LPAREN) | (1L << LT) | (1L << BANG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (NullLiteral - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(1395); expressionList();
}
}
setState(1398); rparenRule();
}
break;
case 20:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1400);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(1403);
switch (_input.LA(1)) {
case INC:
{
setState(1401); incRule();
}
break;
case DEC:
{
setState(1402); decRule();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 21:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1405);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(1406); match(INSTANCEOF);
setState(1407); type();
}
break;
}
}
}
setState(1412);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,140,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class PrimaryContext extends ParserRuleContext {
public DotRuleContext dotRule() {
return getRuleContext(DotRuleContext.class,0);
}
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public IdentifierRuleContext identifierRule() {
return getRuleContext(IdentifierRuleContext.class,0);
}
public LparenRuleContext lparenRule() {
return getRuleContext(LparenRuleContext.class,0);
}
public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() {
return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public RparenRuleContext rparenRule() {
return getRuleContext(RparenRuleContext.class,0);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public SuperRuleContext superRule() {
return getRuleContext(SuperRuleContext.class,0);
}
public ThisRuleContext thisRule() {
return getRuleContext(ThisRuleContext.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 PJListener ) ((PJListener)listener).enterPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitPrimary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitPrimary(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryContext primary() throws RecognitionException {
PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
enterRule(_localctx, 180, RULE_primary);
try {
setState(1435);
switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1413); lparenRule();
setState(1414); expression(0);
setState(1415); rparenRule();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1417); thisRule();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1418); superRule();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1419); literal();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1420); identifierRule();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1421); type();
setState(1422); dotRule();
setState(1423); match(CLASS);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1425); match(VOID);
setState(1426); dotRule();
setState(1427); match(CLASS);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1429); nonWildcardTypeArguments();
setState(1433);
switch (_input.LA(1)) {
case SUPER:
case Identifier:
{
setState(1430); explicitGenericInvocationSuffix();
}
break;
case THIS:
{
setState(1431); match(THIS);
setState(1432); arguments();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public TerminalNode CharacterLiteral() { return getToken(PJParser.CharacterLiteral, 0); }
public TerminalNode IntegerLiteral() { return getToken(PJParser.IntegerLiteral, 0); }
public TerminalNode StringLiteral() { return getToken(PJParser.StringLiteral, 0); }
public TerminalNode FloatingPointLiteral() { return getToken(PJParser.FloatingPointLiteral, 0); }
public TerminalNode BooleanLiteral() { return getToken(PJParser.BooleanLiteral, 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 PJListener ) ((PJListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 182, RULE_literal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1437);
_la = _input.LA(1);
if ( !(((((_la - 96)) & ~0x3f) == 0 && ((1L << (_la - 96)) & ((1L << (NullLiteral - 96)) | (1L << (BooleanLiteral - 96)) | (1L << (CharacterLiteral - 96)) | (1L << (StringLiteral - 96)) | (1L << (IntegerLiteral - 96)) | (1L << (FloatingPointLiteral - 96)))) != 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 NonWildcardTypeArgumentsOrDiamondContext extends ParserRuleContext {
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public LtRuleContext ltRule() {
return getRuleContext(LtRuleContext.class,0);
}
public GtRuleContext gtRule() {
return getRuleContext(GtRuleContext.class,0);
}
public NonWildcardTypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nonWildcardTypeArgumentsOrDiamond; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterNonWildcardTypeArgumentsOrDiamond(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitNonWildcardTypeArgumentsOrDiamond(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitNonWildcardTypeArgumentsOrDiamond(this);
else return visitor.visitChildren(this);
}
}
public final NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() throws RecognitionException {
NonWildcardTypeArgumentsOrDiamondContext _localctx = new NonWildcardTypeArgumentsOrDiamondContext(_ctx, getState());
enterRule(_localctx, 184, RULE_nonWildcardTypeArgumentsOrDiamond);
try {
setState(1443);
switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1439); ltRule();
setState(1440); gtRule();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1442); nonWildcardTypeArguments();
}
break;
}
}
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 LtRuleContext ltRule() {
return getRuleContext(LtRuleContext.class,0);
}
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public GtRuleContext gtRule() {
return getRuleContext(GtRuleContext.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 PJListener ) ((PJListener)listener).enterNonWildcardTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitNonWildcardTypeArguments(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitNonWildcardTypeArguments(this);
else return visitor.visitChildren(this);
}
}
public final NonWildcardTypeArgumentsContext nonWildcardTypeArguments() throws RecognitionException {
NonWildcardTypeArgumentsContext _localctx = new NonWildcardTypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 186, RULE_nonWildcardTypeArguments);
try {
enterOuterAlt(_localctx, 1);
{
setState(1445); ltRule();
setState(1446); typeList();
setState(1447); gtRule();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExplicitGenericInvocationContext extends ParserRuleContext {
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() {
return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0);
}
public ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explicitGenericInvocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterExplicitGenericInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitExplicitGenericInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitExplicitGenericInvocation(this);
else return visitor.visitChildren(this);
}
}
public final ExplicitGenericInvocationContext explicitGenericInvocation() throws RecognitionException {
ExplicitGenericInvocationContext _localctx = new ExplicitGenericInvocationContext(_ctx, getState());
enterRule(_localctx, 188, RULE_explicitGenericInvocation);
try {
enterOuterAlt(_localctx, 1);
{
setState(1449); nonWildcardTypeArguments();
setState(1450); explicitGenericInvocationSuffix();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExplicitGenericInvocationSuffixContext extends ParserRuleContext {
public SuperSuffixContext superSuffix() {
return getRuleContext(SuperSuffixContext.class,0);
}
public TerminalNode Identifier() { return getToken(PJParser.Identifier, 0); }
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explicitGenericInvocationSuffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterExplicitGenericInvocationSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitExplicitGenericInvocationSuffix(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitExplicitGenericInvocationSuffix(this);
else return visitor.visitChildren(this);
}
}
public final ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() throws RecognitionException {
ExplicitGenericInvocationSuffixContext _localctx = new ExplicitGenericInvocationSuffixContext(_ctx, getState());
enterRule(_localctx, 190, RULE_explicitGenericInvocationSuffix);
try {
setState(1456);
switch (_input.LA(1)) {
case SUPER:
enterOuterAlt(_localctx, 1);
{
setState(1452); match(SUPER);
setState(1453); superSuffix();
}
break;
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(1454); match(Identifier);
setState(1455); arguments();
}
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 DotRuleContext dotRule() {
return getRuleContext(DotRuleContext.class,0);
}
public TerminalNode Identifier() { return getToken(PJParser.Identifier, 0); }
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,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 PJListener ) ((PJListener)listener).enterSuperSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitSuperSuffix(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitSuperSuffix(this);
else return visitor.visitChildren(this);
}
}
public final SuperSuffixContext superSuffix() throws RecognitionException {
SuperSuffixContext _localctx = new SuperSuffixContext(_ctx, getState());
enterRule(_localctx, 192, RULE_superSuffix);
try {
setState(1464);
switch (_input.LA(1)) {
case LPAREN:
enterOuterAlt(_localctx, 1);
{
setState(1458); arguments();
}
break;
case DOT:
enterOuterAlt(_localctx, 2);
{
setState(1459); dotRule();
setState(1460); match(Identifier);
setState(1462);
switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
case 1:
{
setState(1461); arguments();
}
break;
}
}
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 ArgumentsContext extends ParserRuleContext {
public ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.class,0);
}
public LparenRuleContext lparenRule() {
return getRuleContext(LparenRuleContext.class,0);
}
public RparenRuleContext rparenRule() {
return getRuleContext(RparenRuleContext.class,0);
}
public ArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitArguments(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitArguments(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentsContext arguments() throws RecognitionException {
ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState());
enterRule(_localctx, 194, RULE_arguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1466); lparenRule();
setState(1468);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << LPAREN) | (1L << LT) | (1L << BANG))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (NullLiteral - 64)) | (1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (IntegerLiteral - 64)) | (1L << (FloatingPointLiteral - 64)) | (1L << (Identifier - 64)))) != 0)) {
{
setState(1467); expressionList();
}
}
setState(1470); rparenRule();
}
}
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 NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public ArrayCreatorRestContext arrayCreatorRest() {
return getRuleContext(ArrayCreatorRestContext.class,0);
}
public ClassCreatorRestContext classCreatorRest() {
return getRuleContext(ClassCreatorRestContext.class,0);
}
public CreatedNameContext createdName() {
return getRuleContext(CreatedNameContext.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 PJListener ) ((PJListener)listener).enterCreator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitCreator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitCreator(this);
else return visitor.visitChildren(this);
}
}
public final CreatorContext creator() throws RecognitionException {
CreatorContext _localctx = new CreatorContext(_ctx, getState());
enterRule(_localctx, 196, RULE_creator);
try {
setState(1481);
switch (_input.LA(1)) {
case LT:
enterOuterAlt(_localctx, 1);
{
setState(1472); nonWildcardTypeArguments();
setState(1473); createdName();
setState(1474); classCreatorRest();
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(1476); createdName();
setState(1479);
switch (_input.LA(1)) {
case LBRACK:
{
setState(1477); arrayCreatorRest();
}
break;
case LPAREN:
{
setState(1478); classCreatorRest();
}
break;
default:
throw new NoViableAltException(this);
}
}
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 CreatedNameContext extends ParserRuleContext {
public List dotRule() {
return getRuleContexts(DotRuleContext.class);
}
public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond(int i) {
return getRuleContext(TypeArgumentsOrDiamondContext.class,i);
}
public IdentifierRuleContext identifierRule() {
return getRuleContext(IdentifierRuleContext.class,0);
}
public TerminalNode Identifier(int i) {
return getToken(PJParser.Identifier, i);
}
public List Identifier() { return getTokens(PJParser.Identifier); }
public List typeArgumentsOrDiamond() {
return getRuleContexts(TypeArgumentsOrDiamondContext.class);
}
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public DotRuleContext dotRule(int i) {
return getRuleContext(DotRuleContext.class,i);
}
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 PJListener ) ((PJListener)listener).enterCreatedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitCreatedName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitCreatedName(this);
else return visitor.visitChildren(this);
}
}
public final CreatedNameContext createdName() throws RecognitionException {
CreatedNameContext _localctx = new CreatedNameContext(_ctx, getState());
enterRule(_localctx, 198, RULE_createdName);
int _la;
try {
setState(1498);
switch (_input.LA(1)) {
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1483); identifierRule();
setState(1485);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1484); typeArgumentsOrDiamond();
}
}
setState(1494);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(1487); dotRule();
setState(1488); match(Identifier);
setState(1490);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1489); typeArgumentsOrDiamond();
}
}
}
}
setState(1496);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
enterOuterAlt(_localctx, 2);
{
setState(1497); 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 ClassCreatorRestContext extends ParserRuleContext {
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.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 PJListener ) ((PJListener)listener).enterClassCreatorRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitClassCreatorRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitClassCreatorRest(this);
else return visitor.visitChildren(this);
}
}
public final ClassCreatorRestContext classCreatorRest() throws RecognitionException {
ClassCreatorRestContext _localctx = new ClassCreatorRestContext(_ctx, getState());
enterRule(_localctx, 200, RULE_classCreatorRest);
try {
enterOuterAlt(_localctx, 1);
{
setState(1500); arguments();
setState(1502);
switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
case 1:
{
setState(1501); classBody();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayCreatorRestContext extends ParserRuleContext {
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List rbrackRule() {
return getRuleContexts(RbrackRuleContext.class);
}
public List lbrackRule() {
return getRuleContexts(LbrackRuleContext.class);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public RbrackRuleContext rbrackRule(int i) {
return getRuleContext(RbrackRuleContext.class,i);
}
public LbrackRuleContext lbrackRule(int i) {
return getRuleContext(LbrackRuleContext.class,i);
}
public ArrayInitializerContext arrayInitializer() {
return getRuleContext(ArrayInitializerContext.class,0);
}
public ArrayCreatorRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayCreatorRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterArrayCreatorRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitArrayCreatorRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitArrayCreatorRest(this);
else return visitor.visitChildren(this);
}
}
public final ArrayCreatorRestContext arrayCreatorRest() throws RecognitionException {
ArrayCreatorRestContext _localctx = new ArrayCreatorRestContext(_ctx, getState());
enterRule(_localctx, 202, RULE_arrayCreatorRest);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1504); lbrackRule();
setState(1535);
switch (_input.LA(1)) {
case RBRACK:
{
setState(1505); rbrackRule();
setState(1511);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(1506); lbrackRule();
setState(1507); rbrackRule();
}
}
setState(1513);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1514); arrayInitializer();
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case LPAREN:
case LT:
case BANG:
case TILDE:
case INC:
case DEC:
case ADD:
case SUB:
case NullLiteral:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case IntegerLiteral:
case FloatingPointLiteral:
case Identifier:
{
setState(1516); expression(0);
setState(1517); rbrackRule();
setState(1524);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1518); lbrackRule();
setState(1519); expression(0);
setState(1520); rbrackRule();
}
}
}
setState(1526);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
}
setState(1532);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,157,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1527); lbrackRule();
setState(1528); rbrackRule();
}
}
}
setState(1534);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,157,_ctx);
}
}
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 NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() {
return getRuleContext(NonWildcardTypeArgumentsOrDiamondContext.class,0);
}
public TerminalNode Identifier() { return getToken(PJParser.Identifier, 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 PJListener ) ((PJListener)listener).enterInnerCreator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitInnerCreator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitInnerCreator(this);
else return visitor.visitChildren(this);
}
}
public final InnerCreatorContext innerCreator() throws RecognitionException {
InnerCreatorContext _localctx = new InnerCreatorContext(_ctx, getState());
enterRule(_localctx, 204, RULE_innerCreator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1537); match(Identifier);
setState(1539);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1538); nonWildcardTypeArgumentsOrDiamond();
}
}
setState(1541); classCreatorRest();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AbstractRuleContext extends ParserRuleContext {
public TerminalNode ABSTRACT() { return getToken(PJParser.ABSTRACT, 0); }
public AbstractRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abstractRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterAbstractRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAbstractRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAbstractRule(this);
else return visitor.visitChildren(this);
}
}
public final AbstractRuleContext abstractRule() throws RecognitionException {
AbstractRuleContext _localctx = new AbstractRuleContext(_ctx, getState());
enterRule(_localctx, 206, RULE_abstractRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1543); match(ABSTRACT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssertRuleContext extends ParserRuleContext {
public TerminalNode ASSERT() { return getToken(PJParser.ASSERT, 0); }
public AssertRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assertRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterAssertRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAssertRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAssertRule(this);
else return visitor.visitChildren(this);
}
}
public final AssertRuleContext assertRule() throws RecognitionException {
AssertRuleContext _localctx = new AssertRuleContext(_ctx, getState());
enterRule(_localctx, 208, RULE_assertRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1545); match(ASSERT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BooleanRuleContext extends ParserRuleContext {
public TerminalNode BOOLEAN() { return getToken(PJParser.BOOLEAN, 0); }
public BooleanRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterBooleanRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitBooleanRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitBooleanRule(this);
else return visitor.visitChildren(this);
}
}
public final BooleanRuleContext booleanRule() throws RecognitionException {
BooleanRuleContext _localctx = new BooleanRuleContext(_ctx, getState());
enterRule(_localctx, 210, RULE_booleanRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1547); match(BOOLEAN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BreakRuleContext extends ParserRuleContext {
public TerminalNode BREAK() { return getToken(PJParser.BREAK, 0); }
public BreakRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_breakRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterBreakRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitBreakRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitBreakRule(this);
else return visitor.visitChildren(this);
}
}
public final BreakRuleContext breakRule() throws RecognitionException {
BreakRuleContext _localctx = new BreakRuleContext(_ctx, getState());
enterRule(_localctx, 212, RULE_breakRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1549); match(BREAK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ByteRuleContext extends ParserRuleContext {
public TerminalNode BYTE() { return getToken(PJParser.BYTE, 0); }
public ByteRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_byteRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterByteRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitByteRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitByteRule(this);
else return visitor.visitChildren(this);
}
}
public final ByteRuleContext byteRule() throws RecognitionException {
ByteRuleContext _localctx = new ByteRuleContext(_ctx, getState());
enterRule(_localctx, 214, RULE_byteRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1551); match(BYTE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CaseRuleContext extends ParserRuleContext {
public TerminalNode CASE() { return getToken(PJParser.CASE, 0); }
public CaseRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_caseRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterCaseRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitCaseRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitCaseRule(this);
else return visitor.visitChildren(this);
}
}
public final CaseRuleContext caseRule() throws RecognitionException {
CaseRuleContext _localctx = new CaseRuleContext(_ctx, getState());
enterRule(_localctx, 216, RULE_caseRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1553); match(CASE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchRuleContext extends ParserRuleContext {
public TerminalNode CATCH() { return getToken(PJParser.CATCH, 0); }
public CatchRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterCatchRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitCatchRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitCatchRule(this);
else return visitor.visitChildren(this);
}
}
public final CatchRuleContext catchRule() throws RecognitionException {
CatchRuleContext _localctx = new CatchRuleContext(_ctx, getState());
enterRule(_localctx, 218, RULE_catchRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1555); match(CATCH);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CharRuleContext extends ParserRuleContext {
public TerminalNode CHAR() { return getToken(PJParser.CHAR, 0); }
public CharRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_charRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterCharRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitCharRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitCharRule(this);
else return visitor.visitChildren(this);
}
}
public final CharRuleContext charRule() throws RecognitionException {
CharRuleContext _localctx = new CharRuleContext(_ctx, getState());
enterRule(_localctx, 220, RULE_charRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1557); match(CHAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassRuleContext extends ParserRuleContext {
public TerminalNode CLASS() { return getToken(PJParser.CLASS, 0); }
public ClassRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterClassRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitClassRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitClassRule(this);
else return visitor.visitChildren(this);
}
}
public final ClassRuleContext classRule() throws RecognitionException {
ClassRuleContext _localctx = new ClassRuleContext(_ctx, getState());
enterRule(_localctx, 222, RULE_classRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1559); match(CLASS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstRuleContext extends ParserRuleContext {
public TerminalNode CONST() { return getToken(PJParser.CONST, 0); }
public ConstRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterConstRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitConstRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitConstRule(this);
else return visitor.visitChildren(this);
}
}
public final ConstRuleContext constRule() throws RecognitionException {
ConstRuleContext _localctx = new ConstRuleContext(_ctx, getState());
enterRule(_localctx, 224, RULE_constRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1561); match(CONST);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ContinueRuleContext extends ParserRuleContext {
public TerminalNode CONTINUE() { return getToken(PJParser.CONTINUE, 0); }
public ContinueRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_continueRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterContinueRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitContinueRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitContinueRule(this);
else return visitor.visitChildren(this);
}
}
public final ContinueRuleContext continueRule() throws RecognitionException {
ContinueRuleContext _localctx = new ContinueRuleContext(_ctx, getState());
enterRule(_localctx, 226, RULE_continueRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1563); match(CONTINUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultRuleContext extends ParserRuleContext {
public TerminalNode DEFAULT() { return getToken(PJParser.DEFAULT, 0); }
public DefaultRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterDefaultRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitDefaultRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitDefaultRule(this);
else return visitor.visitChildren(this);
}
}
public final DefaultRuleContext defaultRule() throws RecognitionException {
DefaultRuleContext _localctx = new DefaultRuleContext(_ctx, getState());
enterRule(_localctx, 228, RULE_defaultRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1565); match(DEFAULT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DoRuleContext extends ParserRuleContext {
public TerminalNode DO() { return getToken(PJParser.DO, 0); }
public DoRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_doRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterDoRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitDoRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitDoRule(this);
else return visitor.visitChildren(this);
}
}
public final DoRuleContext doRule() throws RecognitionException {
DoRuleContext _localctx = new DoRuleContext(_ctx, getState());
enterRule(_localctx, 230, RULE_doRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1567); match(DO);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DoubleRuleContext extends ParserRuleContext {
public TerminalNode DOUBLE() { return getToken(PJParser.DOUBLE, 0); }
public DoubleRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_doubleRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterDoubleRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitDoubleRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitDoubleRule(this);
else return visitor.visitChildren(this);
}
}
public final DoubleRuleContext doubleRule() throws RecognitionException {
DoubleRuleContext _localctx = new DoubleRuleContext(_ctx, getState());
enterRule(_localctx, 232, RULE_doubleRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1569); match(DOUBLE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElseRuleContext extends ParserRuleContext {
public TerminalNode ELSE() { return getToken(PJParser.ELSE, 0); }
public ElseRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elseRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterElseRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitElseRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitElseRule(this);
else return visitor.visitChildren(this);
}
}
public final ElseRuleContext elseRule() throws RecognitionException {
ElseRuleContext _localctx = new ElseRuleContext(_ctx, getState());
enterRule(_localctx, 234, RULE_elseRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1571); match(ELSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumRuleContext extends ParserRuleContext {
public TerminalNode ENUM() { return getToken(PJParser.ENUM, 0); }
public EnumRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterEnumRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitEnumRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitEnumRule(this);
else return visitor.visitChildren(this);
}
}
public final EnumRuleContext enumRule() throws RecognitionException {
EnumRuleContext _localctx = new EnumRuleContext(_ctx, getState());
enterRule(_localctx, 236, RULE_enumRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1573); match(ENUM);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExtendsRuleContext extends ParserRuleContext {
public TerminalNode EXTENDS() { return getToken(PJParser.EXTENDS, 0); }
public ExtendsRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extendsRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterExtendsRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitExtendsRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitExtendsRule(this);
else return visitor.visitChildren(this);
}
}
public final ExtendsRuleContext extendsRule() throws RecognitionException {
ExtendsRuleContext _localctx = new ExtendsRuleContext(_ctx, getState());
enterRule(_localctx, 238, RULE_extendsRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1575); match(EXTENDS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FinalRuleContext extends ParserRuleContext {
public TerminalNode FINAL() { return getToken(PJParser.FINAL, 0); }
public FinalRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_finalRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterFinalRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitFinalRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitFinalRule(this);
else return visitor.visitChildren(this);
}
}
public final FinalRuleContext finalRule() throws RecognitionException {
FinalRuleContext _localctx = new FinalRuleContext(_ctx, getState());
enterRule(_localctx, 240, RULE_finalRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1577); match(FINAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FinallyRuleContext extends ParserRuleContext {
public TerminalNode FINALLY() { return getToken(PJParser.FINALLY, 0); }
public FinallyRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_finallyRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterFinallyRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitFinallyRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitFinallyRule(this);
else return visitor.visitChildren(this);
}
}
public final FinallyRuleContext finallyRule() throws RecognitionException {
FinallyRuleContext _localctx = new FinallyRuleContext(_ctx, getState());
enterRule(_localctx, 242, RULE_finallyRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1579); match(FINALLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FloatRuleContext extends ParserRuleContext {
public TerminalNode FLOAT() { return getToken(PJParser.FLOAT, 0); }
public FloatRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_floatRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterFloatRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitFloatRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitFloatRule(this);
else return visitor.visitChildren(this);
}
}
public final FloatRuleContext floatRule() throws RecognitionException {
FloatRuleContext _localctx = new FloatRuleContext(_ctx, getState());
enterRule(_localctx, 244, RULE_floatRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1581); match(FLOAT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForRuleContext extends ParserRuleContext {
public TerminalNode FOR() { return getToken(PJParser.FOR, 0); }
public ForRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterForRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitForRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitForRule(this);
else return visitor.visitChildren(this);
}
}
public final ForRuleContext forRule() throws RecognitionException {
ForRuleContext _localctx = new ForRuleContext(_ctx, getState());
enterRule(_localctx, 246, RULE_forRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1583); match(FOR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfRuleContext extends ParserRuleContext {
public TerminalNode IF() { return getToken(PJParser.IF, 0); }
public IfRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterIfRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitIfRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitIfRule(this);
else return visitor.visitChildren(this);
}
}
public final IfRuleContext ifRule() throws RecognitionException {
IfRuleContext _localctx = new IfRuleContext(_ctx, getState());
enterRule(_localctx, 248, RULE_ifRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1585); match(IF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GotoRuleContext extends ParserRuleContext {
public TerminalNode GOTO() { return getToken(PJParser.GOTO, 0); }
public GotoRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gotoRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterGotoRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitGotoRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitGotoRule(this);
else return visitor.visitChildren(this);
}
}
public final GotoRuleContext gotoRule() throws RecognitionException {
GotoRuleContext _localctx = new GotoRuleContext(_ctx, getState());
enterRule(_localctx, 250, RULE_gotoRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1587); match(GOTO);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImplementsRuleContext extends ParserRuleContext {
public TerminalNode IMPLEMENTS() { return getToken(PJParser.IMPLEMENTS, 0); }
public ImplementsRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_implementsRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterImplementsRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitImplementsRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitImplementsRule(this);
else return visitor.visitChildren(this);
}
}
public final ImplementsRuleContext implementsRule() throws RecognitionException {
ImplementsRuleContext _localctx = new ImplementsRuleContext(_ctx, getState());
enterRule(_localctx, 252, RULE_implementsRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1589); match(IMPLEMENTS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportRuleContext extends ParserRuleContext {
public TerminalNode IMPORT() { return getToken(PJParser.IMPORT, 0); }
public ImportRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterImportRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitImportRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitImportRule(this);
else return visitor.visitChildren(this);
}
}
public final ImportRuleContext importRule() throws RecognitionException {
ImportRuleContext _localctx = new ImportRuleContext(_ctx, getState());
enterRule(_localctx, 254, RULE_importRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1591); match(IMPORT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InstanceofRuleContext extends ParserRuleContext {
public TerminalNode INSTANCEOF() { return getToken(PJParser.INSTANCEOF, 0); }
public InstanceofRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_instanceofRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterInstanceofRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitInstanceofRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitInstanceofRule(this);
else return visitor.visitChildren(this);
}
}
public final InstanceofRuleContext instanceofRule() throws RecognitionException {
InstanceofRuleContext _localctx = new InstanceofRuleContext(_ctx, getState());
enterRule(_localctx, 256, RULE_instanceofRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1593); match(INSTANCEOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntRuleContext extends ParserRuleContext {
public TerminalNode INT() { return getToken(PJParser.INT, 0); }
public IntRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterIntRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitIntRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitIntRule(this);
else return visitor.visitChildren(this);
}
}
public final IntRuleContext intRule() throws RecognitionException {
IntRuleContext _localctx = new IntRuleContext(_ctx, getState());
enterRule(_localctx, 258, RULE_intRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1595); match(INT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceRuleContext extends ParserRuleContext {
public TerminalNode INTERFACE() { return getToken(PJParser.INTERFACE, 0); }
public InterfaceRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterInterfaceRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitInterfaceRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitInterfaceRule(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceRuleContext interfaceRule() throws RecognitionException {
InterfaceRuleContext _localctx = new InterfaceRuleContext(_ctx, getState());
enterRule(_localctx, 260, RULE_interfaceRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1597); match(INTERFACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LongRuleContext extends ParserRuleContext {
public TerminalNode LONG() { return getToken(PJParser.LONG, 0); }
public LongRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_longRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterLongRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitLongRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitLongRule(this);
else return visitor.visitChildren(this);
}
}
public final LongRuleContext longRule() throws RecognitionException {
LongRuleContext _localctx = new LongRuleContext(_ctx, getState());
enterRule(_localctx, 262, RULE_longRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1599); match(LONG);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NativeRuleContext extends ParserRuleContext {
public TerminalNode NATIVE() { return getToken(PJParser.NATIVE, 0); }
public NativeRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nativeRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterNativeRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitNativeRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitNativeRule(this);
else return visitor.visitChildren(this);
}
}
public final NativeRuleContext nativeRule() throws RecognitionException {
NativeRuleContext _localctx = new NativeRuleContext(_ctx, getState());
enterRule(_localctx, 264, RULE_nativeRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1601); match(NATIVE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NewRuleContext extends ParserRuleContext {
public TerminalNode NEW() { return getToken(PJParser.NEW, 0); }
public NewRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_newRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterNewRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitNewRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitNewRule(this);
else return visitor.visitChildren(this);
}
}
public final NewRuleContext newRule() throws RecognitionException {
NewRuleContext _localctx = new NewRuleContext(_ctx, getState());
enterRule(_localctx, 266, RULE_newRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1603); match(NEW);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PackageRuleContext extends ParserRuleContext {
public TerminalNode PACKAGE() { return getToken(PJParser.PACKAGE, 0); }
public PackageRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterPackageRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitPackageRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitPackageRule(this);
else return visitor.visitChildren(this);
}
}
public final PackageRuleContext packageRule() throws RecognitionException {
PackageRuleContext _localctx = new PackageRuleContext(_ctx, getState());
enterRule(_localctx, 268, RULE_packageRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1605); match(PACKAGE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrivateRuleContext extends ParserRuleContext {
public TerminalNode PRIVATE() { return getToken(PJParser.PRIVATE, 0); }
public PrivateRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_privateRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterPrivateRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitPrivateRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitPrivateRule(this);
else return visitor.visitChildren(this);
}
}
public final PrivateRuleContext privateRule() throws RecognitionException {
PrivateRuleContext _localctx = new PrivateRuleContext(_ctx, getState());
enterRule(_localctx, 270, RULE_privateRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1607); match(PRIVATE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ProtectedRuleContext extends ParserRuleContext {
public TerminalNode PROTECTED() { return getToken(PJParser.PROTECTED, 0); }
public ProtectedRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_protectedRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterProtectedRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitProtectedRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitProtectedRule(this);
else return visitor.visitChildren(this);
}
}
public final ProtectedRuleContext protectedRule() throws RecognitionException {
ProtectedRuleContext _localctx = new ProtectedRuleContext(_ctx, getState());
enterRule(_localctx, 272, RULE_protectedRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1609); match(PROTECTED);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PublicRuleContext extends ParserRuleContext {
public TerminalNode PUBLIC() { return getToken(PJParser.PUBLIC, 0); }
public PublicRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_publicRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterPublicRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitPublicRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitPublicRule(this);
else return visitor.visitChildren(this);
}
}
public final PublicRuleContext publicRule() throws RecognitionException {
PublicRuleContext _localctx = new PublicRuleContext(_ctx, getState());
enterRule(_localctx, 274, RULE_publicRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1611); match(PUBLIC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReturnRuleContext extends ParserRuleContext {
public TerminalNode RETURN() { return getToken(PJParser.RETURN, 0); }
public ReturnRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_returnRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterReturnRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitReturnRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitReturnRule(this);
else return visitor.visitChildren(this);
}
}
public final ReturnRuleContext returnRule() throws RecognitionException {
ReturnRuleContext _localctx = new ReturnRuleContext(_ctx, getState());
enterRule(_localctx, 276, RULE_returnRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1613); match(RETURN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ShortRuleContext extends ParserRuleContext {
public TerminalNode SHORT() { return getToken(PJParser.SHORT, 0); }
public ShortRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shortRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterShortRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitShortRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitShortRule(this);
else return visitor.visitChildren(this);
}
}
public final ShortRuleContext shortRule() throws RecognitionException {
ShortRuleContext _localctx = new ShortRuleContext(_ctx, getState());
enterRule(_localctx, 278, RULE_shortRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1615); match(SHORT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StaticRuleContext extends ParserRuleContext {
public TerminalNode STATIC() { return getToken(PJParser.STATIC, 0); }
public StaticRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_staticRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterStaticRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitStaticRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitStaticRule(this);
else return visitor.visitChildren(this);
}
}
public final StaticRuleContext staticRule() throws RecognitionException {
StaticRuleContext _localctx = new StaticRuleContext(_ctx, getState());
enterRule(_localctx, 280, RULE_staticRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1617); match(STATIC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrictfpRuleContext extends ParserRuleContext {
public TerminalNode STRICTFP() { return getToken(PJParser.STRICTFP, 0); }
public StrictfpRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strictfpRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterStrictfpRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitStrictfpRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitStrictfpRule(this);
else return visitor.visitChildren(this);
}
}
public final StrictfpRuleContext strictfpRule() throws RecognitionException {
StrictfpRuleContext _localctx = new StrictfpRuleContext(_ctx, getState());
enterRule(_localctx, 282, RULE_strictfpRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1619); match(STRICTFP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SuperRuleContext extends ParserRuleContext {
public TerminalNode SUPER() { return getToken(PJParser.SUPER, 0); }
public SuperRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_superRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterSuperRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitSuperRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitSuperRule(this);
else return visitor.visitChildren(this);
}
}
public final SuperRuleContext superRule() throws RecognitionException {
SuperRuleContext _localctx = new SuperRuleContext(_ctx, getState());
enterRule(_localctx, 284, RULE_superRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1621); match(SUPER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchRuleContext extends ParserRuleContext {
public TerminalNode SWITCH() { return getToken(PJParser.SWITCH, 0); }
public SwitchRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterSwitchRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitSwitchRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitSwitchRule(this);
else return visitor.visitChildren(this);
}
}
public final SwitchRuleContext switchRule() throws RecognitionException {
SwitchRuleContext _localctx = new SwitchRuleContext(_ctx, getState());
enterRule(_localctx, 286, RULE_switchRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1623); match(SWITCH);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SynchronizedRuleContext extends ParserRuleContext {
public TerminalNode SYNCHRONIZED() { return getToken(PJParser.SYNCHRONIZED, 0); }
public SynchronizedRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_synchronizedRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterSynchronizedRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitSynchronizedRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitSynchronizedRule(this);
else return visitor.visitChildren(this);
}
}
public final SynchronizedRuleContext synchronizedRule() throws RecognitionException {
SynchronizedRuleContext _localctx = new SynchronizedRuleContext(_ctx, getState());
enterRule(_localctx, 288, RULE_synchronizedRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1625); match(SYNCHRONIZED);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ThisRuleContext extends ParserRuleContext {
public TerminalNode THIS() { return getToken(PJParser.THIS, 0); }
public ThisRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_thisRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterThisRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitThisRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitThisRule(this);
else return visitor.visitChildren(this);
}
}
public final ThisRuleContext thisRule() throws RecognitionException {
ThisRuleContext _localctx = new ThisRuleContext(_ctx, getState());
enterRule(_localctx, 290, RULE_thisRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1627); match(THIS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ThrowRuleContext extends ParserRuleContext {
public TerminalNode THROW() { return getToken(PJParser.THROW, 0); }
public ThrowRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_throwRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterThrowRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitThrowRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitThrowRule(this);
else return visitor.visitChildren(this);
}
}
public final ThrowRuleContext throwRule() throws RecognitionException {
ThrowRuleContext _localctx = new ThrowRuleContext(_ctx, getState());
enterRule(_localctx, 292, RULE_throwRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1629); match(THROW);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ThrowsRuleContext extends ParserRuleContext {
public TerminalNode THROWS() { return getToken(PJParser.THROWS, 0); }
public ThrowsRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_throwsRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterThrowsRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitThrowsRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitThrowsRule(this);
else return visitor.visitChildren(this);
}
}
public final ThrowsRuleContext throwsRule() throws RecognitionException {
ThrowsRuleContext _localctx = new ThrowsRuleContext(_ctx, getState());
enterRule(_localctx, 294, RULE_throwsRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1631); match(THROWS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TransientRuleContext extends ParserRuleContext {
public TerminalNode TRANSIENT() { return getToken(PJParser.TRANSIENT, 0); }
public TransientRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transientRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterTransientRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTransientRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTransientRule(this);
else return visitor.visitChildren(this);
}
}
public final TransientRuleContext transientRule() throws RecognitionException {
TransientRuleContext _localctx = new TransientRuleContext(_ctx, getState());
enterRule(_localctx, 296, RULE_transientRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1633); match(TRANSIENT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TryRuleContext extends ParserRuleContext {
public TerminalNode TRY() { return getToken(PJParser.TRY, 0); }
public TryRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tryRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterTryRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTryRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTryRule(this);
else return visitor.visitChildren(this);
}
}
public final TryRuleContext tryRule() throws RecognitionException {
TryRuleContext _localctx = new TryRuleContext(_ctx, getState());
enterRule(_localctx, 298, RULE_tryRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1635); match(TRY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VoidRuleContext extends ParserRuleContext {
public TerminalNode VOID() { return getToken(PJParser.VOID, 0); }
public VoidRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_voidRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterVoidRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitVoidRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitVoidRule(this);
else return visitor.visitChildren(this);
}
}
public final VoidRuleContext voidRule() throws RecognitionException {
VoidRuleContext _localctx = new VoidRuleContext(_ctx, getState());
enterRule(_localctx, 300, RULE_voidRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1637); match(VOID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VolatileRuleContext extends ParserRuleContext {
public TerminalNode VOLATILE() { return getToken(PJParser.VOLATILE, 0); }
public VolatileRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_volatileRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterVolatileRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitVolatileRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitVolatileRule(this);
else return visitor.visitChildren(this);
}
}
public final VolatileRuleContext volatileRule() throws RecognitionException {
VolatileRuleContext _localctx = new VolatileRuleContext(_ctx, getState());
enterRule(_localctx, 302, RULE_volatileRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1639); match(VOLATILE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhileRuleContext extends ParserRuleContext {
public TerminalNode WHILE() { return getToken(PJParser.WHILE, 0); }
public WhileRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whileRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterWhileRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitWhileRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitWhileRule(this);
else return visitor.visitChildren(this);
}
}
public final WhileRuleContext whileRule() throws RecognitionException {
WhileRuleContext _localctx = new WhileRuleContext(_ctx, getState());
enterRule(_localctx, 304, RULE_whileRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1641); match(WHILE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LparenRuleContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(PJParser.LPAREN, 0); }
public LparenRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lparenRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterLparenRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitLparenRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitLparenRule(this);
else return visitor.visitChildren(this);
}
}
public final LparenRuleContext lparenRule() throws RecognitionException {
LparenRuleContext _localctx = new LparenRuleContext(_ctx, getState());
enterRule(_localctx, 306, RULE_lparenRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1643); match(LPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RparenRuleContext extends ParserRuleContext {
public TerminalNode RPAREN() { return getToken(PJParser.RPAREN, 0); }
public RparenRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rparenRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterRparenRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitRparenRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitRparenRule(this);
else return visitor.visitChildren(this);
}
}
public final RparenRuleContext rparenRule() throws RecognitionException {
RparenRuleContext _localctx = new RparenRuleContext(_ctx, getState());
enterRule(_localctx, 308, RULE_rparenRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1645); match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LbraceRuleContext extends ParserRuleContext {
public TerminalNode LBRACE() { return getToken(PJParser.LBRACE, 0); }
public LbraceRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lbraceRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterLbraceRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitLbraceRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitLbraceRule(this);
else return visitor.visitChildren(this);
}
}
public final LbraceRuleContext lbraceRule() throws RecognitionException {
LbraceRuleContext _localctx = new LbraceRuleContext(_ctx, getState());
enterRule(_localctx, 310, RULE_lbraceRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1647); match(LBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RbraceRuleContext extends ParserRuleContext {
public TerminalNode RBRACE() { return getToken(PJParser.RBRACE, 0); }
public RbraceRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rbraceRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterRbraceRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitRbraceRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitRbraceRule(this);
else return visitor.visitChildren(this);
}
}
public final RbraceRuleContext rbraceRule() throws RecognitionException {
RbraceRuleContext _localctx = new RbraceRuleContext(_ctx, getState());
enterRule(_localctx, 312, RULE_rbraceRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1649); match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LbrackRuleContext extends ParserRuleContext {
public TerminalNode LBRACK() { return getToken(PJParser.LBRACK, 0); }
public LbrackRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lbrackRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterLbrackRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitLbrackRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitLbrackRule(this);
else return visitor.visitChildren(this);
}
}
public final LbrackRuleContext lbrackRule() throws RecognitionException {
LbrackRuleContext _localctx = new LbrackRuleContext(_ctx, getState());
enterRule(_localctx, 314, RULE_lbrackRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1651); match(LBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RbrackRuleContext extends ParserRuleContext {
public TerminalNode RBRACK() { return getToken(PJParser.RBRACK, 0); }
public RbrackRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rbrackRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterRbrackRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitRbrackRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitRbrackRule(this);
else return visitor.visitChildren(this);
}
}
public final RbrackRuleContext rbrackRule() throws RecognitionException {
RbrackRuleContext _localctx = new RbrackRuleContext(_ctx, getState());
enterRule(_localctx, 316, RULE_rbrackRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1653); match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SemiRuleContext extends ParserRuleContext {
public TerminalNode SEMI() { return getToken(PJParser.SEMI, 0); }
public SemiRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_semiRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterSemiRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitSemiRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitSemiRule(this);
else return visitor.visitChildren(this);
}
}
public final SemiRuleContext semiRule() throws RecognitionException {
SemiRuleContext _localctx = new SemiRuleContext(_ctx, getState());
enterRule(_localctx, 318, RULE_semiRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1655); match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CommaRuleContext extends ParserRuleContext {
public TerminalNode COMMA() { return getToken(PJParser.COMMA, 0); }
public CommaRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commaRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterCommaRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitCommaRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitCommaRule(this);
else return visitor.visitChildren(this);
}
}
public final CommaRuleContext commaRule() throws RecognitionException {
CommaRuleContext _localctx = new CommaRuleContext(_ctx, getState());
enterRule(_localctx, 320, RULE_commaRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1657); match(COMMA);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DotRuleContext extends ParserRuleContext {
public TerminalNode DOT() { return getToken(PJParser.DOT, 0); }
public DotRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dotRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterDotRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitDotRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitDotRule(this);
else return visitor.visitChildren(this);
}
}
public final DotRuleContext dotRule() throws RecognitionException {
DotRuleContext _localctx = new DotRuleContext(_ctx, getState());
enterRule(_localctx, 322, RULE_dotRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1659); match(DOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignRuleContext extends ParserRuleContext {
public TerminalNode ASSIGN() { return getToken(PJParser.ASSIGN, 0); }
public AssignRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterAssignRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAssignRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAssignRule(this);
else return visitor.visitChildren(this);
}
}
public final AssignRuleContext assignRule() throws RecognitionException {
AssignRuleContext _localctx = new AssignRuleContext(_ctx, getState());
enterRule(_localctx, 324, RULE_assignRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1661); match(ASSIGN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GtRuleContext extends ParserRuleContext {
public TerminalNode GT() { return getToken(PJParser.GT, 0); }
public GtRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gtRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterGtRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitGtRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitGtRule(this);
else return visitor.visitChildren(this);
}
}
public final GtRuleContext gtRule() throws RecognitionException {
GtRuleContext _localctx = new GtRuleContext(_ctx, getState());
enterRule(_localctx, 326, RULE_gtRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1663); match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LtRuleContext extends ParserRuleContext {
public TerminalNode LT() { return getToken(PJParser.LT, 0); }
public LtRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ltRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterLtRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitLtRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitLtRule(this);
else return visitor.visitChildren(this);
}
}
public final LtRuleContext ltRule() throws RecognitionException {
LtRuleContext _localctx = new LtRuleContext(_ctx, getState());
enterRule(_localctx, 328, RULE_ltRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1665); match(LT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BangRuleContext extends ParserRuleContext {
public TerminalNode BANG() { return getToken(PJParser.BANG, 0); }
public BangRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bangRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterBangRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitBangRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitBangRule(this);
else return visitor.visitChildren(this);
}
}
public final BangRuleContext bangRule() throws RecognitionException {
BangRuleContext _localctx = new BangRuleContext(_ctx, getState());
enterRule(_localctx, 330, RULE_bangRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1667); match(BANG);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TildeRuleContext extends ParserRuleContext {
public TerminalNode TILDE() { return getToken(PJParser.TILDE, 0); }
public TildeRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tildeRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterTildeRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitTildeRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitTildeRule(this);
else return visitor.visitChildren(this);
}
}
public final TildeRuleContext tildeRule() throws RecognitionException {
TildeRuleContext _localctx = new TildeRuleContext(_ctx, getState());
enterRule(_localctx, 332, RULE_tildeRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1669); match(TILDE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuestionRuleContext extends ParserRuleContext {
public TerminalNode QUESTION() { return getToken(PJParser.QUESTION, 0); }
public QuestionRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_questionRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterQuestionRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitQuestionRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitQuestionRule(this);
else return visitor.visitChildren(this);
}
}
public final QuestionRuleContext questionRule() throws RecognitionException {
QuestionRuleContext _localctx = new QuestionRuleContext(_ctx, getState());
enterRule(_localctx, 334, RULE_questionRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1671); match(QUESTION);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ColonRuleContext extends ParserRuleContext {
public TerminalNode COLON() { return getToken(PJParser.COLON, 0); }
public ColonRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_colonRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterColonRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitColonRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitColonRule(this);
else return visitor.visitChildren(this);
}
}
public final ColonRuleContext colonRule() throws RecognitionException {
ColonRuleContext _localctx = new ColonRuleContext(_ctx, getState());
enterRule(_localctx, 336, RULE_colonRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1673); match(COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EqualRuleContext extends ParserRuleContext {
public TerminalNode EQUAL() { return getToken(PJParser.EQUAL, 0); }
public EqualRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterEqualRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitEqualRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitEqualRule(this);
else return visitor.visitChildren(this);
}
}
public final EqualRuleContext equalRule() throws RecognitionException {
EqualRuleContext _localctx = new EqualRuleContext(_ctx, getState());
enterRule(_localctx, 338, RULE_equalRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1675); match(EQUAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LeRuleContext extends ParserRuleContext {
public TerminalNode LE() { return getToken(PJParser.LE, 0); }
public LeRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_leRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterLeRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitLeRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitLeRule(this);
else return visitor.visitChildren(this);
}
}
public final LeRuleContext leRule() throws RecognitionException {
LeRuleContext _localctx = new LeRuleContext(_ctx, getState());
enterRule(_localctx, 340, RULE_leRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1677); match(LE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GeRuleContext extends ParserRuleContext {
public TerminalNode GE() { return getToken(PJParser.GE, 0); }
public GeRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterGeRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitGeRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitGeRule(this);
else return visitor.visitChildren(this);
}
}
public final GeRuleContext geRule() throws RecognitionException {
GeRuleContext _localctx = new GeRuleContext(_ctx, getState());
enterRule(_localctx, 342, RULE_geRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1679); match(GE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NotEqualRuleContext extends ParserRuleContext {
public TerminalNode NOTEQUAL() { return getToken(PJParser.NOTEQUAL, 0); }
public NotEqualRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notEqualRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterNotEqualRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitNotEqualRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitNotEqualRule(this);
else return visitor.visitChildren(this);
}
}
public final NotEqualRuleContext notEqualRule() throws RecognitionException {
NotEqualRuleContext _localctx = new NotEqualRuleContext(_ctx, getState());
enterRule(_localctx, 344, RULE_notEqualRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1681); match(NOTEQUAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AndRuleContext extends ParserRuleContext {
public TerminalNode AND() { return getToken(PJParser.AND, 0); }
public AndRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterAndRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitAndRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitAndRule(this);
else return visitor.visitChildren(this);
}
}
public final AndRuleContext andRule() throws RecognitionException {
AndRuleContext _localctx = new AndRuleContext(_ctx, getState());
enterRule(_localctx, 346, RULE_andRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1683); match(AND);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrRuleContext extends ParserRuleContext {
public TerminalNode OR() { return getToken(PJParser.OR, 0); }
public OrRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterOrRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitOrRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PJVisitor ) return ((PJVisitor)visitor).visitOrRule(this);
else return visitor.visitChildren(this);
}
}
public final OrRuleContext orRule() throws RecognitionException {
OrRuleContext _localctx = new OrRuleContext(_ctx, getState());
enterRule(_localctx, 348, RULE_orRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(1685); match(OR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IncRuleContext extends ParserRuleContext {
public TerminalNode INC() { return getToken(PJParser.INC, 0); }
public IncRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_incRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).enterIncRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PJListener ) ((PJListener)listener).exitIncRule(this);
}
@Override
public 