static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); }

protected static final DFA[] _decisionToDFA;

protected static final PredictionContextCache _sharedContextCache =

new PredictionContextCache();

public static final int

AND=1, EOR=2, SUB=3, RSB=4, ADD=5, ADC=6, SBC=7, RSC=8, TST=9, TEQ=10,

CMP=11, CMN=12, ORR=13, MOV=14, BIC=15, MVN=16, MUL=17, MLA=18, SMULL=19,

UMULL=20, SMLAL=21, UMLAL=22, LDR=23, STR=24, Branch=25, BranchAndLink=26,

BLX=27, BX=28, BXJ=29, LSLI=30, LSRI=31, ASRI=32, RORI=33, RRXI=34, R0=35,

R1=36, R2=37, R3=38, R4=39, R5=40, R6=41, R7=42, R8=43, R9=44, R10=45,

R11=46, R12=47, R13=48, R14=49, R15=50, HASH=51, HEX=52, NUMBER=53, COMMENTM=54,

COMMENT=55, NEWLINE=56, COMMA=57, COLON=58, LBRACKET=59, RBRACKET=60,

SPECIALRBRACKET=61, WS=62, LABEL=63, LETTER=64, LABELTEXT=65, BRANCHEND=66,

EQ=67, NE=68, CS=69, CC=70, MI=71, PL=72, VS=73, VC=74, HI=75, LS=76,

GE=77, LT=78, GT=79, LE=80, AL=81, UPDATEFLAG=82, BYTEACCESS=83, PRIVILEGE=84,

DOUBLEWORD=85, HALFWORD=86, SIGNEDHALFWORD=87, SIGNEDBYTE=88, COMEND=89;

public static final int

RULE_compilationUnit = 0, RULE_program = 1, RULE_statement = 2, RULE_instruction = 3,

RULE_cond = 4, RULE_reg = 5, RULE_labelReference = 6, RULE_label = 7,

RULE_immediate = 8, RULE_branch_instruction = 9, RULE_data_processing_instruction = 10,

RULE_shifter_operand = 11, RULE_shift_operation = 12, RULE_shiftopcode = 13,

RULE_multiply_instruction = 14, RULE_load_store_instruction = 15, RULE_addressing_mode = 16;

private static String[] makeRuleNames() {

return new String[] {

"compilationUnit", "program", "statement", "instruction", "cond", "reg",

"labelReference", "label", "immediate", "branch_instruction", "data_processing_instruction",

"shifter_operand", "shift_operation", "shiftopcode", "multiply_instruction",

"load_store_instruction", "addressing_mode"

};

}

public static final String[] ruleNames = makeRuleNames();

private static String[] makeLiteralNames() {

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, 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, "','", "':'",

"'['", "']'", "']!'"

};

}

private static final String[] _LITERAL_NAMES = makeLiteralNames();

private static String[] makeSymbolicNames() {

return new String[] {

null, "AND", "EOR", "SUB", "RSB", "ADD", "ADC", "SBC", "RSC", "TST",

"TEQ", "CMP", "CMN", "ORR", "MOV", "BIC", "MVN", "MUL", "MLA", "SMULL",

"UMULL", "SMLAL", "UMLAL", "LDR", "STR", "Branch", "BranchAndLink", "BLX",

"BX", "BXJ", "LSLI", "LSRI", "ASRI", "RORI", "RRXI", "R0", "R1", "R2",

"R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10", "R11", "R12", "R13",

"R14", "R15", "HASH", "HEX", "NUMBER", "COMMENTM", "COMMENT", "NEWLINE",

"COMMA", "COLON", "LBRACKET", "RBRACKET", "SPECIALRBRACKET", "WS", "LABEL",

"LETTER", "LABELTEXT", "BRANCHEND", "EQ", "NE", "CS", "CC", "MI", "PL",

"VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL", "UPDATEFLAG", "BYTEACCESS",

"PRIVILEGE", "DOUBLEWORD", "HALFWORD", "SIGNEDHALFWORD", "SIGNEDBYTE",

"COMEND"

};

}

private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();

public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

/**

@Deprecated

public static final String[] tokenNames;

static {

tokenNames = new String[_SYMBOLIC_NAMES.length];

for (int i = 0; i < tokenNames.length; i++) {

tokenNames[i] = VOCABULARY.getLiteralName(i);

if (tokenNames[i] == null) {

tokenNames[i] = VOCABULARY.getSymbolicName(i);

}

if (tokenNames[i] == null) {

tokenNames[i] = "<INVALID>";

}

}

}

@Override

@Deprecated

public String[] getTokenNames() {

return tokenNames;

}

@Override

public Vocabulary getVocabulary() {

return VOCABULARY;

}

@Override

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

@Override

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

@Override

public String getSerializedATN() { return _serializedATN; }

@Override

public ATN getATN() { return _ATN; }

public ArmParser(TokenStream input) {

super(input);

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

}

public static class CompilationUnitContext extends ParserRuleContext {

public ProgramContext program() {

return getRuleContext(ProgramContext.class,0);

}

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

public CompilationUnitContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

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

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).enterCompilationUnit(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitCompilationUnit(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitCompilationUnit(this);

else return visitor.visitChildren(this);

}

}

public final CompilationUnitContext compilationUnit() throws RecognitionException {

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

enterRule(_localctx, 0, RULE_compilationUnit);

try {

enterOuterAlt(_localctx, 1);

{

setState(34);

program();

setState(35);

match(EOF);

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class ProgramContext extends ParserRuleContext {

public List<StatementContext> statement() {

return getRuleContexts(StatementContext.class);

}

public StatementContext statement(int i) {

return getRuleContext(StatementContext.class,i);

}

public List<TerminalNode> WS() { return getTokens(ArmParser.WS); }

public TerminalNode WS(int i) {

return getToken(ArmParser.WS, i);

}

public List<TerminalNode> NEWLINE() { return getTokens(ArmParser.NEWLINE); }

public TerminalNode NEWLINE(int i) {

return getToken(ArmParser.NEWLINE, i);

}

public List<TerminalNode> BRANCHEND() { return getTokens(ArmParser.BRANCHEND); }

public TerminalNode BRANCHEND(int i) {

return getToken(ArmParser.BRANCHEND, i);

}

public ProgramContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

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

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).enterProgram(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitProgram(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitProgram(this);

else return visitor.visitChildren(this);

}

}

public final ProgramContext program() throws RecognitionException {

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

enterRule(_localctx, 2, RULE_program);

int _la;

try {

int _alt;

enterOuterAlt(_localctx, 1);

{

setState(40);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==NEWLINE || _la==BRANCHEND) {

{

{

setState(37);

_la = _input.LA(1);

if ( !(_la==NEWLINE || _la==BRANCHEND) ) {

_errHandler.recoverInline(this);

}

else {

if ( _input.LA(1)==Token.EOF ) matchedEOF = true;

_errHandler.reportMatch(this);

consume();

}

}

}

setState(42);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(46);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==WS) {

{

{

setState(43);

match(WS);

}

}

setState(48);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(49);

statement();

setState(53);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==WS) {

{

{

setState(50);

match(WS);

}

}

setState(55);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(76);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==NEWLINE || _la==BRANCHEND) {

{

{

setState(57);

_errHandler.sync(this);

_la = _input.LA(1);

do {

{

{

setState(56);

_la = _input.LA(1);

if ( !(_la==NEWLINE || _la==BRANCHEND) ) {

_errHandler.recoverInline(this);

}

else {

if ( _input.LA(1)==Token.EOF ) matchedEOF = true;

_errHandler.reportMatch(this);

consume();

}

}

}

setState(59);

_errHandler.sync(this);

_la = _input.LA(1);

} while ( _la==NEWLINE || _la==BRANCHEND );

setState(64);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==WS) {

{

{

setState(61);

match(WS);

}

}

setState(66);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(67);

statement();

setState(71);

_errHandler.sync(this);

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

while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {

if ( _alt==1 ) {

{

{

setState(68);

_la = _input.LA(1);

if ( !(((((_la - 56)) & ~0x3f) == 0 && ((1L << (_la - 56)) & ((1L << (NEWLINE - 56)) | (1L << (WS - 56)) | (1L << (BRANCHEND - 56)))) != 0)) ) {

_errHandler.recoverInline(this);

}

else {

if ( _input.LA(1)==Token.EOF ) matchedEOF = true;

_errHandler.reportMatch(this);

consume();

}

}

}

}

setState(73);

_errHandler.sync(this);

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

}

}

}

setState(78);

_errHandler.sync(this);

_la = _input.LA(1);

}

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class StatementContext extends ParserRuleContext {

public TerminalNode COMMENT() { return getToken(ArmParser.COMMENT, 0); }

public TerminalNode COMMENTM() { return getToken(ArmParser.COMMENTM, 0); }

public InstructionContext instruction() {

return getRuleContext(InstructionContext.class,0);

}

public LabelContext label() {

return getRuleContext(LabelContext.class,0);

}

public List<TerminalNode> WS() { return getTokens(ArmParser.WS); }

public TerminalNode WS(int i) {

return getToken(ArmParser.WS, i);

}

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 ArmParserListener ) ((ArmParserListener)listener).enterStatement(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitStatement(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitStatement(this);

else return visitor.visitChildren(this);

}

}

public final StatementContext statement() throws RecognitionException {

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

enterRule(_localctx, 4, RULE_statement);

int _la;

try {

setState(92);

_errHandler.sync(this);

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

case 1:

enterOuterAlt(_localctx, 1);

{

setState(79);

match(COMMENT);

}

break;

case 2:

enterOuterAlt(_localctx, 2);

{

setState(80);

match(COMMENTM);

}

break;

case 3:

enterOuterAlt(_localctx, 3);

{

setState(81);

instruction();

}

break;

case 4:

enterOuterAlt(_localctx, 4);

{

setState(82);

label();

}

break;

case 5:

enterOuterAlt(_localctx, 5);

{

setState(83);

label();

setState(87);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==WS) {

{

{

setState(84);

match(WS);

}

}

setState(89);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(90);

instruction();

}

break;

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class InstructionContext extends ParserRuleContext {

public Data_processing_instructionContext data_processing_instruction() {

return getRuleContext(Data_processing_instructionContext.class,0);

}

public Multiply_instructionContext multiply_instruction() {

return getRuleContext(Multiply_instructionContext.class,0);

}

public Branch_instructionContext branch_instruction() {

return getRuleContext(Branch_instructionContext.class,0);

}

public Load_store_instructionContext load_store_instruction() {

return getRuleContext(Load_store_instructionContext.class,0);

}

public InstructionContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

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

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).enterInstruction(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitInstruction(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitInstruction(this);

else return visitor.visitChildren(this);

}

}

public final InstructionContext instruction() throws RecognitionException {

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

enterRule(_localctx, 6, RULE_instruction);

try {

setState(98);

_errHandler.sync(this);

switch (_input.LA(1)) {

case AND:

case EOR:

case SUB:

case RSB:

case ADD:

case ADC:

case SBC:

case RSC:

case TST:

case TEQ:

case CMP:

case CMN:

case ORR:

case MOV:

case BIC:

case MVN:

enterOuterAlt(_localctx, 1);

{

setState(94);

data_processing_instruction();

}

break;

case MUL:

case MLA:

case SMULL:

case UMULL:

case SMLAL:

case UMLAL:

enterOuterAlt(_localctx, 2);

{

setState(95);

multiply_instruction();

}

break;

case Branch:

case BranchAndLink:

case BX:

enterOuterAlt(_localctx, 3);

{

setState(96);

branch_instruction();

}

break;

case LDR:

case STR:

enterOuterAlt(_localctx, 4);

{

setState(97);

load_store_instruction();

}

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

public TerminalNode EQ() { return getToken(ArmParser.EQ, 0); }

public TerminalNode NE() { return getToken(ArmParser.NE, 0); }

public TerminalNode CS() { return getToken(ArmParser.CS, 0); }

public TerminalNode CC() { return getToken(ArmParser.CC, 0); }

public TerminalNode MI() { return getToken(ArmParser.MI, 0); }

public TerminalNode PL() { return getToken(ArmParser.PL, 0); }

public TerminalNode VS() { return getToken(ArmParser.VS, 0); }

public TerminalNode VC() { return getToken(ArmParser.VC, 0); }

public TerminalNode HI() { return getToken(ArmParser.HI, 0); }

public TerminalNode LS() { return getToken(ArmParser.LS, 0); }

public TerminalNode GE() { return getToken(ArmParser.GE, 0); }

public TerminalNode LT() { return getToken(ArmParser.LT, 0); }

public TerminalNode GT() { return getToken(ArmParser.GT, 0); }

public TerminalNode LE() { return getToken(ArmParser.LE, 0); }

public TerminalNode AL() { return getToken(ArmParser.AL, 0); }

public CondContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

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

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).enterCond(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitCond(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitCond(this);

else return visitor.visitChildren(this);

}

}

public final CondContext cond() throws RecognitionException {

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

enterRule(_localctx, 8, RULE_cond);

int _la;

try {

enterOuterAlt(_localctx, 1);

{

setState(100);

_la = _input.LA(1);

if ( !(((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (EQ - 67)) | (1L << (NE - 67)) | (1L << (CS - 67)) | (1L << (CC - 67)) | (1L << (MI - 67)) | (1L << (PL - 67)) | (1L << (VS - 67)) | (1L << (VC - 67)) | (1L << (HI - 67)) | (1L << (LS - 67)) | (1L << (GE - 67)) | (1L << (LT - 67)) | (1L << (GT - 67)) | (1L << (LE - 67)) | (1L << (AL - 67)))) != 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 RegContext extends ParserRuleContext {

public TerminalNode R0() { return getToken(ArmParser.R0, 0); }

public TerminalNode R1() { return getToken(ArmParser.R1, 0); }

public TerminalNode R2() { return getToken(ArmParser.R2, 0); }

public TerminalNode R3() { return getToken(ArmParser.R3, 0); }

public TerminalNode R4() { return getToken(ArmParser.R4, 0); }

public TerminalNode R5() { return getToken(ArmParser.R5, 0); }

public TerminalNode R6() { return getToken(ArmParser.R6, 0); }

public TerminalNode R7() { return getToken(ArmParser.R7, 0); }

public TerminalNode R8() { return getToken(ArmParser.R8, 0); }

public TerminalNode R9() { return getToken(ArmParser.R9, 0); }

public TerminalNode R10() { return getToken(ArmParser.R10, 0); }

public TerminalNode R11() { return getToken(ArmParser.R11, 0); }

public TerminalNode R12() { return getToken(ArmParser.R12, 0); }

public TerminalNode R13() { return getToken(ArmParser.R13, 0); }

public TerminalNode R14() { return getToken(ArmParser.R14, 0); }

public TerminalNode R15() { return getToken(ArmParser.R15, 0); }

public RegContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

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

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).enterReg(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitReg(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitReg(this);

else return visitor.visitChildren(this);

}

}

public final RegContext reg() throws RecognitionException {

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

enterRule(_localctx, 10, RULE_reg);

int _la;

try {

enterOuterAlt(_localctx, 1);

{

setState(102);

_la = _input.LA(1);

if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << R0) | (1L << R1) | (1L << R2) | (1L << R3) | (1L << R4) | (1L << R5) | (1L << R6) | (1L << R7) | (1L << R8) | (1L << R9) | (1L << R10) | (1L << R11) | (1L << R12) | (1L << R13) | (1L << R14) | (1L << R15))) != 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 LabelReferenceContext extends ParserRuleContext {

public TerminalNode LABELTEXT() { return getToken(ArmParser.LABELTEXT, 0); }

public LabelReferenceContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

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

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).enterLabelReference(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitLabelReference(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitLabelReference(this);

else return visitor.visitChildren(this);

}

}

public final LabelReferenceContext labelReference() throws RecognitionException {

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

enterRule(_localctx, 12, RULE_labelReference);

try {

enterOuterAlt(_localctx, 1);

{

setState(104);

match(LABELTEXT);

}

}

catch (RecognitionException re) {

_localctx.exception = re;

_errHandler.reportError(this, re);

_errHandler.recover(this, re);

}

finally {

exitRule();

}

return _localctx;

}

public static class LabelContext extends ParserRuleContext {

public TerminalNode LABEL() { return getToken(ArmParser.LABEL, 0); }

public LabelContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

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

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).enterLabel(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitLabel(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitLabel(this);

else return visitor.visitChildren(this);

}

}

public final LabelContext label() throws RecognitionException {

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

enterRule(_localctx, 14, RULE_label);

try {

enterOuterAlt(_localctx, 1);

{

setState(106);

match(LABEL);

}

}

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 TerminalNode HASH() { return getToken(ArmParser.HASH, 0); }

public TerminalNode HEX() { return getToken(ArmParser.HEX, 0); }

public TerminalNode NUMBER() { return getToken(ArmParser.NUMBER, 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 ArmParserListener ) ((ArmParserListener)listener).enterImmediate(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitImmediate(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitImmediate(this);

else return visitor.visitChildren(this);

}

}

public final ImmediateContext immediate() throws RecognitionException {

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

enterRule(_localctx, 16, RULE_immediate);

int _la;

try {

enterOuterAlt(_localctx, 1);

{

setState(108);

match(HASH);

setState(109);

_la = _input.LA(1);

if ( !(_la==HEX || _la==NUMBER) ) {

_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 Branch_instructionContext extends ParserRuleContext {

public Branch_instructionContext(ParserRuleContext parent, int invokingState) {

super(parent, invokingState);

}

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

public Branch_instructionContext() { }

public void copyFrom(Branch_instructionContext ctx) {

super.copyFrom(ctx);

}

}

public static class BranchToRegisterContext extends Branch_instructionContext {

public Token opcode;

public TerminalNode COMEND() { return getToken(ArmParser.COMEND, 0); }

public RegContext reg() {

return getRuleContext(RegContext.class,0);

}

public TerminalNode BX() { return getToken(ArmParser.BX, 0); }

public CondContext cond() {

return getRuleContext(CondContext.class,0);

}

public List<TerminalNode> WS() { return getTokens(ArmParser.WS); }

public TerminalNode WS(int i) {

return getToken(ArmParser.WS, i);

}

public BranchToRegisterContext(Branch_instructionContext ctx) { copyFrom(ctx); }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).enterBranchToRegister(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitBranchToRegister(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitBranchToRegister(this);

else return visitor.visitChildren(this);

}

}

public static class BranchToLabelContext extends Branch_instructionContext {

public Token opcode;

public TerminalNode COMEND() { return getToken(ArmParser.COMEND, 0); }

public LabelReferenceContext labelReference() {

return getRuleContext(LabelReferenceContext.class,0);

}

public TerminalNode Branch() { return getToken(ArmParser.Branch, 0); }

public TerminalNode BranchAndLink() { return getToken(ArmParser.BranchAndLink, 0); }

public CondContext cond() {

return getRuleContext(CondContext.class,0);

}

public List<TerminalNode> WS() { return getTokens(ArmParser.WS); }

public TerminalNode WS(int i) {

return getToken(ArmParser.WS, i);

}

public BranchToLabelContext(Branch_instructionContext ctx) { copyFrom(ctx); }

@Override

public void enterRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).enterBranchToLabel(this);

}

@Override

public void exitRule(ParseTreeListener listener) {

if ( listener instanceof ArmParserListener ) ((ArmParserListener)listener).exitBranchToLabel(this);

}

@Override

public <T> T accept(ParseTreeVisitor<? extends T> visitor) {

if ( visitor instanceof ArmParserVisitor ) return ((ArmParserVisitor<? extends T>)visitor).visitBranchToLabel(this);

else return visitor.visitChildren(this);

}

}

public final Branch_instructionContext branch_instruction() throws RecognitionException {

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

enterRule(_localctx, 18, RULE_branch_instruction);

int _la;

try {

setState(135);

_errHandler.sync(this);

switch (_input.LA(1)) {

case Branch:

case BranchAndLink:

_localctx = new BranchToLabelContext(_localctx);

enterOuterAlt(_localctx, 1);

{

setState(111);

((BranchToLabelContext)_localctx).opcode = _input.LT(1);

_la = _input.LA(1);

if ( !(_la==Branch || _la==BranchAndLink) ) {

((BranchToLabelContext)_localctx).opcode = (Token)_errHandler.recoverInline(this);

}

else {

if ( _input.LA(1)==Token.EOF ) matchedEOF = true;

_errHandler.reportMatch(this);

consume();

}

setState(113);

_errHandler.sync(this);

_la = _input.LA(1);

if (((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (EQ - 67)) | (1L << (NE - 67)) | (1L << (CS - 67)) | (1L << (CC - 67)) | (1L << (MI - 67)) | (1L << (PL - 67)) | (1L << (VS - 67)) | (1L << (VC - 67)) | (1L << (HI - 67)) | (1L << (LS - 67)) | (1L << (GE - 67)) | (1L << (LT - 67)) | (1L << (GT - 67)) | (1L << (LE - 67)) | (1L << (AL - 67)))) != 0)) {

{

setState(112);

cond();

}

}

setState(115);

match(COMEND);

setState(119);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==WS) {

{

{

setState(116);

match(WS);

}

}

setState(121);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(122);

labelReference();

}

break;

case BX:

_localctx = new BranchToRegisterContext(_localctx);

enterOuterAlt(_localctx, 2);

{

setState(123);

((BranchToRegisterContext)_localctx).opcode = match(BX);

setState(125);

_errHandler.sync(this);

_la = _input.LA(1);

if (((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (EQ - 67)) | (1L << (NE - 67)) | (1L << (CS - 67)) | (1L << (CC - 67)) | (1L << (MI - 67)) | (1L << (PL - 67)) | (1L << (VS - 67)) | (1L << (VC - 67)) | (1L << (HI - 67)) | (1L << (LS - 67)) | (1L << (GE - 67)) | (1L << (LT - 67)) | (1L << (GT - 67)) | (1L << (LE - 67)) | (1L << (AL - 67)))) != 0)) {

{

setState(124);

cond();

}

}

setState(127);

match(COMEND);

setState(131);

_errHandler.sync(this);

_la = _input.LA(1);

while (_la==WS) {

{

{

setState(128);

match(WS);

}

}

setState(133);

_errHandler.sync(this);

_la = _input.LA(1);

}

setState(134);

reg();

}

break;

default:

throw new NoViableAltException(this);

}

}

catch (RecognitionException re) {