sootup.jimple.JimpleParser Maven / Gradle / Ivy
The newest version!
// Generated from sootup/jimple/Jimple.g4 by ANTLR 4.9.3
package sootup.jimple;
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 JimpleParser extends Parser {
static { RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24,
T__24=25, T__25=26, T__26=27, LINE_COMMENT=28, LONG_COMMENT=29, STRING_CONSTANT=30,
CLASS=31, EXTENDS=32, IMPLEMENTS=33, BREAKPOINT=34, CASE=35, CATCH=36,
CMP=37, CMPG=38, CMPL=39, DEFAULT=40, ENTERMONITOR=41, EXITMONITOR=42,
GOTO=43, IF=44, INSTANCEOF=45, LENGTHOF=46, SWITCH=47, NEG=48, NEWARRAY=49,
NEWMULTIARRAY=50, NEW=51, NOP=52, RETURN=53, RET=54, NONSTATIC_INVOKE=55,
STATICINVOKE=56, DYNAMICINVOKE=57, THROWS=58, THROW=59, NULL=60, FROM=61,
TO=62, WITH=63, COMMA=64, L_BRACE=65, R_BRACE=66, SEMICOLON=67, L_BRACKET=68,
R_BRACKET=69, L_PAREN=70, R_PAREN=71, COLON=72, DOT=73, EQUALS=74, COLON_EQUALS=75,
AND=76, OR=77, XOR=78, MOD=79, CMPEQ=80, CMPNE=81, CMPGT=82, CMPGE=83,
CMPLT=84, CMPLE=85, SHL=86, SHR=87, USHR=88, PLUS=89, MINUS=90, MULT=91,
DIV=92, QUOTE=93, BOOL_CONSTANT=94, FLOAT_CONSTANT=95, DEC_CONSTANT=96,
HEX_CONSTANT=97, IDENTIFIER=98, BLANK=99;
public static final int
RULE_identifier = 0, RULE_integer_constant = 1, RULE_file = 2, RULE_importItem = 3,
RULE_common_modifier = 4, RULE_class_modifier = 5, RULE_method_modifier = 6,
RULE_field_modifier = 7, RULE_file_type = 8, RULE_extends_clause = 9,
RULE_implements_clause = 10, RULE_type = 11, RULE_type_list = 12, RULE_member = 13,
RULE_field = 14, RULE_method = 15, RULE_method_name = 16, RULE_throws_clause = 17,
RULE_method_body = 18, RULE_method_body_contents = 19, RULE_trap_clauses = 20,
RULE_statements = 21, RULE_declarations = 22, RULE_declaration = 23, RULE_statement = 24,
RULE_stmt = 25, RULE_assignments = 26, RULE_identity_ref = 27, RULE_case_stmt = 28,
RULE_case_label = 29, RULE_goto_stmt = 30, RULE_trap_clause = 31, RULE_value = 32,
RULE_bool_expr = 33, RULE_invoke_expr = 34, RULE_binop_expr = 35, RULE_unop_expr = 36,
RULE_method_subsignature = 37, RULE_method_signature = 38, RULE_reference = 39,
RULE_field_signature = 40, RULE_array_descriptor = 41, RULE_arg_list = 42,
RULE_immediate = 43, RULE_methodhandle = 44, RULE_constant = 45, RULE_binop = 46,
RULE_unop = 47;
private static String[] makeRuleNames() {
return new String[] {
"identifier", "integer_constant", "file", "importItem", "common_modifier",
"class_modifier", "method_modifier", "field_modifier", "file_type", "extends_clause",
"implements_clause", "type", "type_list", "member", "field", "method",
"method_name", "throws_clause", "method_body", "method_body_contents",
"trap_clauses", "statements", "declarations", "declaration", "statement",
"stmt", "assignments", "identity_ref", "case_stmt", "case_label", "goto_stmt",
"trap_clause", "value", "bool_expr", "invoke_expr", "binop_expr", "unop_expr",
"method_subsignature", "method_signature", "reference", "field_signature",
"array_descriptor", "arg_list", "immediate", "methodhandle", "constant",
"binop", "unop"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'L'", "'import'", "'final'", "'public'", "'protected'", "'private'",
"'static'", "'enum'", "'synthetic'", "'abstract'", "'super'", "'native'",
"'synchronized'", "'varargs'", "'bridge'", "'strictfp'", "'transient'",
"'volatile'", "'interface'", "'annotation interface'", "''", "''",
"'@parameter'", "'@this:'", "'@caughtexception'", "'methodhandle: '",
"'methodtype:'", null, null, null, "'class'", "'extends'", "'implements'",
"'breakpoint'", "'case'", "'catch'", "'cmp'", "'cmpg'", "'cmpl'", "'default'",
"'entermonitor'", "'exitmonitor'", "'goto'", "'if'", "'instanceof'",
"'lengthof'", null, "'neg'", "'newarray'", "'newmultiarray'", "'new'",
"'nop'", "'return'", "'ret'", null, "'staticinvoke'", "'dynamicinvoke'",
"'throws'", "'throw'", "'null'", "'from'", "'to'", "'with'", "','", "'{'",
"'}'", "';'", "'['", "']'", "'('", "')'", "':'", "'.'", "'='", "':='",
"'&'", "'|'", "'^'", "'%'", "'=='", "'!='", "'>'", "'>='", "'<'", "'<='",
"'<<'", "'>>'", "'>>>'", "'+'", "'-'", "'*'", "'/'", "'''"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, "LINE_COMMENT", "LONG_COMMENT", "STRING_CONSTANT",
"CLASS", "EXTENDS", "IMPLEMENTS", "BREAKPOINT", "CASE", "CATCH", "CMP",
"CMPG", "CMPL", "DEFAULT", "ENTERMONITOR", "EXITMONITOR", "GOTO", "IF",
"INSTANCEOF", "LENGTHOF", "SWITCH", "NEG", "NEWARRAY", "NEWMULTIARRAY",
"NEW", "NOP", "RETURN", "RET", "NONSTATIC_INVOKE", "STATICINVOKE", "DYNAMICINVOKE",
"THROWS", "THROW", "NULL", "FROM", "TO", "WITH", "COMMA", "L_BRACE",
"R_BRACE", "SEMICOLON", "L_BRACKET", "R_BRACKET", "L_PAREN", "R_PAREN",
"COLON", "DOT", "EQUALS", "COLON_EQUALS", "AND", "OR", "XOR", "MOD",
"CMPEQ", "CMPNE", "CMPGT", "CMPGE", "CMPLT", "CMPLE", "SHL", "SHR", "USHR",
"PLUS", "MINUS", "MULT", "DIV", "QUOTE", "BOOL_CONSTANT", "FLOAT_CONSTANT",
"DEC_CONSTANT", "HEX_CONSTANT", "IDENTIFIER", "BLANK"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "Jimple.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public JimpleParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class IdentifierContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(JimpleParser.IDENTIFIER, 0); }
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 0, RULE_identifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(96);
match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Integer_constantContext extends ParserRuleContext {
public TerminalNode DEC_CONSTANT() { return getToken(JimpleParser.DEC_CONSTANT, 0); }
public TerminalNode HEX_CONSTANT() { return getToken(JimpleParser.HEX_CONSTANT, 0); }
public TerminalNode PLUS() { return getToken(JimpleParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(JimpleParser.MINUS, 0); }
public Integer_constantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_integer_constant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterInteger_constant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitInteger_constant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitInteger_constant(this);
else return visitor.visitChildren(this);
}
}
public final Integer_constantContext integer_constant() throws RecognitionException {
Integer_constantContext _localctx = new Integer_constantContext(_ctx, getState());
enterRule(_localctx, 2, RULE_integer_constant);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(99);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(98);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(101);
_la = _input.LA(1);
if ( !(_la==DEC_CONSTANT || _la==HEX_CONSTANT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(103);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0) {
{
setState(102);
match(T__0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FileContext extends ParserRuleContext {
public Token classname;
public File_typeContext file_type() {
return getRuleContext(File_typeContext.class,0);
}
public TerminalNode L_BRACE() { return getToken(JimpleParser.L_BRACE, 0); }
public TerminalNode R_BRACE() { return getToken(JimpleParser.R_BRACE, 0); }
public TerminalNode EOF() { return getToken(JimpleParser.EOF, 0); }
public TerminalNode IDENTIFIER() { return getToken(JimpleParser.IDENTIFIER, 0); }
public List importItem() {
return getRuleContexts(ImportItemContext.class);
}
public ImportItemContext importItem(int i) {
return getRuleContext(ImportItemContext.class,i);
}
public List class_modifier() {
return getRuleContexts(Class_modifierContext.class);
}
public Class_modifierContext class_modifier(int i) {
return getRuleContext(Class_modifierContext.class,i);
}
public Extends_clauseContext extends_clause() {
return getRuleContext(Extends_clauseContext.class,0);
}
public Implements_clauseContext implements_clause() {
return getRuleContext(Implements_clauseContext.class,0);
}
public List member() {
return getRuleContexts(MemberContext.class);
}
public MemberContext member(int i) {
return getRuleContext(MemberContext.class,i);
}
public FileContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_file; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterFile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitFile(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitFile(this);
else return visitor.visitChildren(this);
}
}
public final FileContext file() throws RecognitionException {
FileContext _localctx = new FileContext(_ctx, getState());
enterRule(_localctx, 4, RULE_file);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(108);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(105);
importItem();
}
}
setState(110);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(114);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10))) != 0)) {
{
{
setState(111);
class_modifier();
}
}
setState(116);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(117);
file_type();
setState(118);
((FileContext)_localctx).classname = match(IDENTIFIER);
setState(120);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(119);
extends_clause();
}
}
setState(123);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(122);
implements_clause();
}
}
setState(125);
match(L_BRACE);
setState(129);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15) | (1L << T__16) | (1L << T__17))) != 0) || _la==IDENTIFIER) {
{
{
setState(126);
member();
}
}
setState(131);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(132);
match(R_BRACE);
setState(133);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportItemContext extends ParserRuleContext {
public IdentifierContext location;
public TerminalNode SEMICOLON() { return getToken(JimpleParser.SEMICOLON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ImportItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterImportItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitImportItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitImportItem(this);
else return visitor.visitChildren(this);
}
}
public final ImportItemContext importItem() throws RecognitionException {
ImportItemContext _localctx = new ImportItemContext(_ctx, getState());
enterRule(_localctx, 6, RULE_importItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(135);
match(T__1);
setState(136);
((ImportItemContext)_localctx).location = identifier();
setState(137);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Common_modifierContext extends ParserRuleContext {
public Common_modifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_common_modifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterCommon_modifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitCommon_modifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitCommon_modifier(this);
else return visitor.visitChildren(this);
}
}
public final Common_modifierContext common_modifier() throws RecognitionException {
Common_modifierContext _localctx = new Common_modifierContext(_ctx, getState());
enterRule(_localctx, 8, RULE_common_modifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(139);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Class_modifierContext extends ParserRuleContext {
public Common_modifierContext common_modifier() {
return getRuleContext(Common_modifierContext.class,0);
}
public Class_modifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_class_modifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterClass_modifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitClass_modifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitClass_modifier(this);
else return visitor.visitChildren(this);
}
}
public final Class_modifierContext class_modifier() throws RecognitionException {
Class_modifierContext _localctx = new Class_modifierContext(_ctx, getState());
enterRule(_localctx, 10, RULE_class_modifier);
try {
setState(144);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
enterOuterAlt(_localctx, 1);
{
setState(141);
common_modifier();
}
break;
case T__9:
enterOuterAlt(_localctx, 2);
{
setState(142);
match(T__9);
}
break;
case T__10:
enterOuterAlt(_localctx, 3);
{
setState(143);
match(T__10);
}
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 Method_modifierContext extends ParserRuleContext {
public Common_modifierContext common_modifier() {
return getRuleContext(Common_modifierContext.class,0);
}
public Method_modifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_method_modifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterMethod_modifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitMethod_modifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitMethod_modifier(this);
else return visitor.visitChildren(this);
}
}
public final Method_modifierContext method_modifier() throws RecognitionException {
Method_modifierContext _localctx = new Method_modifierContext(_ctx, getState());
enterRule(_localctx, 12, RULE_method_modifier);
try {
setState(154);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
enterOuterAlt(_localctx, 1);
{
setState(146);
common_modifier();
}
break;
case T__9:
enterOuterAlt(_localctx, 2);
{
setState(147);
match(T__9);
}
break;
case T__11:
enterOuterAlt(_localctx, 3);
{
setState(148);
match(T__11);
}
break;
case T__12:
enterOuterAlt(_localctx, 4);
{
setState(149);
match(T__12);
}
break;
case T__13:
enterOuterAlt(_localctx, 5);
{
setState(150);
match(T__13);
}
break;
case T__14:
enterOuterAlt(_localctx, 6);
{
setState(151);
match(T__14);
}
break;
case T__15:
enterOuterAlt(_localctx, 7);
{
setState(152);
match(T__15);
}
break;
case T__16:
enterOuterAlt(_localctx, 8);
{
setState(153);
match(T__16);
}
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 Field_modifierContext extends ParserRuleContext {
public Common_modifierContext common_modifier() {
return getRuleContext(Common_modifierContext.class,0);
}
public Field_modifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_field_modifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterField_modifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitField_modifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitField_modifier(this);
else return visitor.visitChildren(this);
}
}
public final Field_modifierContext field_modifier() throws RecognitionException {
Field_modifierContext _localctx = new Field_modifierContext(_ctx, getState());
enterRule(_localctx, 14, RULE_field_modifier);
try {
setState(159);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
enterOuterAlt(_localctx, 1);
{
setState(156);
common_modifier();
}
break;
case T__16:
enterOuterAlt(_localctx, 2);
{
setState(157);
match(T__16);
}
break;
case T__17:
enterOuterAlt(_localctx, 3);
{
setState(158);
match(T__17);
}
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 File_typeContext extends ParserRuleContext {
public TerminalNode CLASS() { return getToken(JimpleParser.CLASS, 0); }
public File_typeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_file_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterFile_type(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitFile_type(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitFile_type(this);
else return visitor.visitChildren(this);
}
}
public final File_typeContext file_type() throws RecognitionException {
File_typeContext _localctx = new File_typeContext(_ctx, getState());
enterRule(_localctx, 16, RULE_file_type);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(161);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << CLASS))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Extends_clauseContext extends ParserRuleContext {
public IdentifierContext classname;
public TerminalNode EXTENDS() { return getToken(JimpleParser.EXTENDS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Extends_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extends_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterExtends_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitExtends_clause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitExtends_clause(this);
else return visitor.visitChildren(this);
}
}
public final Extends_clauseContext extends_clause() throws RecognitionException {
Extends_clauseContext _localctx = new Extends_clauseContext(_ctx, getState());
enterRule(_localctx, 18, RULE_extends_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(163);
match(EXTENDS);
setState(164);
((Extends_clauseContext)_localctx).classname = identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Implements_clauseContext extends ParserRuleContext {
public TerminalNode IMPLEMENTS() { return getToken(JimpleParser.IMPLEMENTS, 0); }
public Type_listContext type_list() {
return getRuleContext(Type_listContext.class,0);
}
public Implements_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_implements_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterImplements_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitImplements_clause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitImplements_clause(this);
else return visitor.visitChildren(this);
}
}
public final Implements_clauseContext implements_clause() throws RecognitionException {
Implements_clauseContext _localctx = new Implements_clauseContext(_ctx, getState());
enterRule(_localctx, 20, RULE_implements_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(166);
match(IMPLEMENTS);
setState(167);
type_list();
}
}
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 IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List L_BRACKET() { return getTokens(JimpleParser.L_BRACKET); }
public TerminalNode L_BRACKET(int i) {
return getToken(JimpleParser.L_BRACKET, i);
}
public List R_BRACKET() { return getTokens(JimpleParser.R_BRACKET); }
public TerminalNode R_BRACKET(int i) {
return getToken(JimpleParser.R_BRACKET, i);
}
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitType(this);
else return visitor.visitChildren(this);
}
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 22, RULE_type);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(169);
identifier();
setState(174);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==L_BRACKET) {
{
{
setState(170);
match(L_BRACKET);
setState(171);
match(R_BRACKET);
}
}
setState(176);
_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 Type_listContext extends ParserRuleContext {
public List type() {
return getRuleContexts(TypeContext.class);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public List COMMA() { return getTokens(JimpleParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JimpleParser.COMMA, i);
}
public Type_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterType_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitType_list(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitType_list(this);
else return visitor.visitChildren(this);
}
}
public final Type_listContext type_list() throws RecognitionException {
Type_listContext _localctx = new Type_listContext(_ctx, getState());
enterRule(_localctx, 24, RULE_type_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(177);
type();
setState(182);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(178);
match(COMMA);
setState(179);
type();
}
}
setState(184);
_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 MemberContext extends ParserRuleContext {
public FieldContext field() {
return getRuleContext(FieldContext.class,0);
}
public MethodContext method() {
return getRuleContext(MethodContext.class,0);
}
public MemberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_member; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterMember(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitMember(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitMember(this);
else return visitor.visitChildren(this);
}
}
public final MemberContext member() throws RecognitionException {
MemberContext _localctx = new MemberContext(_ctx, getState());
enterRule(_localctx, 26, RULE_member);
try {
setState(187);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(185);
field();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(186);
method();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(JimpleParser.SEMICOLON, 0); }
public List field_modifier() {
return getRuleContexts(Field_modifierContext.class);
}
public Field_modifierContext field_modifier(int i) {
return getRuleContext(Field_modifierContext.class,i);
}
public FieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_field; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitField(this);
else return visitor.visitChildren(this);
}
}
public final FieldContext field() throws RecognitionException {
FieldContext _localctx = new FieldContext(_ctx, getState());
enterRule(_localctx, 28, RULE_field);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(192);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__16) | (1L << T__17))) != 0)) {
{
{
setState(189);
field_modifier();
}
}
setState(194);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(195);
type();
setState(196);
identifier();
setState(197);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodContext extends ParserRuleContext {
public Method_subsignatureContext method_subsignature() {
return getRuleContext(Method_subsignatureContext.class,0);
}
public Method_bodyContext method_body() {
return getRuleContext(Method_bodyContext.class,0);
}
public List method_modifier() {
return getRuleContexts(Method_modifierContext.class);
}
public Method_modifierContext method_modifier(int i) {
return getRuleContext(Method_modifierContext.class,i);
}
public Throws_clauseContext throws_clause() {
return getRuleContext(Throws_clauseContext.class,0);
}
public MethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_method; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterMethod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitMethod(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitMethod(this);
else return visitor.visitChildren(this);
}
}
public final MethodContext method() throws RecognitionException {
MethodContext _localctx = new MethodContext(_ctx, getState());
enterRule(_localctx, 30, RULE_method);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(202);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15) | (1L << T__16))) != 0)) {
{
{
setState(199);
method_modifier();
}
}
setState(204);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(205);
method_subsignature();
setState(207);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(206);
throws_clause();
}
}
setState(209);
method_body();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Method_nameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Method_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_method_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterMethod_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitMethod_name(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitMethod_name(this);
else return visitor.visitChildren(this);
}
}
public final Method_nameContext method_name() throws RecognitionException {
Method_nameContext _localctx = new Method_nameContext(_ctx, getState());
enterRule(_localctx, 32, RULE_method_name);
try {
setState(214);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__20:
enterOuterAlt(_localctx, 1);
{
setState(211);
match(T__20);
}
break;
case T__21:
enterOuterAlt(_localctx, 2);
{
setState(212);
match(T__21);
}
break;
case IDENTIFIER:
enterOuterAlt(_localctx, 3);
{
setState(213);
identifier();
}
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 Throws_clauseContext extends ParserRuleContext {
public TerminalNode THROWS() { return getToken(JimpleParser.THROWS, 0); }
public Type_listContext type_list() {
return getRuleContext(Type_listContext.class,0);
}
public Throws_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_throws_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterThrows_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitThrows_clause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitThrows_clause(this);
else return visitor.visitChildren(this);
}
}
public final Throws_clauseContext throws_clause() throws RecognitionException {
Throws_clauseContext _localctx = new Throws_clauseContext(_ctx, getState());
enterRule(_localctx, 34, RULE_throws_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(216);
match(THROWS);
setState(217);
type_list();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Method_bodyContext extends ParserRuleContext {
public TerminalNode SEMICOLON() { return getToken(JimpleParser.SEMICOLON, 0); }
public TerminalNode L_BRACE() { return getToken(JimpleParser.L_BRACE, 0); }
public Method_body_contentsContext method_body_contents() {
return getRuleContext(Method_body_contentsContext.class,0);
}
public TerminalNode R_BRACE() { return getToken(JimpleParser.R_BRACE, 0); }
public Method_bodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_method_body; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterMethod_body(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitMethod_body(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitMethod_body(this);
else return visitor.visitChildren(this);
}
}
public final Method_bodyContext method_body() throws RecognitionException {
Method_bodyContext _localctx = new Method_bodyContext(_ctx, getState());
enterRule(_localctx, 36, RULE_method_body);
try {
setState(224);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SEMICOLON:
enterOuterAlt(_localctx, 1);
{
setState(219);
match(SEMICOLON);
}
break;
case L_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(220);
match(L_BRACE);
setState(221);
method_body_contents();
setState(222);
match(R_BRACE);
}
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 Method_body_contentsContext extends ParserRuleContext {
public DeclarationsContext declarations() {
return getRuleContext(DeclarationsContext.class,0);
}
public StatementsContext statements() {
return getRuleContext(StatementsContext.class,0);
}
public Trap_clausesContext trap_clauses() {
return getRuleContext(Trap_clausesContext.class,0);
}
public Method_body_contentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_method_body_contents; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterMethod_body_contents(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitMethod_body_contents(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitMethod_body_contents(this);
else return visitor.visitChildren(this);
}
}
public final Method_body_contentsContext method_body_contents() throws RecognitionException {
Method_body_contentsContext _localctx = new Method_body_contentsContext(_ctx, getState());
enterRule(_localctx, 38, RULE_method_body_contents);
try {
enterOuterAlt(_localctx, 1);
{
setState(226);
declarations();
setState(227);
statements();
setState(228);
trap_clauses();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Trap_clausesContext extends ParserRuleContext {
public List trap_clause() {
return getRuleContexts(Trap_clauseContext.class);
}
public Trap_clauseContext trap_clause(int i) {
return getRuleContext(Trap_clauseContext.class,i);
}
public Trap_clausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trap_clauses; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterTrap_clauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitTrap_clauses(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitTrap_clauses(this);
else return visitor.visitChildren(this);
}
}
public final Trap_clausesContext trap_clauses() throws RecognitionException {
Trap_clausesContext _localctx = new Trap_clausesContext(_ctx, getState());
enterRule(_localctx, 40, RULE_trap_clauses);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(233);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CATCH) {
{
{
setState(230);
trap_clause();
}
}
setState(235);
_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 StatementsContext extends ParserRuleContext {
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public StatementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterStatements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitStatements(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitStatements(this);
else return visitor.visitChildren(this);
}
}
public final StatementsContext statements() throws RecognitionException {
StatementsContext _localctx = new StatementsContext(_ctx, getState());
enterRule(_localctx, 42, RULE_statements);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(239);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BREAKPOINT) | (1L << ENTERMONITOR) | (1L << EXITMONITOR) | (1L << GOTO) | (1L << IF) | (1L << SWITCH) | (1L << NOP) | (1L << RETURN) | (1L << RET) | (1L << NONSTATIC_INVOKE) | (1L << STATICINVOKE) | (1L << DYNAMICINVOKE) | (1L << THROW))) != 0) || _la==CMPLT || _la==IDENTIFIER) {
{
{
setState(236);
statement();
}
}
setState(241);
_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 DeclarationsContext extends ParserRuleContext {
public List declaration() {
return getRuleContexts(DeclarationContext.class);
}
public DeclarationContext declaration(int i) {
return getRuleContext(DeclarationContext.class,i);
}
public DeclarationsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declarations; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterDeclarations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitDeclarations(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitDeclarations(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationsContext declarations() throws RecognitionException {
DeclarationsContext _localctx = new DeclarationsContext(_ctx, getState());
enterRule(_localctx, 44, RULE_declarations);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(245);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(242);
declaration();
}
}
}
setState(247);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public Arg_listContext arg_list() {
return getRuleContext(Arg_listContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(JimpleParser.SEMICOLON, 0); }
public DeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationContext declaration() throws RecognitionException {
DeclarationContext _localctx = new DeclarationContext(_ctx, getState());
enterRule(_localctx, 46, RULE_declaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(248);
type();
setState(249);
arg_list();
setState(250);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public IdentifierContext label_name;
public StmtContext stmt() {
return getRuleContext(StmtContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(JimpleParser.SEMICOLON, 0); }
public TerminalNode COLON() { return getToken(JimpleParser.COLON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 48, RULE_statement);
try {
enterOuterAlt(_localctx, 1);
{
setState(255);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(252);
((StatementContext)_localctx).label_name = identifier();
setState(253);
match(COLON);
}
break;
}
setState(257);
stmt();
setState(258);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StmtContext extends ParserRuleContext {
public AssignmentsContext assignments() {
return getRuleContext(AssignmentsContext.class,0);
}
public Goto_stmtContext goto_stmt() {
return getRuleContext(Goto_stmtContext.class,0);
}
public TerminalNode IF() { return getToken(JimpleParser.IF, 0); }
public Bool_exprContext bool_expr() {
return getRuleContext(Bool_exprContext.class,0);
}
public Invoke_exprContext invoke_expr() {
return getRuleContext(Invoke_exprContext.class,0);
}
public TerminalNode RETURN() { return getToken(JimpleParser.RETURN, 0); }
public ImmediateContext immediate() {
return getRuleContext(ImmediateContext.class,0);
}
public TerminalNode SWITCH() { return getToken(JimpleParser.SWITCH, 0); }
public TerminalNode L_PAREN() { return getToken(JimpleParser.L_PAREN, 0); }
public TerminalNode R_PAREN() { return getToken(JimpleParser.R_PAREN, 0); }
public TerminalNode L_BRACE() { return getToken(JimpleParser.L_BRACE, 0); }
public TerminalNode R_BRACE() { return getToken(JimpleParser.R_BRACE, 0); }
public List case_stmt() {
return getRuleContexts(Case_stmtContext.class);
}
public Case_stmtContext case_stmt(int i) {
return getRuleContext(Case_stmtContext.class,i);
}
public TerminalNode RET() { return getToken(JimpleParser.RET, 0); }
public TerminalNode THROW() { return getToken(JimpleParser.THROW, 0); }
public TerminalNode ENTERMONITOR() { return getToken(JimpleParser.ENTERMONITOR, 0); }
public TerminalNode EXITMONITOR() { return getToken(JimpleParser.EXITMONITOR, 0); }
public TerminalNode NOP() { return getToken(JimpleParser.NOP, 0); }
public TerminalNode BREAKPOINT() { return getToken(JimpleParser.BREAKPOINT, 0); }
public StmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitStmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitStmt(this);
else return visitor.visitChildren(this);
}
}
public final StmtContext stmt() throws RecognitionException {
StmtContext _localctx = new StmtContext(_ctx, getState());
enterRule(_localctx, 50, RULE_stmt);
int _la;
try {
setState(295);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CMPLT:
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(260);
assignments();
}
break;
case GOTO:
case IF:
enterOuterAlt(_localctx, 2);
{
setState(263);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(261);
match(IF);
setState(262);
bool_expr();
}
}
setState(265);
goto_stmt();
}
break;
case NONSTATIC_INVOKE:
case STATICINVOKE:
case DYNAMICINVOKE:
enterOuterAlt(_localctx, 3);
{
setState(266);
invoke_expr();
}
break;
case RETURN:
enterOuterAlt(_localctx, 4);
{
setState(267);
match(RETURN);
setState(269);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__25) | (1L << T__26) | (1L << STRING_CONSTANT) | (1L << CLASS) | (1L << NULL))) != 0) || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & ((1L << (PLUS - 89)) | (1L << (MINUS - 89)) | (1L << (BOOL_CONSTANT - 89)) | (1L << (FLOAT_CONSTANT - 89)) | (1L << (DEC_CONSTANT - 89)) | (1L << (HEX_CONSTANT - 89)) | (1L << (IDENTIFIER - 89)))) != 0)) {
{
setState(268);
immediate();
}
}
}
break;
case SWITCH:
enterOuterAlt(_localctx, 5);
{
setState(271);
match(SWITCH);
setState(272);
match(L_PAREN);
setState(273);
immediate();
setState(274);
match(R_PAREN);
setState(275);
match(L_BRACE);
setState(277);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(276);
case_stmt();
}
}
setState(279);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==CASE || _la==DEFAULT );
setState(281);
match(R_BRACE);
}
break;
case RET:
enterOuterAlt(_localctx, 6);
{
setState(283);
match(RET);
setState(285);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__25) | (1L << T__26) | (1L << STRING_CONSTANT) | (1L << CLASS) | (1L << NULL))) != 0) || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & ((1L << (PLUS - 89)) | (1L << (MINUS - 89)) | (1L << (BOOL_CONSTANT - 89)) | (1L << (FLOAT_CONSTANT - 89)) | (1L << (DEC_CONSTANT - 89)) | (1L << (HEX_CONSTANT - 89)) | (1L << (IDENTIFIER - 89)))) != 0)) {
{
setState(284);
immediate();
}
}
}
break;
case THROW:
enterOuterAlt(_localctx, 7);
{
setState(287);
match(THROW);
setState(288);
immediate();
}
break;
case ENTERMONITOR:
enterOuterAlt(_localctx, 8);
{
setState(289);
match(ENTERMONITOR);
setState(290);
immediate();
}
break;
case EXITMONITOR:
enterOuterAlt(_localctx, 9);
{
setState(291);
match(EXITMONITOR);
setState(292);
immediate();
}
break;
case NOP:
enterOuterAlt(_localctx, 10);
{
setState(293);
match(NOP);
}
break;
case BREAKPOINT:
enterOuterAlt(_localctx, 11);
{
setState(294);
match(BREAKPOINT);
}
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 AssignmentsContext extends ParserRuleContext {
public IdentifierContext local;
public TerminalNode COLON_EQUALS() { return getToken(JimpleParser.COLON_EQUALS, 0); }
public Identity_refContext identity_ref() {
return getRuleContext(Identity_refContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode EQUALS() { return getToken(JimpleParser.EQUALS, 0); }
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public ReferenceContext reference() {
return getRuleContext(ReferenceContext.class,0);
}
public AssignmentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterAssignments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitAssignments(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitAssignments(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentsContext assignments() throws RecognitionException {
AssignmentsContext _localctx = new AssignmentsContext(_ctx, getState());
enterRule(_localctx, 52, RULE_assignments);
try {
setState(308);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(297);
((AssignmentsContext)_localctx).local = identifier();
setState(298);
match(COLON_EQUALS);
setState(299);
identity_ref();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(303);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
{
setState(301);
reference();
}
break;
case 2:
{
setState(302);
((AssignmentsContext)_localctx).local = identifier();
}
break;
}
setState(305);
match(EQUALS);
setState(306);
value();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Identity_refContext extends ParserRuleContext {
public Token parameter_idx;
public Token caught;
public TerminalNode COLON() { return getToken(JimpleParser.COLON, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode DEC_CONSTANT() { return getToken(JimpleParser.DEC_CONSTANT, 0); }
public Identity_refContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identity_ref; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterIdentity_ref(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitIdentity_ref(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitIdentity_ref(this);
else return visitor.visitChildren(this);
}
}
public final Identity_refContext identity_ref() throws RecognitionException {
Identity_refContext _localctx = new Identity_refContext(_ctx, getState());
enterRule(_localctx, 54, RULE_identity_ref);
try {
setState(317);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__22:
enterOuterAlt(_localctx, 1);
{
setState(310);
match(T__22);
setState(311);
((Identity_refContext)_localctx).parameter_idx = match(DEC_CONSTANT);
setState(312);
match(COLON);
setState(313);
type();
}
break;
case T__23:
enterOuterAlt(_localctx, 2);
{
setState(314);
match(T__23);
setState(315);
type();
}
break;
case T__24:
enterOuterAlt(_localctx, 3);
{
setState(316);
((Identity_refContext)_localctx).caught = match(T__24);
}
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 Case_stmtContext extends ParserRuleContext {
public Case_labelContext case_label() {
return getRuleContext(Case_labelContext.class,0);
}
public TerminalNode COLON() { return getToken(JimpleParser.COLON, 0); }
public Goto_stmtContext goto_stmt() {
return getRuleContext(Goto_stmtContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(JimpleParser.SEMICOLON, 0); }
public Case_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_case_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterCase_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitCase_stmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitCase_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Case_stmtContext case_stmt() throws RecognitionException {
Case_stmtContext _localctx = new Case_stmtContext(_ctx, getState());
enterRule(_localctx, 56, RULE_case_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(319);
case_label();
setState(320);
match(COLON);
setState(321);
goto_stmt();
setState(322);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Case_labelContext extends ParserRuleContext {
public TerminalNode CASE() { return getToken(JimpleParser.CASE, 0); }
public Integer_constantContext integer_constant() {
return getRuleContext(Integer_constantContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(JimpleParser.DEFAULT, 0); }
public Case_labelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_case_label; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterCase_label(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitCase_label(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitCase_label(this);
else return visitor.visitChildren(this);
}
}
public final Case_labelContext case_label() throws RecognitionException {
Case_labelContext _localctx = new Case_labelContext(_ctx, getState());
enterRule(_localctx, 58, RULE_case_label);
try {
setState(327);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CASE:
enterOuterAlt(_localctx, 1);
{
setState(324);
match(CASE);
setState(325);
integer_constant();
}
break;
case DEFAULT:
enterOuterAlt(_localctx, 2);
{
setState(326);
match(DEFAULT);
}
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 Goto_stmtContext extends ParserRuleContext {
public IdentifierContext label_name;
public TerminalNode GOTO() { return getToken(JimpleParser.GOTO, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Goto_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_goto_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterGoto_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitGoto_stmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitGoto_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Goto_stmtContext goto_stmt() throws RecognitionException {
Goto_stmtContext _localctx = new Goto_stmtContext(_ctx, getState());
enterRule(_localctx, 60, RULE_goto_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(329);
match(GOTO);
setState(330);
((Goto_stmtContext)_localctx).label_name = identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Trap_clauseContext extends ParserRuleContext {
public IdentifierContext exceptiontype;
public IdentifierContext from;
public IdentifierContext to;
public IdentifierContext with;
public TerminalNode CATCH() { return getToken(JimpleParser.CATCH, 0); }
public TerminalNode FROM() { return getToken(JimpleParser.FROM, 0); }
public TerminalNode TO() { return getToken(JimpleParser.TO, 0); }
public TerminalNode WITH() { return getToken(JimpleParser.WITH, 0); }
public TerminalNode SEMICOLON() { return getToken(JimpleParser.SEMICOLON, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public Trap_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trap_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterTrap_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitTrap_clause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitTrap_clause(this);
else return visitor.visitChildren(this);
}
}
public final Trap_clauseContext trap_clause() throws RecognitionException {
Trap_clauseContext _localctx = new Trap_clauseContext(_ctx, getState());
enterRule(_localctx, 62, RULE_trap_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(332);
match(CATCH);
setState(333);
((Trap_clauseContext)_localctx).exceptiontype = identifier();
setState(334);
match(FROM);
setState(335);
((Trap_clauseContext)_localctx).from = identifier();
setState(336);
match(TO);
setState(337);
((Trap_clauseContext)_localctx).to = identifier();
setState(338);
match(WITH);
setState(339);
((Trap_clauseContext)_localctx).with = identifier();
setState(340);
match(SEMICOLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValueContext extends ParserRuleContext {
public IdentifierContext base_type;
public TypeContext array_type;
public TypeContext multiarray_type;
public TypeContext nonvoid_cast;
public ImmediateContext op;
public TypeContext nonvoid_type;
public List immediate() {
return getRuleContexts(ImmediateContext.class);
}
public ImmediateContext immediate(int i) {
return getRuleContext(ImmediateContext.class,i);
}
public ReferenceContext reference() {
return getRuleContext(ReferenceContext.class,0);
}
public TerminalNode NEW() { return getToken(JimpleParser.NEW, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode NEWARRAY() { return getToken(JimpleParser.NEWARRAY, 0); }
public TerminalNode L_PAREN() { return getToken(JimpleParser.L_PAREN, 0); }
public TerminalNode R_PAREN() { return getToken(JimpleParser.R_PAREN, 0); }
public Array_descriptorContext array_descriptor() {
return getRuleContext(Array_descriptorContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode NEWMULTIARRAY() { return getToken(JimpleParser.NEWMULTIARRAY, 0); }
public List L_BRACKET() { return getTokens(JimpleParser.L_BRACKET); }
public TerminalNode L_BRACKET(int i) {
return getToken(JimpleParser.L_BRACKET, i);
}
public List R_BRACKET() { return getTokens(JimpleParser.R_BRACKET); }
public TerminalNode R_BRACKET(int i) {
return getToken(JimpleParser.R_BRACKET, i);
}
public TerminalNode INSTANCEOF() { return getToken(JimpleParser.INSTANCEOF, 0); }
public Binop_exprContext binop_expr() {
return getRuleContext(Binop_exprContext.class,0);
}
public Invoke_exprContext invoke_expr() {
return getRuleContext(Invoke_exprContext.class,0);
}
public Unop_exprContext unop_expr() {
return getRuleContext(Unop_exprContext.class,0);
}
public ValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitValue(this);
else return visitor.visitChildren(this);
}
}
public final ValueContext value() throws RecognitionException {
ValueContext _localctx = new ValueContext(_ctx, getState());
enterRule(_localctx, 64, RULE_value);
int _la;
try {
setState(377);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(342);
immediate();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(343);
reference();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(344);
match(NEW);
setState(345);
((ValueContext)_localctx).base_type = identifier();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(346);
match(NEWARRAY);
setState(347);
match(L_PAREN);
setState(348);
((ValueContext)_localctx).array_type = type();
setState(349);
match(R_PAREN);
setState(350);
array_descriptor();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(352);
match(NEWMULTIARRAY);
setState(353);
match(L_PAREN);
setState(354);
((ValueContext)_localctx).multiarray_type = type();
setState(355);
match(R_PAREN);
setState(361);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(356);
match(L_BRACKET);
setState(358);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__25) | (1L << T__26) | (1L << STRING_CONSTANT) | (1L << CLASS) | (1L << NULL))) != 0) || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & ((1L << (PLUS - 89)) | (1L << (MINUS - 89)) | (1L << (BOOL_CONSTANT - 89)) | (1L << (FLOAT_CONSTANT - 89)) | (1L << (DEC_CONSTANT - 89)) | (1L << (HEX_CONSTANT - 89)) | (1L << (IDENTIFIER - 89)))) != 0)) {
{
setState(357);
immediate();
}
}
setState(360);
match(R_BRACKET);
}
}
setState(363);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==L_BRACKET );
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(365);
match(L_PAREN);
setState(366);
((ValueContext)_localctx).nonvoid_cast = type();
setState(367);
match(R_PAREN);
setState(368);
((ValueContext)_localctx).op = immediate();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(370);
((ValueContext)_localctx).op = immediate();
setState(371);
match(INSTANCEOF);
setState(372);
((ValueContext)_localctx).nonvoid_type = type();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(374);
binop_expr();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(375);
invoke_expr();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(376);
unop_expr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Bool_exprContext extends ParserRuleContext {
public Binop_exprContext binop_expr() {
return getRuleContext(Binop_exprContext.class,0);
}
public Unop_exprContext unop_expr() {
return getRuleContext(Unop_exprContext.class,0);
}
public Bool_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterBool_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitBool_expr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitBool_expr(this);
else return visitor.visitChildren(this);
}
}
public final Bool_exprContext bool_expr() throws RecognitionException {
Bool_exprContext _localctx = new Bool_exprContext(_ctx, getState());
enterRule(_localctx, 66, RULE_bool_expr);
try {
setState(381);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__25:
case T__26:
case STRING_CONSTANT:
case CLASS:
case NULL:
case PLUS:
case MINUS:
case BOOL_CONSTANT:
case FLOAT_CONSTANT:
case DEC_CONSTANT:
case HEX_CONSTANT:
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(379);
binop_expr();
}
break;
case LENGTHOF:
case NEG:
enterOuterAlt(_localctx, 2);
{
setState(380);
unop_expr();
}
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 Invoke_exprContext extends ParserRuleContext {
public Token nonstaticinvoke;
public IdentifierContext local_name;
public Token staticinvoke;
public Token dynamicinvoke;
public Token unnamed_method_name;
public TypeContext name;
public Type_listContext parameter_list;
public Arg_listContext dyn_args;
public Method_signatureContext bsm;
public Arg_listContext staticargs;
public TerminalNode DOT() { return getToken(JimpleParser.DOT, 0); }
public Method_signatureContext method_signature() {
return getRuleContext(Method_signatureContext.class,0);
}
public List L_PAREN() { return getTokens(JimpleParser.L_PAREN); }
public TerminalNode L_PAREN(int i) {
return getToken(JimpleParser.L_PAREN, i);
}
public List R_PAREN() { return getTokens(JimpleParser.R_PAREN); }
public TerminalNode R_PAREN(int i) {
return getToken(JimpleParser.R_PAREN, i);
}
public TerminalNode NONSTATIC_INVOKE() { return getToken(JimpleParser.NONSTATIC_INVOKE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List arg_list() {
return getRuleContexts(Arg_listContext.class);
}
public Arg_listContext arg_list(int i) {
return getRuleContext(Arg_listContext.class,i);
}
public TerminalNode STATICINVOKE() { return getToken(JimpleParser.STATICINVOKE, 0); }
public TerminalNode CMPLT() { return getToken(JimpleParser.CMPLT, 0); }
public TerminalNode CMPGT() { return getToken(JimpleParser.CMPGT, 0); }
public TerminalNode DYNAMICINVOKE() { return getToken(JimpleParser.DYNAMICINVOKE, 0); }
public TerminalNode STRING_CONSTANT() { return getToken(JimpleParser.STRING_CONSTANT, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public Type_listContext type_list() {
return getRuleContext(Type_listContext.class,0);
}
public Invoke_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_invoke_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterInvoke_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitInvoke_expr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitInvoke_expr(this);
else return visitor.visitChildren(this);
}
}
public final Invoke_exprContext invoke_expr() throws RecognitionException {
Invoke_exprContext _localctx = new Invoke_exprContext(_ctx, getState());
enterRule(_localctx, 68, RULE_invoke_expr);
int _la;
try {
setState(423);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NONSTATIC_INVOKE:
enterOuterAlt(_localctx, 1);
{
setState(383);
((Invoke_exprContext)_localctx).nonstaticinvoke = match(NONSTATIC_INVOKE);
setState(384);
((Invoke_exprContext)_localctx).local_name = identifier();
setState(385);
match(DOT);
setState(386);
method_signature();
setState(387);
match(L_PAREN);
setState(389);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__25) | (1L << T__26) | (1L << STRING_CONSTANT) | (1L << CLASS) | (1L << NULL))) != 0) || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & ((1L << (PLUS - 89)) | (1L << (MINUS - 89)) | (1L << (BOOL_CONSTANT - 89)) | (1L << (FLOAT_CONSTANT - 89)) | (1L << (DEC_CONSTANT - 89)) | (1L << (HEX_CONSTANT - 89)) | (1L << (IDENTIFIER - 89)))) != 0)) {
{
setState(388);
arg_list();
}
}
setState(391);
match(R_PAREN);
}
break;
case STATICINVOKE:
enterOuterAlt(_localctx, 2);
{
setState(393);
((Invoke_exprContext)_localctx).staticinvoke = match(STATICINVOKE);
setState(394);
method_signature();
setState(395);
match(L_PAREN);
setState(397);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__25) | (1L << T__26) | (1L << STRING_CONSTANT) | (1L << CLASS) | (1L << NULL))) != 0) || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & ((1L << (PLUS - 89)) | (1L << (MINUS - 89)) | (1L << (BOOL_CONSTANT - 89)) | (1L << (FLOAT_CONSTANT - 89)) | (1L << (DEC_CONSTANT - 89)) | (1L << (HEX_CONSTANT - 89)) | (1L << (IDENTIFIER - 89)))) != 0)) {
{
setState(396);
arg_list();
}
}
setState(399);
match(R_PAREN);
}
break;
case DYNAMICINVOKE:
enterOuterAlt(_localctx, 3);
{
setState(401);
((Invoke_exprContext)_localctx).dynamicinvoke = match(DYNAMICINVOKE);
setState(402);
((Invoke_exprContext)_localctx).unnamed_method_name = match(STRING_CONSTANT);
setState(403);
match(CMPLT);
setState(404);
((Invoke_exprContext)_localctx).name = type();
setState(405);
match(L_PAREN);
setState(407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENTIFIER) {
{
setState(406);
((Invoke_exprContext)_localctx).parameter_list = type_list();
}
}
setState(409);
match(R_PAREN);
setState(410);
match(CMPGT);
setState(411);
match(L_PAREN);
setState(413);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__25) | (1L << T__26) | (1L << STRING_CONSTANT) | (1L << CLASS) | (1L << NULL))) != 0) || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & ((1L << (PLUS - 89)) | (1L << (MINUS - 89)) | (1L << (BOOL_CONSTANT - 89)) | (1L << (FLOAT_CONSTANT - 89)) | (1L << (DEC_CONSTANT - 89)) | (1L << (HEX_CONSTANT - 89)) | (1L << (IDENTIFIER - 89)))) != 0)) {
{
setState(412);
((Invoke_exprContext)_localctx).dyn_args = arg_list();
}
}
setState(415);
match(R_PAREN);
setState(416);
((Invoke_exprContext)_localctx).bsm = method_signature();
setState(417);
match(L_PAREN);
setState(419);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__25) | (1L << T__26) | (1L << STRING_CONSTANT) | (1L << CLASS) | (1L << NULL))) != 0) || ((((_la - 89)) & ~0x3f) == 0 && ((1L << (_la - 89)) & ((1L << (PLUS - 89)) | (1L << (MINUS - 89)) | (1L << (BOOL_CONSTANT - 89)) | (1L << (FLOAT_CONSTANT - 89)) | (1L << (DEC_CONSTANT - 89)) | (1L << (HEX_CONSTANT - 89)) | (1L << (IDENTIFIER - 89)))) != 0)) {
{
setState(418);
((Invoke_exprContext)_localctx).staticargs = arg_list();
}
}
setState(421);
match(R_PAREN);
}
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 Binop_exprContext extends ParserRuleContext {
public ImmediateContext left;
public ImmediateContext right;
public BinopContext binop() {
return getRuleContext(BinopContext.class,0);
}
public List immediate() {
return getRuleContexts(ImmediateContext.class);
}
public ImmediateContext immediate(int i) {
return getRuleContext(ImmediateContext.class,i);
}
public Binop_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_binop_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterBinop_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitBinop_expr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitBinop_expr(this);
else return visitor.visitChildren(this);
}
}
public final Binop_exprContext binop_expr() throws RecognitionException {
Binop_exprContext _localctx = new Binop_exprContext(_ctx, getState());
enterRule(_localctx, 70, RULE_binop_expr);
try {
enterOuterAlt(_localctx, 1);
{
setState(425);
((Binop_exprContext)_localctx).left = immediate();
setState(426);
binop();
setState(427);
((Binop_exprContext)_localctx).right = immediate();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Unop_exprContext extends ParserRuleContext {
public UnopContext unop() {
return getRuleContext(UnopContext.class,0);
}
public ImmediateContext immediate() {
return getRuleContext(ImmediateContext.class,0);
}
public Unop_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unop_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterUnop_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitUnop_expr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitUnop_expr(this);
else return visitor.visitChildren(this);
}
}
public final Unop_exprContext unop_expr() throws RecognitionException {
Unop_exprContext _localctx = new Unop_exprContext(_ctx, getState());
enterRule(_localctx, 72, RULE_unop_expr);
try {
enterOuterAlt(_localctx, 1);
{
setState(429);
unop();
setState(430);
immediate();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Method_subsignatureContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public Method_nameContext method_name() {
return getRuleContext(Method_nameContext.class,0);
}
public TerminalNode L_PAREN() { return getToken(JimpleParser.L_PAREN, 0); }
public TerminalNode R_PAREN() { return getToken(JimpleParser.R_PAREN, 0); }
public Type_listContext type_list() {
return getRuleContext(Type_listContext.class,0);
}
public Method_subsignatureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_method_subsignature; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterMethod_subsignature(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitMethod_subsignature(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitMethod_subsignature(this);
else return visitor.visitChildren(this);
}
}
public final Method_subsignatureContext method_subsignature() throws RecognitionException {
Method_subsignatureContext _localctx = new Method_subsignatureContext(_ctx, getState());
enterRule(_localctx, 74, RULE_method_subsignature);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(432);
type();
setState(433);
method_name();
setState(434);
match(L_PAREN);
setState(436);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENTIFIER) {
{
setState(435);
type_list();
}
}
setState(438);
match(R_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Method_signatureContext extends ParserRuleContext {
public IdentifierContext class_name;
public TerminalNode CMPLT() { return getToken(JimpleParser.CMPLT, 0); }
public TerminalNode COLON() { return getToken(JimpleParser.COLON, 0); }
public Method_subsignatureContext method_subsignature() {
return getRuleContext(Method_subsignatureContext.class,0);
}
public TerminalNode CMPGT() { return getToken(JimpleParser.CMPGT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Method_signatureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_method_signature; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterMethod_signature(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitMethod_signature(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitMethod_signature(this);
else return visitor.visitChildren(this);
}
}
public final Method_signatureContext method_signature() throws RecognitionException {
Method_signatureContext _localctx = new Method_signatureContext(_ctx, getState());
enterRule(_localctx, 76, RULE_method_signature);
try {
enterOuterAlt(_localctx, 1);
{
setState(440);
match(CMPLT);
setState(441);
((Method_signatureContext)_localctx).class_name = identifier();
setState(442);
match(COLON);
setState(443);
method_subsignature();
setState(444);
match(CMPGT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReferenceContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Array_descriptorContext array_descriptor() {
return getRuleContext(Array_descriptorContext.class,0);
}
public TerminalNode DOT() { return getToken(JimpleParser.DOT, 0); }
public Field_signatureContext field_signature() {
return getRuleContext(Field_signatureContext.class,0);
}
public ReferenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reference; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitReference(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitReference(this);
else return visitor.visitChildren(this);
}
}
public final ReferenceContext reference() throws RecognitionException {
ReferenceContext _localctx = new ReferenceContext(_ctx, getState());
enterRule(_localctx, 78, RULE_reference);
try {
setState(454);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(446);
identifier();
setState(447);
array_descriptor();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(449);
identifier();
setState(450);
match(DOT);
setState(451);
field_signature();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(453);
field_signature();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Field_signatureContext extends ParserRuleContext {
public IdentifierContext classname;
public IdentifierContext fieldname;
public TerminalNode CMPLT() { return getToken(JimpleParser.CMPLT, 0); }
public TerminalNode COLON() { return getToken(JimpleParser.COLON, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode CMPGT() { return getToken(JimpleParser.CMPGT, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public Field_signatureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_field_signature; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterField_signature(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitField_signature(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitField_signature(this);
else return visitor.visitChildren(this);
}
}
public final Field_signatureContext field_signature() throws RecognitionException {
Field_signatureContext _localctx = new Field_signatureContext(_ctx, getState());
enterRule(_localctx, 80, RULE_field_signature);
try {
enterOuterAlt(_localctx, 1);
{
setState(456);
match(CMPLT);
setState(457);
((Field_signatureContext)_localctx).classname = identifier();
setState(458);
match(COLON);
setState(459);
type();
setState(460);
((Field_signatureContext)_localctx).fieldname = identifier();
setState(461);
match(CMPGT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Array_descriptorContext extends ParserRuleContext {
public TerminalNode L_BRACKET() { return getToken(JimpleParser.L_BRACKET, 0); }
public ImmediateContext immediate() {
return getRuleContext(ImmediateContext.class,0);
}
public TerminalNode R_BRACKET() { return getToken(JimpleParser.R_BRACKET, 0); }
public Array_descriptorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_array_descriptor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterArray_descriptor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitArray_descriptor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitArray_descriptor(this);
else return visitor.visitChildren(this);
}
}
public final Array_descriptorContext array_descriptor() throws RecognitionException {
Array_descriptorContext _localctx = new Array_descriptorContext(_ctx, getState());
enterRule(_localctx, 82, RULE_array_descriptor);
try {
enterOuterAlt(_localctx, 1);
{
setState(463);
match(L_BRACKET);
setState(464);
immediate();
setState(465);
match(R_BRACKET);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Arg_listContext extends ParserRuleContext {
public List immediate() {
return getRuleContexts(ImmediateContext.class);
}
public ImmediateContext immediate(int i) {
return getRuleContext(ImmediateContext.class,i);
}
public List COMMA() { return getTokens(JimpleParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JimpleParser.COMMA, i);
}
public Arg_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arg_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterArg_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitArg_list(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitArg_list(this);
else return visitor.visitChildren(this);
}
}
public final Arg_listContext arg_list() throws RecognitionException {
Arg_listContext _localctx = new Arg_listContext(_ctx, getState());
enterRule(_localctx, 84, RULE_arg_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(467);
immediate();
setState(472);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(468);
match(COMMA);
setState(469);
immediate();
}
}
setState(474);
_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 ImmediateContext extends ParserRuleContext {
public IdentifierContext local;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public ImmediateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_immediate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterImmediate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitImmediate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitImmediate(this);
else return visitor.visitChildren(this);
}
}
public final ImmediateContext immediate() throws RecognitionException {
ImmediateContext _localctx = new ImmediateContext(_ctx, getState());
enterRule(_localctx, 86, RULE_immediate);
try {
setState(477);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(475);
((ImmediateContext)_localctx).local = identifier();
}
break;
case T__25:
case T__26:
case STRING_CONSTANT:
case CLASS:
case NULL:
case PLUS:
case MINUS:
case BOOL_CONSTANT:
case FLOAT_CONSTANT:
case DEC_CONSTANT:
case HEX_CONSTANT:
enterOuterAlt(_localctx, 2);
{
setState(476);
constant();
}
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 MethodhandleContext extends ParserRuleContext {
public TerminalNode STRING_CONSTANT() { return getToken(JimpleParser.STRING_CONSTANT, 0); }
public Method_signatureContext method_signature() {
return getRuleContext(Method_signatureContext.class,0);
}
public Field_signatureContext field_signature() {
return getRuleContext(Field_signatureContext.class,0);
}
public MethodhandleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodhandle; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterMethodhandle(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitMethodhandle(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitMethodhandle(this);
else return visitor.visitChildren(this);
}
}
public final MethodhandleContext methodhandle() throws RecognitionException {
MethodhandleContext _localctx = new MethodhandleContext(_ctx, getState());
enterRule(_localctx, 88, RULE_methodhandle);
try {
enterOuterAlt(_localctx, 1);
{
setState(479);
match(T__25);
setState(480);
match(STRING_CONSTANT);
setState(483);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(481);
method_signature();
}
break;
case 2:
{
setState(482);
field_signature();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantContext extends ParserRuleContext {
public Token methodtype;
public TerminalNode BOOL_CONSTANT() { return getToken(JimpleParser.BOOL_CONSTANT, 0); }
public Integer_constantContext integer_constant() {
return getRuleContext(Integer_constantContext.class,0);
}
public TerminalNode FLOAT_CONSTANT() { return getToken(JimpleParser.FLOAT_CONSTANT, 0); }
public TerminalNode STRING_CONSTANT() { return getToken(JimpleParser.STRING_CONSTANT, 0); }
public TerminalNode CLASS() { return getToken(JimpleParser.CLASS, 0); }
public TerminalNode NULL() { return getToken(JimpleParser.NULL, 0); }
public MethodhandleContext methodhandle() {
return getRuleContext(MethodhandleContext.class,0);
}
public Method_subsignatureContext method_subsignature() {
return getRuleContext(Method_subsignatureContext.class,0);
}
public ConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitConstant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitConstant(this);
else return visitor.visitChildren(this);
}
}
public final ConstantContext constant() throws RecognitionException {
ConstantContext _localctx = new ConstantContext(_ctx, getState());
enterRule(_localctx, 90, RULE_constant);
try {
setState(495);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BOOL_CONSTANT:
enterOuterAlt(_localctx, 1);
{
setState(485);
match(BOOL_CONSTANT);
}
break;
case PLUS:
case MINUS:
case DEC_CONSTANT:
case HEX_CONSTANT:
enterOuterAlt(_localctx, 2);
{
setState(486);
integer_constant();
}
break;
case FLOAT_CONSTANT:
enterOuterAlt(_localctx, 3);
{
setState(487);
match(FLOAT_CONSTANT);
}
break;
case STRING_CONSTANT:
enterOuterAlt(_localctx, 4);
{
setState(488);
match(STRING_CONSTANT);
}
break;
case CLASS:
enterOuterAlt(_localctx, 5);
{
setState(489);
match(CLASS);
setState(490);
match(STRING_CONSTANT);
}
break;
case NULL:
enterOuterAlt(_localctx, 6);
{
setState(491);
match(NULL);
}
break;
case T__25:
enterOuterAlt(_localctx, 7);
{
setState(492);
methodhandle();
}
break;
case T__26:
enterOuterAlt(_localctx, 8);
{
setState(493);
((ConstantContext)_localctx).methodtype = match(T__26);
setState(494);
method_subsignature();
}
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 BinopContext extends ParserRuleContext {
public TerminalNode AND() { return getToken(JimpleParser.AND, 0); }
public TerminalNode OR() { return getToken(JimpleParser.OR, 0); }
public TerminalNode XOR() { return getToken(JimpleParser.XOR, 0); }
public TerminalNode CMP() { return getToken(JimpleParser.CMP, 0); }
public TerminalNode CMPG() { return getToken(JimpleParser.CMPG, 0); }
public TerminalNode CMPL() { return getToken(JimpleParser.CMPL, 0); }
public TerminalNode CMPEQ() { return getToken(JimpleParser.CMPEQ, 0); }
public TerminalNode CMPNE() { return getToken(JimpleParser.CMPNE, 0); }
public TerminalNode CMPGT() { return getToken(JimpleParser.CMPGT, 0); }
public TerminalNode CMPGE() { return getToken(JimpleParser.CMPGE, 0); }
public TerminalNode CMPLT() { return getToken(JimpleParser.CMPLT, 0); }
public TerminalNode CMPLE() { return getToken(JimpleParser.CMPLE, 0); }
public TerminalNode SHL() { return getToken(JimpleParser.SHL, 0); }
public TerminalNode SHR() { return getToken(JimpleParser.SHR, 0); }
public TerminalNode USHR() { return getToken(JimpleParser.USHR, 0); }
public TerminalNode PLUS() { return getToken(JimpleParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(JimpleParser.MINUS, 0); }
public TerminalNode MULT() { return getToken(JimpleParser.MULT, 0); }
public TerminalNode DIV() { return getToken(JimpleParser.DIV, 0); }
public TerminalNode MOD() { return getToken(JimpleParser.MOD, 0); }
public BinopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_binop; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterBinop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitBinop(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitBinop(this);
else return visitor.visitChildren(this);
}
}
public final BinopContext binop() throws RecognitionException {
BinopContext _localctx = new BinopContext(_ctx, getState());
enterRule(_localctx, 92, RULE_binop);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(497);
_la = _input.LA(1);
if ( !(((((_la - 37)) & ~0x3f) == 0 && ((1L << (_la - 37)) & ((1L << (CMP - 37)) | (1L << (CMPG - 37)) | (1L << (CMPL - 37)) | (1L << (AND - 37)) | (1L << (OR - 37)) | (1L << (XOR - 37)) | (1L << (MOD - 37)) | (1L << (CMPEQ - 37)) | (1L << (CMPNE - 37)) | (1L << (CMPGT - 37)) | (1L << (CMPGE - 37)) | (1L << (CMPLT - 37)) | (1L << (CMPLE - 37)) | (1L << (SHL - 37)) | (1L << (SHR - 37)) | (1L << (USHR - 37)) | (1L << (PLUS - 37)) | (1L << (MINUS - 37)) | (1L << (MULT - 37)) | (1L << (DIV - 37)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnopContext extends ParserRuleContext {
public TerminalNode LENGTHOF() { return getToken(JimpleParser.LENGTHOF, 0); }
public TerminalNode NEG() { return getToken(JimpleParser.NEG, 0); }
public UnopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unop; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).enterUnop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JimpleListener ) ((JimpleListener)listener).exitUnop(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JimpleVisitor ) return ((JimpleVisitor)visitor).visitUnop(this);
else return visitor.visitChildren(this);
}
}
public final UnopContext unop() throws RecognitionException {
UnopContext _localctx = new UnopContext(_ctx, getState());
enterRule(_localctx, 94, RULE_unop);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(499);
_la = _input.LA(1);
if ( !(_la==LENGTHOF || _la==NEG) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3e\u01f8\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\3\2\3\2\3\3\5\3f\n\3\3\3\3"+
"\3\5\3j\n\3\3\4\7\4m\n\4\f\4\16\4p\13\4\3\4\7\4s\n\4\f\4\16\4v\13\4\3"+
"\4\3\4\3\4\5\4{\n\4\3\4\5\4~\n\4\3\4\3\4\7\4\u0082\n\4\f\4\16\4\u0085"+
"\13\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\6\3\6\3\7\3\7\3\7\5\7\u0093\n\7\3"+
"\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u009d\n\b\3\t\3\t\3\t\5\t\u00a2\n\t"+
"\3\n\3\n\3\13\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\7\r\u00af\n\r\f\r\16\r"+
"\u00b2\13\r\3\16\3\16\3\16\7\16\u00b7\n\16\f\16\16\16\u00ba\13\16\3\17"+
"\3\17\5\17\u00be\n\17\3\20\7\20\u00c1\n\20\f\20\16\20\u00c4\13\20\3\20"+
"\3\20\3\20\3\20\3\21\7\21\u00cb\n\21\f\21\16\21\u00ce\13\21\3\21\3\21"+
"\5\21\u00d2\n\21\3\21\3\21\3\22\3\22\3\22\5\22\u00d9\n\22\3\23\3\23\3"+
"\23\3\24\3\24\3\24\3\24\3\24\5\24\u00e3\n\24\3\25\3\25\3\25\3\25\3\26"+
"\7\26\u00ea\n\26\f\26\16\26\u00ed\13\26\3\27\7\27\u00f0\n\27\f\27\16\27"+
"\u00f3\13\27\3\30\7\30\u00f6\n\30\f\30\16\30\u00f9\13\30\3\31\3\31\3\31"+
"\3\31\3\32\3\32\3\32\5\32\u0102\n\32\3\32\3\32\3\32\3\33\3\33\3\33\5\33"+
"\u010a\n\33\3\33\3\33\3\33\3\33\5\33\u0110\n\33\3\33\3\33\3\33\3\33\3"+
"\33\3\33\6\33\u0118\n\33\r\33\16\33\u0119\3\33\3\33\3\33\3\33\5\33\u0120"+
"\n\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\5\33\u012a\n\33\3\34\3\34"+
"\3\34\3\34\3\34\3\34\5\34\u0132\n\34\3\34\3\34\3\34\5\34\u0137\n\34\3"+
"\35\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u0140\n\35\3\36\3\36\3\36\3\36"+
"\3\36\3\37\3\37\3\37\5\37\u014a\n\37\3 \3 \3 \3!\3!\3!\3!\3!\3!\3!\3!"+
"\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+
"\5\"\u0169\n\"\3\"\6\"\u016c\n\"\r\"\16\"\u016d\3\"\3\"\3\"\3\"\3\"\3"+
"\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u017c\n\"\3#\3#\5#\u0180\n#\3$\3$\3$\3"+
"$\3$\3$\5$\u0188\n$\3$\3$\3$\3$\3$\3$\5$\u0190\n$\3$\3$\3$\3$\3$\3$\3"+
"$\3$\5$\u019a\n$\3$\3$\3$\3$\5$\u01a0\n$\3$\3$\3$\3$\5$\u01a6\n$\3$\3"+
"$\5$\u01aa\n$\3%\3%\3%\3%\3&\3&\3&\3\'\3\'\3\'\3\'\5\'\u01b7\n\'\3\'\3"+
"\'\3(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)\5)\u01c9\n)\3*\3*\3*\3*\3"+
"*\3*\3*\3+\3+\3+\3+\3,\3,\3,\7,\u01d9\n,\f,\16,\u01dc\13,\3-\3-\5-\u01e0"+
"\n-\3.\3.\3.\3.\5.\u01e6\n.\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u01f2\n/"+
"\3\60\3\60\3\61\3\61\3\61\2\2\62\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36"+
" \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`\2\b\3\2[\\\3\2bc\3\2\5\13"+
"\4\2\25\26!!\4\2\')N^\4\2\60\60\62\62\2\u0219\2b\3\2\2\2\4e\3\2\2\2\6"+
"n\3\2\2\2\b\u0089\3\2\2\2\n\u008d\3\2\2\2\f\u0092\3\2\2\2\16\u009c\3\2"+
"\2\2\20\u00a1\3\2\2\2\22\u00a3\3\2\2\2\24\u00a5\3\2\2\2\26\u00a8\3\2\2"+
"\2\30\u00ab\3\2\2\2\32\u00b3\3\2\2\2\34\u00bd\3\2\2\2\36\u00c2\3\2\2\2"+
" \u00cc\3\2\2\2\"\u00d8\3\2\2\2$\u00da\3\2\2\2&\u00e2\3\2\2\2(\u00e4\3"+
"\2\2\2*\u00eb\3\2\2\2,\u00f1\3\2\2\2.\u00f7\3\2\2\2\60\u00fa\3\2\2\2\62"+
"\u0101\3\2\2\2\64\u0129\3\2\2\2\66\u0136\3\2\2\28\u013f\3\2\2\2:\u0141"+
"\3\2\2\2<\u0149\3\2\2\2>\u014b\3\2\2\2@\u014e\3\2\2\2B\u017b\3\2\2\2D"+
"\u017f\3\2\2\2F\u01a9\3\2\2\2H\u01ab\3\2\2\2J\u01af\3\2\2\2L\u01b2\3\2"+
"\2\2N\u01ba\3\2\2\2P\u01c8\3\2\2\2R\u01ca\3\2\2\2T\u01d1\3\2\2\2V\u01d5"+
"\3\2\2\2X\u01df\3\2\2\2Z\u01e1\3\2\2\2\\\u01f1\3\2\2\2^\u01f3\3\2\2\2"+
"`\u01f5\3\2\2\2bc\7d\2\2c\3\3\2\2\2df\t\2\2\2ed\3\2\2\2ef\3\2\2\2fg\3"+
"\2\2\2gi\t\3\2\2hj\7\3\2\2ih\3\2\2\2ij\3\2\2\2j\5\3\2\2\2km\5\b\5\2lk"+
"\3\2\2\2mp\3\2\2\2nl\3\2\2\2no\3\2\2\2ot\3\2\2\2pn\3\2\2\2qs\5\f\7\2r"+
"q\3\2\2\2sv\3\2\2\2tr\3\2\2\2tu\3\2\2\2uw\3\2\2\2vt\3\2\2\2wx\5\22\n\2"+
"xz\7d\2\2y{\5\24\13\2zy\3\2\2\2z{\3\2\2\2{}\3\2\2\2|~\5\26\f\2}|\3\2\2"+
"\2}~\3\2\2\2~\177\3\2\2\2\177\u0083\7C\2\2\u0080\u0082\5\34\17\2\u0081"+
"\u0080\3\2\2\2\u0082\u0085\3\2\2\2\u0083\u0081\3\2\2\2\u0083\u0084\3\2"+
"\2\2\u0084\u0086\3\2\2\2\u0085\u0083\3\2\2\2\u0086\u0087\7D\2\2\u0087"+
"\u0088\7\2\2\3\u0088\7\3\2\2\2\u0089\u008a\7\4\2\2\u008a\u008b\5\2\2\2"+
"\u008b\u008c\7E\2\2\u008c\t\3\2\2\2\u008d\u008e\t\4\2\2\u008e\13\3\2\2"+
"\2\u008f\u0093\5\n\6\2\u0090\u0093\7\f\2\2\u0091\u0093\7\r\2\2\u0092\u008f"+
"\3\2\2\2\u0092\u0090\3\2\2\2\u0092\u0091\3\2\2\2\u0093\r\3\2\2\2\u0094"+
"\u009d\5\n\6\2\u0095\u009d\7\f\2\2\u0096\u009d\7\16\2\2\u0097\u009d\7"+
"\17\2\2\u0098\u009d\7\20\2\2\u0099\u009d\7\21\2\2\u009a\u009d\7\22\2\2"+
"\u009b\u009d\7\23\2\2\u009c\u0094\3\2\2\2\u009c\u0095\3\2\2\2\u009c\u0096"+
"\3\2\2\2\u009c\u0097\3\2\2\2\u009c\u0098\3\2\2\2\u009c\u0099\3\2\2\2\u009c"+
"\u009a\3\2\2\2\u009c\u009b\3\2\2\2\u009d\17\3\2\2\2\u009e\u00a2\5\n\6"+
"\2\u009f\u00a2\7\23\2\2\u00a0\u00a2\7\24\2\2\u00a1\u009e\3\2\2\2\u00a1"+
"\u009f\3\2\2\2\u00a1\u00a0\3\2\2\2\u00a2\21\3\2\2\2\u00a3\u00a4\t\5\2"+
"\2\u00a4\23\3\2\2\2\u00a5\u00a6\7\"\2\2\u00a6\u00a7\5\2\2\2\u00a7\25\3"+
"\2\2\2\u00a8\u00a9\7#\2\2\u00a9\u00aa\5\32\16\2\u00aa\27\3\2\2\2\u00ab"+
"\u00b0\5\2\2\2\u00ac\u00ad\7F\2\2\u00ad\u00af\7G\2\2\u00ae\u00ac\3\2\2"+
"\2\u00af\u00b2\3\2\2\2\u00b0\u00ae\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1\31"+
"\3\2\2\2\u00b2\u00b0\3\2\2\2\u00b3\u00b8\5\30\r\2\u00b4\u00b5\7B\2\2\u00b5"+
"\u00b7\5\30\r\2\u00b6\u00b4\3\2\2\2\u00b7\u00ba\3\2\2\2\u00b8\u00b6\3"+
"\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\33\3\2\2\2\u00ba\u00b8\3\2\2\2\u00bb"+
"\u00be\5\36\20\2\u00bc\u00be\5 \21\2\u00bd\u00bb\3\2\2\2\u00bd\u00bc\3"+
"\2\2\2\u00be\35\3\2\2\2\u00bf\u00c1\5\20\t\2\u00c0\u00bf\3\2\2\2\u00c1"+
"\u00c4\3\2\2\2\u00c2\u00c0\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c5\3\2"+
"\2\2\u00c4\u00c2\3\2\2\2\u00c5\u00c6\5\30\r\2\u00c6\u00c7\5\2\2\2\u00c7"+
"\u00c8\7E\2\2\u00c8\37\3\2\2\2\u00c9\u00cb\5\16\b\2\u00ca\u00c9\3\2\2"+
"\2\u00cb\u00ce\3\2\2\2\u00cc\u00ca\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00cf"+
"\3\2\2\2\u00ce\u00cc\3\2\2\2\u00cf\u00d1\5L\'\2\u00d0\u00d2\5$\23\2\u00d1"+
"\u00d0\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d3\3\2\2\2\u00d3\u00d4\5&"+
"\24\2\u00d4!\3\2\2\2\u00d5\u00d9\7\27\2\2\u00d6\u00d9\7\30\2\2\u00d7\u00d9"+
"\5\2\2\2\u00d8\u00d5\3\2\2\2\u00d8\u00d6\3\2\2\2\u00d8\u00d7\3\2\2\2\u00d9"+
"#\3\2\2\2\u00da\u00db\7<\2\2\u00db\u00dc\5\32\16\2\u00dc%\3\2\2\2\u00dd"+
"\u00e3\7E\2\2\u00de\u00df\7C\2\2\u00df\u00e0\5(\25\2\u00e0\u00e1\7D\2"+
"\2\u00e1\u00e3\3\2\2\2\u00e2\u00dd\3\2\2\2\u00e2\u00de\3\2\2\2\u00e3\'"+
"\3\2\2\2\u00e4\u00e5\5.\30\2\u00e5\u00e6\5,\27\2\u00e6\u00e7\5*\26\2\u00e7"+
")\3\2\2\2\u00e8\u00ea\5@!\2\u00e9\u00e8\3\2\2\2\u00ea\u00ed\3\2\2\2\u00eb"+
"\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec+\3\2\2\2\u00ed\u00eb\3\2\2\2"+
"\u00ee\u00f0\5\62\32\2\u00ef\u00ee\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1\u00ef"+
"\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2-\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f4"+
"\u00f6\5\60\31\2\u00f5\u00f4\3\2\2\2\u00f6\u00f9\3\2\2\2\u00f7\u00f5\3"+
"\2\2\2\u00f7\u00f8\3\2\2\2\u00f8/\3\2\2\2\u00f9\u00f7\3\2\2\2\u00fa\u00fb"+
"\5\30\r\2\u00fb\u00fc\5V,\2\u00fc\u00fd\7E\2\2\u00fd\61\3\2\2\2\u00fe"+
"\u00ff\5\2\2\2\u00ff\u0100\7J\2\2\u0100\u0102\3\2\2\2\u0101\u00fe\3\2"+
"\2\2\u0101\u0102\3\2\2\2\u0102\u0103\3\2\2\2\u0103\u0104\5\64\33\2\u0104"+
"\u0105\7E\2\2\u0105\63\3\2\2\2\u0106\u012a\5\66\34\2\u0107\u0108\7.\2"+
"\2\u0108\u010a\5D#\2\u0109\u0107\3\2\2\2\u0109\u010a\3\2\2\2\u010a\u010b"+
"\3\2\2\2\u010b\u012a\5> \2\u010c\u012a\5F$\2\u010d\u010f\7\67\2\2\u010e"+
"\u0110\5X-\2\u010f\u010e\3\2\2\2\u010f\u0110\3\2\2\2\u0110\u012a\3\2\2"+
"\2\u0111\u0112\7\61\2\2\u0112\u0113\7H\2\2\u0113\u0114\5X-\2\u0114\u0115"+
"\7I\2\2\u0115\u0117\7C\2\2\u0116\u0118\5:\36\2\u0117\u0116\3\2\2\2\u0118"+
"\u0119\3\2\2\2\u0119\u0117\3\2\2\2\u0119\u011a\3\2\2\2\u011a\u011b\3\2"+
"\2\2\u011b\u011c\7D\2\2\u011c\u012a\3\2\2\2\u011d\u011f\78\2\2\u011e\u0120"+
"\5X-\2\u011f\u011e\3\2\2\2\u011f\u0120\3\2\2\2\u0120\u012a\3\2\2\2\u0121"+
"\u0122\7=\2\2\u0122\u012a\5X-\2\u0123\u0124\7+\2\2\u0124\u012a\5X-\2\u0125"+
"\u0126\7,\2\2\u0126\u012a\5X-\2\u0127\u012a\7\66\2\2\u0128\u012a\7$\2"+
"\2\u0129\u0106\3\2\2\2\u0129\u0109\3\2\2\2\u0129\u010c\3\2\2\2\u0129\u010d"+
"\3\2\2\2\u0129\u0111\3\2\2\2\u0129\u011d\3\2\2\2\u0129\u0121\3\2\2\2\u0129"+
"\u0123\3\2\2\2\u0129\u0125\3\2\2\2\u0129\u0127\3\2\2\2\u0129\u0128\3\2"+
"\2\2\u012a\65\3\2\2\2\u012b\u012c\5\2\2\2\u012c\u012d\7M\2\2\u012d\u012e"+
"\58\35\2\u012e\u0137\3\2\2\2\u012f\u0132\5P)\2\u0130\u0132\5\2\2\2\u0131"+
"\u012f\3\2\2\2\u0131\u0130\3\2\2\2\u0132\u0133\3\2\2\2\u0133\u0134\7L"+
"\2\2\u0134\u0135\5B\"\2\u0135\u0137\3\2\2\2\u0136\u012b\3\2\2\2\u0136"+
"\u0131\3\2\2\2\u0137\67\3\2\2\2\u0138\u0139\7\31\2\2\u0139\u013a\7b\2"+
"\2\u013a\u013b\7J\2\2\u013b\u0140\5\30\r\2\u013c\u013d\7\32\2\2\u013d"+
"\u0140\5\30\r\2\u013e\u0140\7\33\2\2\u013f\u0138\3\2\2\2\u013f\u013c\3"+
"\2\2\2\u013f\u013e\3\2\2\2\u01409\3\2\2\2\u0141\u0142\5<\37\2\u0142\u0143"+
"\7J\2\2\u0143\u0144\5> \2\u0144\u0145\7E\2\2\u0145;\3\2\2\2\u0146\u0147"+
"\7%\2\2\u0147\u014a\5\4\3\2\u0148\u014a\7*\2\2\u0149\u0146\3\2\2\2\u0149"+
"\u0148\3\2\2\2\u014a=\3\2\2\2\u014b\u014c\7-\2\2\u014c\u014d\5\2\2\2\u014d"+
"?\3\2\2\2\u014e\u014f\7&\2\2\u014f\u0150\5\2\2\2\u0150\u0151\7?\2\2\u0151"+
"\u0152\5\2\2\2\u0152\u0153\7@\2\2\u0153\u0154\5\2\2\2\u0154\u0155\7A\2"+
"\2\u0155\u0156\5\2\2\2\u0156\u0157\7E\2\2\u0157A\3\2\2\2\u0158\u017c\5"+
"X-\2\u0159\u017c\5P)\2\u015a\u015b\7\65\2\2\u015b\u017c\5\2\2\2\u015c"+
"\u015d\7\63\2\2\u015d\u015e\7H\2\2\u015e\u015f\5\30\r\2\u015f\u0160\7"+
"I\2\2\u0160\u0161\5T+\2\u0161\u017c\3\2\2\2\u0162\u0163\7\64\2\2\u0163"+
"\u0164\7H\2\2\u0164\u0165\5\30\r\2\u0165\u016b\7I\2\2\u0166\u0168\7F\2"+
"\2\u0167\u0169\5X-\2\u0168\u0167\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a"+
"\3\2\2\2\u016a\u016c\7G\2\2\u016b\u0166\3\2\2\2\u016c\u016d\3\2\2\2\u016d"+
"\u016b\3\2\2\2\u016d\u016e\3\2\2\2\u016e\u017c\3\2\2\2\u016f\u0170\7H"+
"\2\2\u0170\u0171\5\30\r\2\u0171\u0172\7I\2\2\u0172\u0173\5X-\2\u0173\u017c"+
"\3\2\2\2\u0174\u0175\5X-\2\u0175\u0176\7/\2\2\u0176\u0177\5\30\r\2\u0177"+
"\u017c\3\2\2\2\u0178\u017c\5H%\2\u0179\u017c\5F$\2\u017a\u017c\5J&\2\u017b"+
"\u0158\3\2\2\2\u017b\u0159\3\2\2\2\u017b\u015a\3\2\2\2\u017b\u015c\3\2"+
"\2\2\u017b\u0162\3\2\2\2\u017b\u016f\3\2\2\2\u017b\u0174\3\2\2\2\u017b"+
"\u0178\3\2\2\2\u017b\u0179\3\2\2\2\u017b\u017a\3\2\2\2\u017cC\3\2\2\2"+
"\u017d\u0180\5H%\2\u017e\u0180\5J&\2\u017f\u017d\3\2\2\2\u017f\u017e\3"+
"\2\2\2\u0180E\3\2\2\2\u0181\u0182\79\2\2\u0182\u0183\5\2\2\2\u0183\u0184"+
"\7K\2\2\u0184\u0185\5N(\2\u0185\u0187\7H\2\2\u0186\u0188\5V,\2\u0187\u0186"+
"\3\2\2\2\u0187\u0188\3\2\2\2\u0188\u0189\3\2\2\2\u0189\u018a\7I\2\2\u018a"+
"\u01aa\3\2\2\2\u018b\u018c\7:\2\2\u018c\u018d\5N(\2\u018d\u018f\7H\2\2"+
"\u018e\u0190\5V,\2\u018f\u018e\3\2\2\2\u018f\u0190\3\2\2\2\u0190\u0191"+
"\3\2\2\2\u0191\u0192\7I\2\2\u0192\u01aa\3\2\2\2\u0193\u0194\7;\2\2\u0194"+
"\u0195\7 \2\2\u0195\u0196\7V\2\2\u0196\u0197\5\30\r\2\u0197\u0199\7H\2"+
"\2\u0198\u019a\5\32\16\2\u0199\u0198\3\2\2\2\u0199\u019a\3\2\2\2\u019a"+
"\u019b\3\2\2\2\u019b\u019c\7I\2\2\u019c\u019d\7T\2\2\u019d\u019f\7H\2"+
"\2\u019e\u01a0\5V,\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1"+
"\3\2\2\2\u01a1\u01a2\7I\2\2\u01a2\u01a3\5N(\2\u01a3\u01a5\7H\2\2\u01a4"+
"\u01a6\5V,\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01a7\3\2\2"+
"\2\u01a7\u01a8\7I\2\2\u01a8\u01aa\3\2\2\2\u01a9\u0181\3\2\2\2\u01a9\u018b"+
"\3\2\2\2\u01a9\u0193\3\2\2\2\u01aaG\3\2\2\2\u01ab\u01ac\5X-\2\u01ac\u01ad"+
"\5^\60\2\u01ad\u01ae\5X-\2\u01aeI\3\2\2\2\u01af\u01b0\5`\61\2\u01b0\u01b1"+
"\5X-\2\u01b1K\3\2\2\2\u01b2\u01b3\5\30\r\2\u01b3\u01b4\5\"\22\2\u01b4"+
"\u01b6\7H\2\2\u01b5\u01b7\5\32\16\2\u01b6\u01b5\3\2\2\2\u01b6\u01b7\3"+
"\2\2\2\u01b7\u01b8\3\2\2\2\u01b8\u01b9\7I\2\2\u01b9M\3\2\2\2\u01ba\u01bb"+
"\7V\2\2\u01bb\u01bc\5\2\2\2\u01bc\u01bd\7J\2\2\u01bd\u01be\5L\'\2\u01be"+
"\u01bf\7T\2\2\u01bfO\3\2\2\2\u01c0\u01c1\5\2\2\2\u01c1\u01c2\5T+\2\u01c2"+
"\u01c9\3\2\2\2\u01c3\u01c4\5\2\2\2\u01c4\u01c5\7K\2\2\u01c5\u01c6\5R*"+
"\2\u01c6\u01c9\3\2\2\2\u01c7\u01c9\5R*\2\u01c8\u01c0\3\2\2\2\u01c8\u01c3"+
"\3\2\2\2\u01c8\u01c7\3\2\2\2\u01c9Q\3\2\2\2\u01ca\u01cb\7V\2\2\u01cb\u01cc"+
"\5\2\2\2\u01cc\u01cd\7J\2\2\u01cd\u01ce\5\30\r\2\u01ce\u01cf\5\2\2\2\u01cf"+
"\u01d0\7T\2\2\u01d0S\3\2\2\2\u01d1\u01d2\7F\2\2\u01d2\u01d3\5X-\2\u01d3"+
"\u01d4\7G\2\2\u01d4U\3\2\2\2\u01d5\u01da\5X-\2\u01d6\u01d7\7B\2\2\u01d7"+
"\u01d9\5X-\2\u01d8\u01d6\3\2\2\2\u01d9\u01dc\3\2\2\2\u01da\u01d8\3\2\2"+
"\2\u01da\u01db\3\2\2\2\u01dbW\3\2\2\2\u01dc\u01da\3\2\2\2\u01dd\u01e0"+
"\5\2\2\2\u01de\u01e0\5\\/\2\u01df\u01dd\3\2\2\2\u01df\u01de\3\2\2\2\u01e0"+
"Y\3\2\2\2\u01e1\u01e2\7\34\2\2\u01e2\u01e5\7 \2\2\u01e3\u01e6\5N(\2\u01e4"+
"\u01e6\5R*\2\u01e5\u01e3\3\2\2\2\u01e5\u01e4\3\2\2\2\u01e6[\3\2\2\2\u01e7"+
"\u01f2\7`\2\2\u01e8\u01f2\5\4\3\2\u01e9\u01f2\7a\2\2\u01ea\u01f2\7 \2"+
"\2\u01eb\u01ec\7!\2\2\u01ec\u01f2\7 \2\2\u01ed\u01f2\7>\2\2\u01ee\u01f2"+
"\5Z.\2\u01ef\u01f0\7\35\2\2\u01f0\u01f2\5L\'\2\u01f1\u01e7\3\2\2\2\u01f1"+
"\u01e8\3\2\2\2\u01f1\u01e9\3\2\2\2\u01f1\u01ea\3\2\2\2\u01f1\u01eb\3\2"+
"\2\2\u01f1\u01ed\3\2\2\2\u01f1\u01ee\3\2\2\2\u01f1\u01ef\3\2\2\2\u01f2"+
"]\3\2\2\2\u01f3\u01f4\t\6\2\2\u01f4_\3\2\2\2\u01f5\u01f6\t\7\2\2\u01f6"+
"a\3\2\2\2\61eintz}\u0083\u0092\u009c\u00a1\u00b0\u00b8\u00bd\u00c2\u00cc"+
"\u00d1\u00d8\u00e2\u00eb\u00f1\u00f7\u0101\u0109\u010f\u0119\u011f\u0129"+
"\u0131\u0136\u013f\u0149\u0168\u016d\u017b\u017f\u0187\u018f\u0199\u019f"+
"\u01a5\u01a9\u01b6\u01c8\u01da\u01df\u01e5\u01f1";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}