| package org.eclipse.etrice.core.fsm.ui.contentassist.antlr.internal; |
| |
| import java.io.InputStream; |
| import org.eclipse.xtext.*; |
| import org.eclipse.xtext.parser.*; |
| import org.eclipse.xtext.parser.impl.*; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.xtext.parser.antlr.XtextTokenStream; |
| import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; |
| import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; |
| import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA; |
| import org.eclipse.etrice.core.fsm.services.FSMGrammarAccess; |
| |
| |
| |
| import org.antlr.runtime.*; |
| import java.util.Stack; |
| import java.util.List; |
| import java.util.ArrayList; |
| |
| @SuppressWarnings("all") |
| public class InternalFSMParser extends AbstractInternalContentAssistParser { |
| public static final String[] tokenNames = new String[] { |
| "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_ID", "RULE_HEX", "RULE_INT", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'mandatory'", "'false'", "'+'", "'-'", "'e'", "'E'", "'eventdriven'", "'datadriven'", "'async'", "'sync'", "'ptBoolean'", "'ptInteger'", "'ptReal'", "'ptCharacter'", "'ModelComponent'", "'extends'", "'{'", "'}'", "'StateMachine'", "'State'", "'entry'", "'exit'", "'do'", "'subgraph'", "'RefinedState'", "'TransitionPoint'", "'EntryPoint'", "'ExitPoint'", "'ChoicePoint'", "'Transition'", "':'", "'initial'", "'->'", "'action'", "'triggers'", "'or'", "'guard'", "'cond'", "'RefinedTransition'", "'my'", "'of'", "'cp'", "'<'", "'>'", "'|'", "'in'", "'('", "')'", "','", "'out'", "'='", "'attribute'", "'.*'", "'['", "']'", "'.'", "'abstract'", "'handler'", "'optional'", "'true'" |
| }; |
| public static final int RULE_HEX=5; |
| public static final int T__50=50; |
| public static final int T__19=19; |
| public static final int T__15=15; |
| public static final int T__59=59; |
| public static final int T__16=16; |
| public static final int T__17=17; |
| public static final int T__18=18; |
| public static final int T__55=55; |
| public static final int T__12=12; |
| public static final int T__56=56; |
| public static final int T__13=13; |
| public static final int T__57=57; |
| public static final int T__14=14; |
| public static final int T__58=58; |
| public static final int T__51=51; |
| public static final int T__52=52; |
| public static final int T__53=53; |
| public static final int T__54=54; |
| public static final int T__60=60; |
| public static final int T__61=61; |
| public static final int RULE_ID=4; |
| public static final int T__26=26; |
| public static final int T__27=27; |
| public static final int T__28=28; |
| public static final int RULE_INT=6; |
| public static final int T__29=29; |
| public static final int T__22=22; |
| public static final int T__66=66; |
| public static final int RULE_ML_COMMENT=8; |
| public static final int T__23=23; |
| public static final int T__67=67; |
| public static final int T__24=24; |
| public static final int T__68=68; |
| public static final int T__25=25; |
| public static final int T__69=69; |
| public static final int T__62=62; |
| public static final int T__63=63; |
| public static final int T__20=20; |
| public static final int T__64=64; |
| public static final int T__21=21; |
| public static final int T__65=65; |
| public static final int T__70=70; |
| public static final int T__71=71; |
| public static final int RULE_STRING=7; |
| public static final int RULE_SL_COMMENT=9; |
| public static final int T__37=37; |
| public static final int T__38=38; |
| public static final int T__39=39; |
| public static final int T__33=33; |
| public static final int T__34=34; |
| public static final int T__35=35; |
| public static final int T__36=36; |
| public static final int EOF=-1; |
| public static final int T__30=30; |
| public static final int T__31=31; |
| public static final int T__32=32; |
| public static final int RULE_WS=10; |
| public static final int RULE_ANY_OTHER=11; |
| public static final int T__48=48; |
| public static final int T__49=49; |
| public static final int T__44=44; |
| public static final int T__45=45; |
| public static final int T__46=46; |
| public static final int T__47=47; |
| public static final int T__40=40; |
| public static final int T__41=41; |
| public static final int T__42=42; |
| public static final int T__43=43; |
| |
| // delegates |
| // delegators |
| |
| |
| public InternalFSMParser(TokenStream input) { |
| this(input, new RecognizerSharedState()); |
| } |
| public InternalFSMParser(TokenStream input, RecognizerSharedState state) { |
| super(input, state); |
| |
| } |
| |
| |
| public String[] getTokenNames() { return InternalFSMParser.tokenNames; } |
| public String getGrammarFileName() { return "InternalFSM.g"; } |
| |
| |
| |
| private FSMGrammarAccess grammarAccess; |
| |
| public void setGrammarAccess(FSMGrammarAccess grammarAccess) { |
| this.grammarAccess = grammarAccess; |
| } |
| |
| @Override |
| protected Grammar getGrammar() { |
| return grammarAccess.getGrammar(); |
| } |
| |
| @Override |
| protected String getValueForTokenName(String tokenName) { |
| return tokenName; |
| } |
| |
| |
| |
| |
| // $ANTLR start "entryRuleFSMModel" |
| // InternalFSM.g:60:1: entryRuleFSMModel : ruleFSMModel EOF ; |
| public final void entryRuleFSMModel() throws RecognitionException { |
| try { |
| // InternalFSM.g:61:1: ( ruleFSMModel EOF ) |
| // InternalFSM.g:62:1: ruleFSMModel EOF |
| { |
| before(grammarAccess.getFSMModelRule()); |
| pushFollow(FOLLOW_1); |
| ruleFSMModel(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getFSMModelRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleFSMModel" |
| |
| |
| // $ANTLR start "ruleFSMModel" |
| // InternalFSM.g:69:1: ruleFSMModel : ( ( rule__FSMModel__ComponentsAssignment )* ) ; |
| public final void ruleFSMModel() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:73:2: ( ( ( rule__FSMModel__ComponentsAssignment )* ) ) |
| // InternalFSM.g:74:1: ( ( rule__FSMModel__ComponentsAssignment )* ) |
| { |
| // InternalFSM.g:74:1: ( ( rule__FSMModel__ComponentsAssignment )* ) |
| // InternalFSM.g:75:1: ( rule__FSMModel__ComponentsAssignment )* |
| { |
| before(grammarAccess.getFSMModelAccess().getComponentsAssignment()); |
| // InternalFSM.g:76:1: ( rule__FSMModel__ComponentsAssignment )* |
| loop1: |
| do { |
| int alt1=2; |
| int LA1_0 = input.LA(1); |
| |
| if ( ((LA1_0>=18 && LA1_0<=21)||LA1_0==26||LA1_0==68) ) { |
| alt1=1; |
| } |
| |
| |
| switch (alt1) { |
| case 1 : |
| // InternalFSM.g:76:2: rule__FSMModel__ComponentsAssignment |
| { |
| pushFollow(FOLLOW_3); |
| rule__FSMModel__ComponentsAssignment(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop1; |
| } |
| } while (true); |
| |
| after(grammarAccess.getFSMModelAccess().getComponentsAssignment()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleFSMModel" |
| |
| |
| // $ANTLR start "entryRuleModelComponent" |
| // InternalFSM.g:88:1: entryRuleModelComponent : ruleModelComponent EOF ; |
| public final void entryRuleModelComponent() throws RecognitionException { |
| try { |
| // InternalFSM.g:89:1: ( ruleModelComponent EOF ) |
| // InternalFSM.g:90:1: ruleModelComponent EOF |
| { |
| before(grammarAccess.getModelComponentRule()); |
| pushFollow(FOLLOW_1); |
| ruleModelComponent(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getModelComponentRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleModelComponent" |
| |
| |
| // $ANTLR start "ruleModelComponent" |
| // InternalFSM.g:97:1: ruleModelComponent : ( ( rule__ModelComponent__Group__0 ) ) ; |
| public final void ruleModelComponent() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:101:2: ( ( ( rule__ModelComponent__Group__0 ) ) ) |
| // InternalFSM.g:102:1: ( ( rule__ModelComponent__Group__0 ) ) |
| { |
| // InternalFSM.g:102:1: ( ( rule__ModelComponent__Group__0 ) ) |
| // InternalFSM.g:103:1: ( rule__ModelComponent__Group__0 ) |
| { |
| before(grammarAccess.getModelComponentAccess().getGroup()); |
| // InternalFSM.g:104:1: ( rule__ModelComponent__Group__0 ) |
| // InternalFSM.g:104:2: rule__ModelComponent__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getModelComponentAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleModelComponent" |
| |
| |
| // $ANTLR start "entryRuleStateGraphNode" |
| // InternalFSM.g:116:1: entryRuleStateGraphNode : ruleStateGraphNode EOF ; |
| public final void entryRuleStateGraphNode() throws RecognitionException { |
| try { |
| // InternalFSM.g:117:1: ( ruleStateGraphNode EOF ) |
| // InternalFSM.g:118:1: ruleStateGraphNode EOF |
| { |
| before(grammarAccess.getStateGraphNodeRule()); |
| pushFollow(FOLLOW_1); |
| ruleStateGraphNode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateGraphNodeRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleStateGraphNode" |
| |
| |
| // $ANTLR start "ruleStateGraphNode" |
| // InternalFSM.g:125:1: ruleStateGraphNode : ( ( rule__StateGraphNode__Alternatives ) ) ; |
| public final void ruleStateGraphNode() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:129:2: ( ( ( rule__StateGraphNode__Alternatives ) ) ) |
| // InternalFSM.g:130:1: ( ( rule__StateGraphNode__Alternatives ) ) |
| { |
| // InternalFSM.g:130:1: ( ( rule__StateGraphNode__Alternatives ) ) |
| // InternalFSM.g:131:1: ( rule__StateGraphNode__Alternatives ) |
| { |
| before(grammarAccess.getStateGraphNodeAccess().getAlternatives()); |
| // InternalFSM.g:132:1: ( rule__StateGraphNode__Alternatives ) |
| // InternalFSM.g:132:2: rule__StateGraphNode__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateGraphNode__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateGraphNodeAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleStateGraphNode" |
| |
| |
| // $ANTLR start "entryRuleStateGraph" |
| // InternalFSM.g:146:1: entryRuleStateGraph : ruleStateGraph EOF ; |
| public final void entryRuleStateGraph() throws RecognitionException { |
| try { |
| // InternalFSM.g:147:1: ( ruleStateGraph EOF ) |
| // InternalFSM.g:148:1: ruleStateGraph EOF |
| { |
| before(grammarAccess.getStateGraphRule()); |
| pushFollow(FOLLOW_1); |
| ruleStateGraph(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateGraphRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleStateGraph" |
| |
| |
| // $ANTLR start "ruleStateGraph" |
| // InternalFSM.g:155:1: ruleStateGraph : ( ( rule__StateGraph__Group__0 ) ) ; |
| public final void ruleStateGraph() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:159:2: ( ( ( rule__StateGraph__Group__0 ) ) ) |
| // InternalFSM.g:160:1: ( ( rule__StateGraph__Group__0 ) ) |
| { |
| // InternalFSM.g:160:1: ( ( rule__StateGraph__Group__0 ) ) |
| // InternalFSM.g:161:1: ( rule__StateGraph__Group__0 ) |
| { |
| before(grammarAccess.getStateGraphAccess().getGroup()); |
| // InternalFSM.g:162:1: ( rule__StateGraph__Group__0 ) |
| // InternalFSM.g:162:2: rule__StateGraph__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateGraph__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateGraphAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleStateGraph" |
| |
| |
| // $ANTLR start "entryRuleStateMachine" |
| // InternalFSM.g:174:1: entryRuleStateMachine : ruleStateMachine EOF ; |
| public final void entryRuleStateMachine() throws RecognitionException { |
| try { |
| // InternalFSM.g:175:1: ( ruleStateMachine EOF ) |
| // InternalFSM.g:176:1: ruleStateMachine EOF |
| { |
| before(grammarAccess.getStateMachineRule()); |
| pushFollow(FOLLOW_1); |
| ruleStateMachine(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateMachineRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleStateMachine" |
| |
| |
| // $ANTLR start "ruleStateMachine" |
| // InternalFSM.g:183:1: ruleStateMachine : ( ( rule__StateMachine__Group__0 ) ) ; |
| public final void ruleStateMachine() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:187:2: ( ( ( rule__StateMachine__Group__0 ) ) ) |
| // InternalFSM.g:188:1: ( ( rule__StateMachine__Group__0 ) ) |
| { |
| // InternalFSM.g:188:1: ( ( rule__StateMachine__Group__0 ) ) |
| // InternalFSM.g:189:1: ( rule__StateMachine__Group__0 ) |
| { |
| before(grammarAccess.getStateMachineAccess().getGroup()); |
| // InternalFSM.g:190:1: ( rule__StateMachine__Group__0 ) |
| // InternalFSM.g:190:2: rule__StateMachine__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateMachineAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleStateMachine" |
| |
| |
| // $ANTLR start "entryRuleState" |
| // InternalFSM.g:202:1: entryRuleState : ruleState EOF ; |
| public final void entryRuleState() throws RecognitionException { |
| try { |
| // InternalFSM.g:203:1: ( ruleState EOF ) |
| // InternalFSM.g:204:1: ruleState EOF |
| { |
| before(grammarAccess.getStateRule()); |
| pushFollow(FOLLOW_1); |
| ruleState(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleState" |
| |
| |
| // $ANTLR start "ruleState" |
| // InternalFSM.g:211:1: ruleState : ( ( rule__State__Alternatives ) ) ; |
| public final void ruleState() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:215:2: ( ( ( rule__State__Alternatives ) ) ) |
| // InternalFSM.g:216:1: ( ( rule__State__Alternatives ) ) |
| { |
| // InternalFSM.g:216:1: ( ( rule__State__Alternatives ) ) |
| // InternalFSM.g:217:1: ( rule__State__Alternatives ) |
| { |
| before(grammarAccess.getStateAccess().getAlternatives()); |
| // InternalFSM.g:218:1: ( rule__State__Alternatives ) |
| // InternalFSM.g:218:2: rule__State__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__State__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleState" |
| |
| |
| // $ANTLR start "entryRuleSimpleState" |
| // InternalFSM.g:230:1: entryRuleSimpleState : ruleSimpleState EOF ; |
| public final void entryRuleSimpleState() throws RecognitionException { |
| try { |
| // InternalFSM.g:231:1: ( ruleSimpleState EOF ) |
| // InternalFSM.g:232:1: ruleSimpleState EOF |
| { |
| before(grammarAccess.getSimpleStateRule()); |
| pushFollow(FOLLOW_1); |
| ruleSimpleState(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSimpleStateRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleSimpleState" |
| |
| |
| // $ANTLR start "ruleSimpleState" |
| // InternalFSM.g:239:1: ruleSimpleState : ( ( rule__SimpleState__Group__0 ) ) ; |
| public final void ruleSimpleState() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:243:2: ( ( ( rule__SimpleState__Group__0 ) ) ) |
| // InternalFSM.g:244:1: ( ( rule__SimpleState__Group__0 ) ) |
| { |
| // InternalFSM.g:244:1: ( ( rule__SimpleState__Group__0 ) ) |
| // InternalFSM.g:245:1: ( rule__SimpleState__Group__0 ) |
| { |
| before(grammarAccess.getSimpleStateAccess().getGroup()); |
| // InternalFSM.g:246:1: ( rule__SimpleState__Group__0 ) |
| // InternalFSM.g:246:2: rule__SimpleState__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleSimpleState" |
| |
| |
| // $ANTLR start "entryRuleRefinedState" |
| // InternalFSM.g:258:1: entryRuleRefinedState : ruleRefinedState EOF ; |
| public final void entryRuleRefinedState() throws RecognitionException { |
| try { |
| // InternalFSM.g:259:1: ( ruleRefinedState EOF ) |
| // InternalFSM.g:260:1: ruleRefinedState EOF |
| { |
| before(grammarAccess.getRefinedStateRule()); |
| pushFollow(FOLLOW_1); |
| ruleRefinedState(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedStateRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleRefinedState" |
| |
| |
| // $ANTLR start "ruleRefinedState" |
| // InternalFSM.g:267:1: ruleRefinedState : ( ( rule__RefinedState__Group__0 ) ) ; |
| public final void ruleRefinedState() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:271:2: ( ( ( rule__RefinedState__Group__0 ) ) ) |
| // InternalFSM.g:272:1: ( ( rule__RefinedState__Group__0 ) ) |
| { |
| // InternalFSM.g:272:1: ( ( rule__RefinedState__Group__0 ) ) |
| // InternalFSM.g:273:1: ( rule__RefinedState__Group__0 ) |
| { |
| before(grammarAccess.getRefinedStateAccess().getGroup()); |
| // InternalFSM.g:274:1: ( rule__RefinedState__Group__0 ) |
| // InternalFSM.g:274:2: rule__RefinedState__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleRefinedState" |
| |
| |
| // $ANTLR start "entryRuleDetailCode" |
| // InternalFSM.g:286:1: entryRuleDetailCode : ruleDetailCode EOF ; |
| public final void entryRuleDetailCode() throws RecognitionException { |
| try { |
| // InternalFSM.g:287:1: ( ruleDetailCode EOF ) |
| // InternalFSM.g:288:1: ruleDetailCode EOF |
| { |
| before(grammarAccess.getDetailCodeRule()); |
| pushFollow(FOLLOW_1); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getDetailCodeRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDetailCode" |
| |
| |
| // $ANTLR start "ruleDetailCode" |
| // InternalFSM.g:295:1: ruleDetailCode : ( ( rule__DetailCode__Group__0 ) ) ; |
| public final void ruleDetailCode() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:299:2: ( ( ( rule__DetailCode__Group__0 ) ) ) |
| // InternalFSM.g:300:1: ( ( rule__DetailCode__Group__0 ) ) |
| { |
| // InternalFSM.g:300:1: ( ( rule__DetailCode__Group__0 ) ) |
| // InternalFSM.g:301:1: ( rule__DetailCode__Group__0 ) |
| { |
| before(grammarAccess.getDetailCodeAccess().getGroup()); |
| // InternalFSM.g:302:1: ( rule__DetailCode__Group__0 ) |
| // InternalFSM.g:302:2: rule__DetailCode__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__DetailCode__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getDetailCodeAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDetailCode" |
| |
| |
| // $ANTLR start "entryRuleTrPoint" |
| // InternalFSM.g:314:1: entryRuleTrPoint : ruleTrPoint EOF ; |
| public final void entryRuleTrPoint() throws RecognitionException { |
| try { |
| // InternalFSM.g:315:1: ( ruleTrPoint EOF ) |
| // InternalFSM.g:316:1: ruleTrPoint EOF |
| { |
| before(grammarAccess.getTrPointRule()); |
| pushFollow(FOLLOW_1); |
| ruleTrPoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTrPointRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTrPoint" |
| |
| |
| // $ANTLR start "ruleTrPoint" |
| // InternalFSM.g:323:1: ruleTrPoint : ( ( rule__TrPoint__Alternatives ) ) ; |
| public final void ruleTrPoint() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:327:2: ( ( ( rule__TrPoint__Alternatives ) ) ) |
| // InternalFSM.g:328:1: ( ( rule__TrPoint__Alternatives ) ) |
| { |
| // InternalFSM.g:328:1: ( ( rule__TrPoint__Alternatives ) ) |
| // InternalFSM.g:329:1: ( rule__TrPoint__Alternatives ) |
| { |
| before(grammarAccess.getTrPointAccess().getAlternatives()); |
| // InternalFSM.g:330:1: ( rule__TrPoint__Alternatives ) |
| // InternalFSM.g:330:2: rule__TrPoint__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__TrPoint__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTrPointAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTrPoint" |
| |
| |
| // $ANTLR start "entryRuleTransitionPoint" |
| // InternalFSM.g:342:1: entryRuleTransitionPoint : ruleTransitionPoint EOF ; |
| public final void entryRuleTransitionPoint() throws RecognitionException { |
| try { |
| // InternalFSM.g:343:1: ( ruleTransitionPoint EOF ) |
| // InternalFSM.g:344:1: ruleTransitionPoint EOF |
| { |
| before(grammarAccess.getTransitionPointRule()); |
| pushFollow(FOLLOW_1); |
| ruleTransitionPoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionPointRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTransitionPoint" |
| |
| |
| // $ANTLR start "ruleTransitionPoint" |
| // InternalFSM.g:351:1: ruleTransitionPoint : ( ( rule__TransitionPoint__Group__0 ) ) ; |
| public final void ruleTransitionPoint() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:355:2: ( ( ( rule__TransitionPoint__Group__0 ) ) ) |
| // InternalFSM.g:356:1: ( ( rule__TransitionPoint__Group__0 ) ) |
| { |
| // InternalFSM.g:356:1: ( ( rule__TransitionPoint__Group__0 ) ) |
| // InternalFSM.g:357:1: ( rule__TransitionPoint__Group__0 ) |
| { |
| before(grammarAccess.getTransitionPointAccess().getGroup()); |
| // InternalFSM.g:358:1: ( rule__TransitionPoint__Group__0 ) |
| // InternalFSM.g:358:2: rule__TransitionPoint__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TransitionPoint__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTransitionPointAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTransitionPoint" |
| |
| |
| // $ANTLR start "entryRuleEntryPoint" |
| // InternalFSM.g:370:1: entryRuleEntryPoint : ruleEntryPoint EOF ; |
| public final void entryRuleEntryPoint() throws RecognitionException { |
| try { |
| // InternalFSM.g:371:1: ( ruleEntryPoint EOF ) |
| // InternalFSM.g:372:1: ruleEntryPoint EOF |
| { |
| before(grammarAccess.getEntryPointRule()); |
| pushFollow(FOLLOW_1); |
| ruleEntryPoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getEntryPointRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEntryPoint" |
| |
| |
| // $ANTLR start "ruleEntryPoint" |
| // InternalFSM.g:379:1: ruleEntryPoint : ( ( rule__EntryPoint__Group__0 ) ) ; |
| public final void ruleEntryPoint() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:383:2: ( ( ( rule__EntryPoint__Group__0 ) ) ) |
| // InternalFSM.g:384:1: ( ( rule__EntryPoint__Group__0 ) ) |
| { |
| // InternalFSM.g:384:1: ( ( rule__EntryPoint__Group__0 ) ) |
| // InternalFSM.g:385:1: ( rule__EntryPoint__Group__0 ) |
| { |
| before(grammarAccess.getEntryPointAccess().getGroup()); |
| // InternalFSM.g:386:1: ( rule__EntryPoint__Group__0 ) |
| // InternalFSM.g:386:2: rule__EntryPoint__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EntryPoint__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getEntryPointAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEntryPoint" |
| |
| |
| // $ANTLR start "entryRuleExitPoint" |
| // InternalFSM.g:398:1: entryRuleExitPoint : ruleExitPoint EOF ; |
| public final void entryRuleExitPoint() throws RecognitionException { |
| try { |
| // InternalFSM.g:399:1: ( ruleExitPoint EOF ) |
| // InternalFSM.g:400:1: ruleExitPoint EOF |
| { |
| before(grammarAccess.getExitPointRule()); |
| pushFollow(FOLLOW_1); |
| ruleExitPoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getExitPointRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleExitPoint" |
| |
| |
| // $ANTLR start "ruleExitPoint" |
| // InternalFSM.g:407:1: ruleExitPoint : ( ( rule__ExitPoint__Group__0 ) ) ; |
| public final void ruleExitPoint() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:411:2: ( ( ( rule__ExitPoint__Group__0 ) ) ) |
| // InternalFSM.g:412:1: ( ( rule__ExitPoint__Group__0 ) ) |
| { |
| // InternalFSM.g:412:1: ( ( rule__ExitPoint__Group__0 ) ) |
| // InternalFSM.g:413:1: ( rule__ExitPoint__Group__0 ) |
| { |
| before(grammarAccess.getExitPointAccess().getGroup()); |
| // InternalFSM.g:414:1: ( rule__ExitPoint__Group__0 ) |
| // InternalFSM.g:414:2: rule__ExitPoint__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ExitPoint__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getExitPointAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleExitPoint" |
| |
| |
| // $ANTLR start "entryRuleChoicePoint" |
| // InternalFSM.g:426:1: entryRuleChoicePoint : ruleChoicePoint EOF ; |
| public final void entryRuleChoicePoint() throws RecognitionException { |
| try { |
| // InternalFSM.g:427:1: ( ruleChoicePoint EOF ) |
| // InternalFSM.g:428:1: ruleChoicePoint EOF |
| { |
| before(grammarAccess.getChoicePointRule()); |
| pushFollow(FOLLOW_1); |
| ruleChoicePoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getChoicePointRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleChoicePoint" |
| |
| |
| // $ANTLR start "ruleChoicePoint" |
| // InternalFSM.g:435:1: ruleChoicePoint : ( ( rule__ChoicePoint__Group__0 ) ) ; |
| public final void ruleChoicePoint() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:439:2: ( ( ( rule__ChoicePoint__Group__0 ) ) ) |
| // InternalFSM.g:440:1: ( ( rule__ChoicePoint__Group__0 ) ) |
| { |
| // InternalFSM.g:440:1: ( ( rule__ChoicePoint__Group__0 ) ) |
| // InternalFSM.g:441:1: ( rule__ChoicePoint__Group__0 ) |
| { |
| before(grammarAccess.getChoicePointAccess().getGroup()); |
| // InternalFSM.g:442:1: ( rule__ChoicePoint__Group__0 ) |
| // InternalFSM.g:442:2: rule__ChoicePoint__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ChoicePoint__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getChoicePointAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleChoicePoint" |
| |
| |
| // $ANTLR start "entryRuleTransition" |
| // InternalFSM.g:456:1: entryRuleTransition : ruleTransition EOF ; |
| public final void entryRuleTransition() throws RecognitionException { |
| try { |
| // InternalFSM.g:457:1: ( ruleTransition EOF ) |
| // InternalFSM.g:458:1: ruleTransition EOF |
| { |
| before(grammarAccess.getTransitionRule()); |
| pushFollow(FOLLOW_1); |
| ruleTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTransition" |
| |
| |
| // $ANTLR start "ruleTransition" |
| // InternalFSM.g:465:1: ruleTransition : ( ( rule__Transition__Alternatives ) ) ; |
| public final void ruleTransition() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:469:2: ( ( ( rule__Transition__Alternatives ) ) ) |
| // InternalFSM.g:470:1: ( ( rule__Transition__Alternatives ) ) |
| { |
| // InternalFSM.g:470:1: ( ( rule__Transition__Alternatives ) ) |
| // InternalFSM.g:471:1: ( rule__Transition__Alternatives ) |
| { |
| before(grammarAccess.getTransitionAccess().getAlternatives()); |
| // InternalFSM.g:472:1: ( rule__Transition__Alternatives ) |
| // InternalFSM.g:472:2: rule__Transition__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__Transition__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTransitionAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTransition" |
| |
| |
| // $ANTLR start "entryRuleNonInitialTransition" |
| // InternalFSM.g:484:1: entryRuleNonInitialTransition : ruleNonInitialTransition EOF ; |
| public final void entryRuleNonInitialTransition() throws RecognitionException { |
| try { |
| // InternalFSM.g:485:1: ( ruleNonInitialTransition EOF ) |
| // InternalFSM.g:486:1: ruleNonInitialTransition EOF |
| { |
| before(grammarAccess.getNonInitialTransitionRule()); |
| pushFollow(FOLLOW_1); |
| ruleNonInitialTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getNonInitialTransitionRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNonInitialTransition" |
| |
| |
| // $ANTLR start "ruleNonInitialTransition" |
| // InternalFSM.g:493:1: ruleNonInitialTransition : ( ( rule__NonInitialTransition__Alternatives ) ) ; |
| public final void ruleNonInitialTransition() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:497:2: ( ( ( rule__NonInitialTransition__Alternatives ) ) ) |
| // InternalFSM.g:498:1: ( ( rule__NonInitialTransition__Alternatives ) ) |
| { |
| // InternalFSM.g:498:1: ( ( rule__NonInitialTransition__Alternatives ) ) |
| // InternalFSM.g:499:1: ( rule__NonInitialTransition__Alternatives ) |
| { |
| before(grammarAccess.getNonInitialTransitionAccess().getAlternatives()); |
| // InternalFSM.g:500:1: ( rule__NonInitialTransition__Alternatives ) |
| // InternalFSM.g:500:2: rule__NonInitialTransition__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__NonInitialTransition__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getNonInitialTransitionAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNonInitialTransition" |
| |
| |
| // $ANTLR start "entryRuleTransitionChainStartTransition" |
| // InternalFSM.g:512:1: entryRuleTransitionChainStartTransition : ruleTransitionChainStartTransition EOF ; |
| public final void entryRuleTransitionChainStartTransition() throws RecognitionException { |
| try { |
| // InternalFSM.g:513:1: ( ruleTransitionChainStartTransition EOF ) |
| // InternalFSM.g:514:1: ruleTransitionChainStartTransition EOF |
| { |
| before(grammarAccess.getTransitionChainStartTransitionRule()); |
| pushFollow(FOLLOW_1); |
| ruleTransitionChainStartTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionChainStartTransitionRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTransitionChainStartTransition" |
| |
| |
| // $ANTLR start "ruleTransitionChainStartTransition" |
| // InternalFSM.g:521:1: ruleTransitionChainStartTransition : ( ( rule__TransitionChainStartTransition__Alternatives ) ) ; |
| public final void ruleTransitionChainStartTransition() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:525:2: ( ( ( rule__TransitionChainStartTransition__Alternatives ) ) ) |
| // InternalFSM.g:526:1: ( ( rule__TransitionChainStartTransition__Alternatives ) ) |
| { |
| // InternalFSM.g:526:1: ( ( rule__TransitionChainStartTransition__Alternatives ) ) |
| // InternalFSM.g:527:1: ( rule__TransitionChainStartTransition__Alternatives ) |
| { |
| before(grammarAccess.getTransitionChainStartTransitionAccess().getAlternatives()); |
| // InternalFSM.g:528:1: ( rule__TransitionChainStartTransition__Alternatives ) |
| // InternalFSM.g:528:2: rule__TransitionChainStartTransition__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__TransitionChainStartTransition__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTransitionChainStartTransitionAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTransitionChainStartTransition" |
| |
| |
| // $ANTLR start "entryRuleInitialTransition" |
| // InternalFSM.g:540:1: entryRuleInitialTransition : ruleInitialTransition EOF ; |
| public final void entryRuleInitialTransition() throws RecognitionException { |
| try { |
| // InternalFSM.g:541:1: ( ruleInitialTransition EOF ) |
| // InternalFSM.g:542:1: ruleInitialTransition EOF |
| { |
| before(grammarAccess.getInitialTransitionRule()); |
| pushFollow(FOLLOW_1); |
| ruleInitialTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getInitialTransitionRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleInitialTransition" |
| |
| |
| // $ANTLR start "ruleInitialTransition" |
| // InternalFSM.g:549:1: ruleInitialTransition : ( ( rule__InitialTransition__Group__0 ) ) ; |
| public final void ruleInitialTransition() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:553:2: ( ( ( rule__InitialTransition__Group__0 ) ) ) |
| // InternalFSM.g:554:1: ( ( rule__InitialTransition__Group__0 ) ) |
| { |
| // InternalFSM.g:554:1: ( ( rule__InitialTransition__Group__0 ) ) |
| // InternalFSM.g:555:1: ( rule__InitialTransition__Group__0 ) |
| { |
| before(grammarAccess.getInitialTransitionAccess().getGroup()); |
| // InternalFSM.g:556:1: ( rule__InitialTransition__Group__0 ) |
| // InternalFSM.g:556:2: rule__InitialTransition__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInitialTransitionAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleInitialTransition" |
| |
| |
| // $ANTLR start "entryRuleContinuationTransition" |
| // InternalFSM.g:568:1: entryRuleContinuationTransition : ruleContinuationTransition EOF ; |
| public final void entryRuleContinuationTransition() throws RecognitionException { |
| try { |
| // InternalFSM.g:569:1: ( ruleContinuationTransition EOF ) |
| // InternalFSM.g:570:1: ruleContinuationTransition EOF |
| { |
| before(grammarAccess.getContinuationTransitionRule()); |
| pushFollow(FOLLOW_1); |
| ruleContinuationTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getContinuationTransitionRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleContinuationTransition" |
| |
| |
| // $ANTLR start "ruleContinuationTransition" |
| // InternalFSM.g:577:1: ruleContinuationTransition : ( ( rule__ContinuationTransition__Group__0 ) ) ; |
| public final void ruleContinuationTransition() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:581:2: ( ( ( rule__ContinuationTransition__Group__0 ) ) ) |
| // InternalFSM.g:582:1: ( ( rule__ContinuationTransition__Group__0 ) ) |
| { |
| // InternalFSM.g:582:1: ( ( rule__ContinuationTransition__Group__0 ) ) |
| // InternalFSM.g:583:1: ( rule__ContinuationTransition__Group__0 ) |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getGroup()); |
| // InternalFSM.g:584:1: ( rule__ContinuationTransition__Group__0 ) |
| // InternalFSM.g:584:2: rule__ContinuationTransition__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getContinuationTransitionAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleContinuationTransition" |
| |
| |
| // $ANTLR start "entryRuleTriggeredTransition" |
| // InternalFSM.g:596:1: entryRuleTriggeredTransition : ruleTriggeredTransition EOF ; |
| public final void entryRuleTriggeredTransition() throws RecognitionException { |
| try { |
| // InternalFSM.g:597:1: ( ruleTriggeredTransition EOF ) |
| // InternalFSM.g:598:1: ruleTriggeredTransition EOF |
| { |
| before(grammarAccess.getTriggeredTransitionRule()); |
| pushFollow(FOLLOW_1); |
| ruleTriggeredTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggeredTransitionRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTriggeredTransition" |
| |
| |
| // $ANTLR start "ruleTriggeredTransition" |
| // InternalFSM.g:605:1: ruleTriggeredTransition : ( ( rule__TriggeredTransition__Group__0 ) ) ; |
| public final void ruleTriggeredTransition() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:609:2: ( ( ( rule__TriggeredTransition__Group__0 ) ) ) |
| // InternalFSM.g:610:1: ( ( rule__TriggeredTransition__Group__0 ) ) |
| { |
| // InternalFSM.g:610:1: ( ( rule__TriggeredTransition__Group__0 ) ) |
| // InternalFSM.g:611:1: ( rule__TriggeredTransition__Group__0 ) |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getGroup()); |
| // InternalFSM.g:612:1: ( rule__TriggeredTransition__Group__0 ) |
| // InternalFSM.g:612:2: rule__TriggeredTransition__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTriggeredTransition" |
| |
| |
| // $ANTLR start "entryRuleGuardedTransition" |
| // InternalFSM.g:624:1: entryRuleGuardedTransition : ruleGuardedTransition EOF ; |
| public final void entryRuleGuardedTransition() throws RecognitionException { |
| try { |
| // InternalFSM.g:625:1: ( ruleGuardedTransition EOF ) |
| // InternalFSM.g:626:1: ruleGuardedTransition EOF |
| { |
| before(grammarAccess.getGuardedTransitionRule()); |
| pushFollow(FOLLOW_1); |
| ruleGuardedTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getGuardedTransitionRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleGuardedTransition" |
| |
| |
| // $ANTLR start "ruleGuardedTransition" |
| // InternalFSM.g:633:1: ruleGuardedTransition : ( ( rule__GuardedTransition__Group__0 ) ) ; |
| public final void ruleGuardedTransition() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:637:2: ( ( ( rule__GuardedTransition__Group__0 ) ) ) |
| // InternalFSM.g:638:1: ( ( rule__GuardedTransition__Group__0 ) ) |
| { |
| // InternalFSM.g:638:1: ( ( rule__GuardedTransition__Group__0 ) ) |
| // InternalFSM.g:639:1: ( rule__GuardedTransition__Group__0 ) |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getGroup()); |
| // InternalFSM.g:640:1: ( rule__GuardedTransition__Group__0 ) |
| // InternalFSM.g:640:2: rule__GuardedTransition__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getGuardedTransitionAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleGuardedTransition" |
| |
| |
| // $ANTLR start "entryRuleCPBranchTransition" |
| // InternalFSM.g:652:1: entryRuleCPBranchTransition : ruleCPBranchTransition EOF ; |
| public final void entryRuleCPBranchTransition() throws RecognitionException { |
| try { |
| // InternalFSM.g:653:1: ( ruleCPBranchTransition EOF ) |
| // InternalFSM.g:654:1: ruleCPBranchTransition EOF |
| { |
| before(grammarAccess.getCPBranchTransitionRule()); |
| pushFollow(FOLLOW_1); |
| ruleCPBranchTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getCPBranchTransitionRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleCPBranchTransition" |
| |
| |
| // $ANTLR start "ruleCPBranchTransition" |
| // InternalFSM.g:661:1: ruleCPBranchTransition : ( ( rule__CPBranchTransition__Group__0 ) ) ; |
| public final void ruleCPBranchTransition() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:665:2: ( ( ( rule__CPBranchTransition__Group__0 ) ) ) |
| // InternalFSM.g:666:1: ( ( rule__CPBranchTransition__Group__0 ) ) |
| { |
| // InternalFSM.g:666:1: ( ( rule__CPBranchTransition__Group__0 ) ) |
| // InternalFSM.g:667:1: ( rule__CPBranchTransition__Group__0 ) |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getGroup()); |
| // InternalFSM.g:668:1: ( rule__CPBranchTransition__Group__0 ) |
| // InternalFSM.g:668:2: rule__CPBranchTransition__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleCPBranchTransition" |
| |
| |
| // $ANTLR start "entryRuleRefinedTransition" |
| // InternalFSM.g:680:1: entryRuleRefinedTransition : ruleRefinedTransition EOF ; |
| public final void entryRuleRefinedTransition() throws RecognitionException { |
| try { |
| // InternalFSM.g:681:1: ( ruleRefinedTransition EOF ) |
| // InternalFSM.g:682:1: ruleRefinedTransition EOF |
| { |
| before(grammarAccess.getRefinedTransitionRule()); |
| pushFollow(FOLLOW_1); |
| ruleRefinedTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedTransitionRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleRefinedTransition" |
| |
| |
| // $ANTLR start "ruleRefinedTransition" |
| // InternalFSM.g:689:1: ruleRefinedTransition : ( ( rule__RefinedTransition__Group__0 ) ) ; |
| public final void ruleRefinedTransition() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:693:2: ( ( ( rule__RefinedTransition__Group__0 ) ) ) |
| // InternalFSM.g:694:1: ( ( rule__RefinedTransition__Group__0 ) ) |
| { |
| // InternalFSM.g:694:1: ( ( rule__RefinedTransition__Group__0 ) ) |
| // InternalFSM.g:695:1: ( rule__RefinedTransition__Group__0 ) |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getGroup()); |
| // InternalFSM.g:696:1: ( rule__RefinedTransition__Group__0 ) |
| // InternalFSM.g:696:2: rule__RefinedTransition__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRefinedTransitionAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleRefinedTransition" |
| |
| |
| // $ANTLR start "entryRuleTransitionTerminal" |
| // InternalFSM.g:708:1: entryRuleTransitionTerminal : ruleTransitionTerminal EOF ; |
| public final void entryRuleTransitionTerminal() throws RecognitionException { |
| try { |
| // InternalFSM.g:709:1: ( ruleTransitionTerminal EOF ) |
| // InternalFSM.g:710:1: ruleTransitionTerminal EOF |
| { |
| before(grammarAccess.getTransitionTerminalRule()); |
| pushFollow(FOLLOW_1); |
| ruleTransitionTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionTerminalRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTransitionTerminal" |
| |
| |
| // $ANTLR start "ruleTransitionTerminal" |
| // InternalFSM.g:717:1: ruleTransitionTerminal : ( ( rule__TransitionTerminal__Alternatives ) ) ; |
| public final void ruleTransitionTerminal() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:721:2: ( ( ( rule__TransitionTerminal__Alternatives ) ) ) |
| // InternalFSM.g:722:1: ( ( rule__TransitionTerminal__Alternatives ) ) |
| { |
| // InternalFSM.g:722:1: ( ( rule__TransitionTerminal__Alternatives ) ) |
| // InternalFSM.g:723:1: ( rule__TransitionTerminal__Alternatives ) |
| { |
| before(grammarAccess.getTransitionTerminalAccess().getAlternatives()); |
| // InternalFSM.g:724:1: ( rule__TransitionTerminal__Alternatives ) |
| // InternalFSM.g:724:2: rule__TransitionTerminal__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__TransitionTerminal__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTransitionTerminalAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTransitionTerminal" |
| |
| |
| // $ANTLR start "entryRuleStateTerminal" |
| // InternalFSM.g:736:1: entryRuleStateTerminal : ruleStateTerminal EOF ; |
| public final void entryRuleStateTerminal() throws RecognitionException { |
| try { |
| // InternalFSM.g:737:1: ( ruleStateTerminal EOF ) |
| // InternalFSM.g:738:1: ruleStateTerminal EOF |
| { |
| before(grammarAccess.getStateTerminalRule()); |
| pushFollow(FOLLOW_1); |
| ruleStateTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateTerminalRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleStateTerminal" |
| |
| |
| // $ANTLR start "ruleStateTerminal" |
| // InternalFSM.g:745:1: ruleStateTerminal : ( ( rule__StateTerminal__StateAssignment ) ) ; |
| public final void ruleStateTerminal() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:749:2: ( ( ( rule__StateTerminal__StateAssignment ) ) ) |
| // InternalFSM.g:750:1: ( ( rule__StateTerminal__StateAssignment ) ) |
| { |
| // InternalFSM.g:750:1: ( ( rule__StateTerminal__StateAssignment ) ) |
| // InternalFSM.g:751:1: ( rule__StateTerminal__StateAssignment ) |
| { |
| before(grammarAccess.getStateTerminalAccess().getStateAssignment()); |
| // InternalFSM.g:752:1: ( rule__StateTerminal__StateAssignment ) |
| // InternalFSM.g:752:2: rule__StateTerminal__StateAssignment |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateTerminal__StateAssignment(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateTerminalAccess().getStateAssignment()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleStateTerminal" |
| |
| |
| // $ANTLR start "entryRuleTrPointTerminal" |
| // InternalFSM.g:764:1: entryRuleTrPointTerminal : ruleTrPointTerminal EOF ; |
| public final void entryRuleTrPointTerminal() throws RecognitionException { |
| try { |
| // InternalFSM.g:765:1: ( ruleTrPointTerminal EOF ) |
| // InternalFSM.g:766:1: ruleTrPointTerminal EOF |
| { |
| before(grammarAccess.getTrPointTerminalRule()); |
| pushFollow(FOLLOW_1); |
| ruleTrPointTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTrPointTerminalRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTrPointTerminal" |
| |
| |
| // $ANTLR start "ruleTrPointTerminal" |
| // InternalFSM.g:773:1: ruleTrPointTerminal : ( ( rule__TrPointTerminal__Group__0 ) ) ; |
| public final void ruleTrPointTerminal() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:777:2: ( ( ( rule__TrPointTerminal__Group__0 ) ) ) |
| // InternalFSM.g:778:1: ( ( rule__TrPointTerminal__Group__0 ) ) |
| { |
| // InternalFSM.g:778:1: ( ( rule__TrPointTerminal__Group__0 ) ) |
| // InternalFSM.g:779:1: ( rule__TrPointTerminal__Group__0 ) |
| { |
| before(grammarAccess.getTrPointTerminalAccess().getGroup()); |
| // InternalFSM.g:780:1: ( rule__TrPointTerminal__Group__0 ) |
| // InternalFSM.g:780:2: rule__TrPointTerminal__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TrPointTerminal__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTrPointTerminalAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTrPointTerminal" |
| |
| |
| // $ANTLR start "entryRuleSubStateTrPointTerminal" |
| // InternalFSM.g:792:1: entryRuleSubStateTrPointTerminal : ruleSubStateTrPointTerminal EOF ; |
| public final void entryRuleSubStateTrPointTerminal() throws RecognitionException { |
| try { |
| // InternalFSM.g:793:1: ( ruleSubStateTrPointTerminal EOF ) |
| // InternalFSM.g:794:1: ruleSubStateTrPointTerminal EOF |
| { |
| before(grammarAccess.getSubStateTrPointTerminalRule()); |
| pushFollow(FOLLOW_1); |
| ruleSubStateTrPointTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSubStateTrPointTerminalRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleSubStateTrPointTerminal" |
| |
| |
| // $ANTLR start "ruleSubStateTrPointTerminal" |
| // InternalFSM.g:801:1: ruleSubStateTrPointTerminal : ( ( rule__SubStateTrPointTerminal__Group__0 ) ) ; |
| public final void ruleSubStateTrPointTerminal() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:805:2: ( ( ( rule__SubStateTrPointTerminal__Group__0 ) ) ) |
| // InternalFSM.g:806:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) ) |
| { |
| // InternalFSM.g:806:1: ( ( rule__SubStateTrPointTerminal__Group__0 ) ) |
| // InternalFSM.g:807:1: ( rule__SubStateTrPointTerminal__Group__0 ) |
| { |
| before(grammarAccess.getSubStateTrPointTerminalAccess().getGroup()); |
| // InternalFSM.g:808:1: ( rule__SubStateTrPointTerminal__Group__0 ) |
| // InternalFSM.g:808:2: rule__SubStateTrPointTerminal__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SubStateTrPointTerminal__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSubStateTrPointTerminalAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleSubStateTrPointTerminal" |
| |
| |
| // $ANTLR start "entryRuleChoicepointTerminal" |
| // InternalFSM.g:820:1: entryRuleChoicepointTerminal : ruleChoicepointTerminal EOF ; |
| public final void entryRuleChoicepointTerminal() throws RecognitionException { |
| try { |
| // InternalFSM.g:821:1: ( ruleChoicepointTerminal EOF ) |
| // InternalFSM.g:822:1: ruleChoicepointTerminal EOF |
| { |
| before(grammarAccess.getChoicepointTerminalRule()); |
| pushFollow(FOLLOW_1); |
| ruleChoicepointTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getChoicepointTerminalRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleChoicepointTerminal" |
| |
| |
| // $ANTLR start "ruleChoicepointTerminal" |
| // InternalFSM.g:829:1: ruleChoicepointTerminal : ( ( rule__ChoicepointTerminal__Group__0 ) ) ; |
| public final void ruleChoicepointTerminal() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:833:2: ( ( ( rule__ChoicepointTerminal__Group__0 ) ) ) |
| // InternalFSM.g:834:1: ( ( rule__ChoicepointTerminal__Group__0 ) ) |
| { |
| // InternalFSM.g:834:1: ( ( rule__ChoicepointTerminal__Group__0 ) ) |
| // InternalFSM.g:835:1: ( rule__ChoicepointTerminal__Group__0 ) |
| { |
| before(grammarAccess.getChoicepointTerminalAccess().getGroup()); |
| // InternalFSM.g:836:1: ( rule__ChoicepointTerminal__Group__0 ) |
| // InternalFSM.g:836:2: rule__ChoicepointTerminal__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ChoicepointTerminal__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getChoicepointTerminalAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleChoicepointTerminal" |
| |
| |
| // $ANTLR start "entryRuleTrigger" |
| // InternalFSM.g:848:1: entryRuleTrigger : ruleTrigger EOF ; |
| public final void entryRuleTrigger() throws RecognitionException { |
| try { |
| // InternalFSM.g:849:1: ( ruleTrigger EOF ) |
| // InternalFSM.g:850:1: ruleTrigger EOF |
| { |
| before(grammarAccess.getTriggerRule()); |
| pushFollow(FOLLOW_1); |
| ruleTrigger(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggerRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleTrigger" |
| |
| |
| // $ANTLR start "ruleTrigger" |
| // InternalFSM.g:857:1: ruleTrigger : ( ( rule__Trigger__Group__0 ) ) ; |
| public final void ruleTrigger() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:861:2: ( ( ( rule__Trigger__Group__0 ) ) ) |
| // InternalFSM.g:862:1: ( ( rule__Trigger__Group__0 ) ) |
| { |
| // InternalFSM.g:862:1: ( ( rule__Trigger__Group__0 ) ) |
| // InternalFSM.g:863:1: ( rule__Trigger__Group__0 ) |
| { |
| before(grammarAccess.getTriggerAccess().getGroup()); |
| // InternalFSM.g:864:1: ( rule__Trigger__Group__0 ) |
| // InternalFSM.g:864:2: rule__Trigger__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Trigger__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTriggerAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleTrigger" |
| |
| |
| // $ANTLR start "entryRuleMessageFromIf" |
| // InternalFSM.g:876:1: entryRuleMessageFromIf : ruleMessageFromIf EOF ; |
| public final void entryRuleMessageFromIf() throws RecognitionException { |
| try { |
| // InternalFSM.g:877:1: ( ruleMessageFromIf EOF ) |
| // InternalFSM.g:878:1: ruleMessageFromIf EOF |
| { |
| before(grammarAccess.getMessageFromIfRule()); |
| pushFollow(FOLLOW_1); |
| ruleMessageFromIf(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getMessageFromIfRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleMessageFromIf" |
| |
| |
| // $ANTLR start "ruleMessageFromIf" |
| // InternalFSM.g:885:1: ruleMessageFromIf : ( ( rule__MessageFromIf__Group__0 ) ) ; |
| public final void ruleMessageFromIf() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:889:2: ( ( ( rule__MessageFromIf__Group__0 ) ) ) |
| // InternalFSM.g:890:1: ( ( rule__MessageFromIf__Group__0 ) ) |
| { |
| // InternalFSM.g:890:1: ( ( rule__MessageFromIf__Group__0 ) ) |
| // InternalFSM.g:891:1: ( rule__MessageFromIf__Group__0 ) |
| { |
| before(grammarAccess.getMessageFromIfAccess().getGroup()); |
| // InternalFSM.g:892:1: ( rule__MessageFromIf__Group__0 ) |
| // InternalFSM.g:892:2: rule__MessageFromIf__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__MessageFromIf__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getMessageFromIfAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleMessageFromIf" |
| |
| |
| // $ANTLR start "entryRuleGuard" |
| // InternalFSM.g:906:1: entryRuleGuard : ruleGuard EOF ; |
| public final void entryRuleGuard() throws RecognitionException { |
| try { |
| // InternalFSM.g:907:1: ( ruleGuard EOF ) |
| // InternalFSM.g:908:1: ruleGuard EOF |
| { |
| before(grammarAccess.getGuardRule()); |
| pushFollow(FOLLOW_1); |
| ruleGuard(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getGuardRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleGuard" |
| |
| |
| // $ANTLR start "ruleGuard" |
| // InternalFSM.g:915:1: ruleGuard : ( ( rule__Guard__Group__0 ) ) ; |
| public final void ruleGuard() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:919:2: ( ( ( rule__Guard__Group__0 ) ) ) |
| // InternalFSM.g:920:1: ( ( rule__Guard__Group__0 ) ) |
| { |
| // InternalFSM.g:920:1: ( ( rule__Guard__Group__0 ) ) |
| // InternalFSM.g:921:1: ( rule__Guard__Group__0 ) |
| { |
| before(grammarAccess.getGuardAccess().getGroup()); |
| // InternalFSM.g:922:1: ( rule__Guard__Group__0 ) |
| // InternalFSM.g:922:2: rule__Guard__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Guard__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getGuardAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleGuard" |
| |
| |
| // $ANTLR start "entryRuleSemanticsRule" |
| // InternalFSM.g:936:1: entryRuleSemanticsRule : ruleSemanticsRule EOF ; |
| public final void entryRuleSemanticsRule() throws RecognitionException { |
| try { |
| // InternalFSM.g:937:1: ( ruleSemanticsRule EOF ) |
| // InternalFSM.g:938:1: ruleSemanticsRule EOF |
| { |
| before(grammarAccess.getSemanticsRuleRule()); |
| pushFollow(FOLLOW_1); |
| ruleSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSemanticsRuleRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleSemanticsRule" |
| |
| |
| // $ANTLR start "ruleSemanticsRule" |
| // InternalFSM.g:945:1: ruleSemanticsRule : ( ( rule__SemanticsRule__Alternatives ) ) ; |
| public final void ruleSemanticsRule() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:949:2: ( ( ( rule__SemanticsRule__Alternatives ) ) ) |
| // InternalFSM.g:950:1: ( ( rule__SemanticsRule__Alternatives ) ) |
| { |
| // InternalFSM.g:950:1: ( ( rule__SemanticsRule__Alternatives ) ) |
| // InternalFSM.g:951:1: ( rule__SemanticsRule__Alternatives ) |
| { |
| before(grammarAccess.getSemanticsRuleAccess().getAlternatives()); |
| // InternalFSM.g:952:1: ( rule__SemanticsRule__Alternatives ) |
| // InternalFSM.g:952:2: rule__SemanticsRule__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__SemanticsRule__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSemanticsRuleAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleSemanticsRule" |
| |
| |
| // $ANTLR start "entryRuleInSemanticsRule" |
| // InternalFSM.g:964:1: entryRuleInSemanticsRule : ruleInSemanticsRule EOF ; |
| public final void entryRuleInSemanticsRule() throws RecognitionException { |
| try { |
| // InternalFSM.g:965:1: ( ruleInSemanticsRule EOF ) |
| // InternalFSM.g:966:1: ruleInSemanticsRule EOF |
| { |
| before(grammarAccess.getInSemanticsRuleRule()); |
| pushFollow(FOLLOW_1); |
| ruleInSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getInSemanticsRuleRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleInSemanticsRule" |
| |
| |
| // $ANTLR start "ruleInSemanticsRule" |
| // InternalFSM.g:973:1: ruleInSemanticsRule : ( ( rule__InSemanticsRule__Group__0 ) ) ; |
| public final void ruleInSemanticsRule() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:977:2: ( ( ( rule__InSemanticsRule__Group__0 ) ) ) |
| // InternalFSM.g:978:1: ( ( rule__InSemanticsRule__Group__0 ) ) |
| { |
| // InternalFSM.g:978:1: ( ( rule__InSemanticsRule__Group__0 ) ) |
| // InternalFSM.g:979:1: ( rule__InSemanticsRule__Group__0 ) |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getGroup()); |
| // InternalFSM.g:980:1: ( rule__InSemanticsRule__Group__0 ) |
| // InternalFSM.g:980:2: rule__InSemanticsRule__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleInSemanticsRule" |
| |
| |
| // $ANTLR start "entryRuleOutSemanticsRule" |
| // InternalFSM.g:992:1: entryRuleOutSemanticsRule : ruleOutSemanticsRule EOF ; |
| public final void entryRuleOutSemanticsRule() throws RecognitionException { |
| try { |
| // InternalFSM.g:993:1: ( ruleOutSemanticsRule EOF ) |
| // InternalFSM.g:994:1: ruleOutSemanticsRule EOF |
| { |
| before(grammarAccess.getOutSemanticsRuleRule()); |
| pushFollow(FOLLOW_1); |
| ruleOutSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getOutSemanticsRuleRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleOutSemanticsRule" |
| |
| |
| // $ANTLR start "ruleOutSemanticsRule" |
| // InternalFSM.g:1001:1: ruleOutSemanticsRule : ( ( rule__OutSemanticsRule__Group__0 ) ) ; |
| public final void ruleOutSemanticsRule() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1005:2: ( ( ( rule__OutSemanticsRule__Group__0 ) ) ) |
| // InternalFSM.g:1006:1: ( ( rule__OutSemanticsRule__Group__0 ) ) |
| { |
| // InternalFSM.g:1006:1: ( ( rule__OutSemanticsRule__Group__0 ) ) |
| // InternalFSM.g:1007:1: ( rule__OutSemanticsRule__Group__0 ) |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getGroup()); |
| // InternalFSM.g:1008:1: ( rule__OutSemanticsRule__Group__0 ) |
| // InternalFSM.g:1008:2: rule__OutSemanticsRule__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleOutSemanticsRule" |
| |
| |
| // $ANTLR start "entryRuleKeyValue" |
| // InternalFSM.g:1022:1: entryRuleKeyValue : ruleKeyValue EOF ; |
| public final void entryRuleKeyValue() throws RecognitionException { |
| try { |
| // InternalFSM.g:1023:1: ( ruleKeyValue EOF ) |
| // InternalFSM.g:1024:1: ruleKeyValue EOF |
| { |
| before(grammarAccess.getKeyValueRule()); |
| pushFollow(FOLLOW_1); |
| ruleKeyValue(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getKeyValueRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleKeyValue" |
| |
| |
| // $ANTLR start "ruleKeyValue" |
| // InternalFSM.g:1031:1: ruleKeyValue : ( ( rule__KeyValue__Group__0 ) ) ; |
| public final void ruleKeyValue() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1035:2: ( ( ( rule__KeyValue__Group__0 ) ) ) |
| // InternalFSM.g:1036:1: ( ( rule__KeyValue__Group__0 ) ) |
| { |
| // InternalFSM.g:1036:1: ( ( rule__KeyValue__Group__0 ) ) |
| // InternalFSM.g:1037:1: ( rule__KeyValue__Group__0 ) |
| { |
| before(grammarAccess.getKeyValueAccess().getGroup()); |
| // InternalFSM.g:1038:1: ( rule__KeyValue__Group__0 ) |
| // InternalFSM.g:1038:2: rule__KeyValue__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__KeyValue__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getKeyValueAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleKeyValue" |
| |
| |
| // $ANTLR start "entryRuleAnnotationTargetType" |
| // InternalFSM.g:1052:1: entryRuleAnnotationTargetType : ruleAnnotationTargetType EOF ; |
| public final void entryRuleAnnotationTargetType() throws RecognitionException { |
| try { |
| // InternalFSM.g:1053:1: ( ruleAnnotationTargetType EOF ) |
| // InternalFSM.g:1054:1: ruleAnnotationTargetType EOF |
| { |
| before(grammarAccess.getAnnotationTargetTypeRule()); |
| pushFollow(FOLLOW_1); |
| ruleAnnotationTargetType(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getAnnotationTargetTypeRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleAnnotationTargetType" |
| |
| |
| // $ANTLR start "ruleAnnotationTargetType" |
| // InternalFSM.g:1061:1: ruleAnnotationTargetType : ( RULE_ID ) ; |
| public final void ruleAnnotationTargetType() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1065:2: ( ( RULE_ID ) ) |
| // InternalFSM.g:1066:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:1066:1: ( RULE_ID ) |
| // InternalFSM.g:1067:1: RULE_ID |
| { |
| before(grammarAccess.getAnnotationTargetTypeAccess().getIDTerminalRuleCall()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getAnnotationTargetTypeAccess().getIDTerminalRuleCall()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleAnnotationTargetType" |
| |
| |
| // $ANTLR start "entryRuleAnnotationAttribute" |
| // InternalFSM.g:1080:1: entryRuleAnnotationAttribute : ruleAnnotationAttribute EOF ; |
| public final void entryRuleAnnotationAttribute() throws RecognitionException { |
| try { |
| // InternalFSM.g:1081:1: ( ruleAnnotationAttribute EOF ) |
| // InternalFSM.g:1082:1: ruleAnnotationAttribute EOF |
| { |
| before(grammarAccess.getAnnotationAttributeRule()); |
| pushFollow(FOLLOW_1); |
| ruleAnnotationAttribute(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getAnnotationAttributeRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleAnnotationAttribute" |
| |
| |
| // $ANTLR start "ruleAnnotationAttribute" |
| // InternalFSM.g:1089:1: ruleAnnotationAttribute : ( ( rule__AnnotationAttribute__Alternatives ) ) ; |
| public final void ruleAnnotationAttribute() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1093:2: ( ( ( rule__AnnotationAttribute__Alternatives ) ) ) |
| // InternalFSM.g:1094:1: ( ( rule__AnnotationAttribute__Alternatives ) ) |
| { |
| // InternalFSM.g:1094:1: ( ( rule__AnnotationAttribute__Alternatives ) ) |
| // InternalFSM.g:1095:1: ( rule__AnnotationAttribute__Alternatives ) |
| { |
| before(grammarAccess.getAnnotationAttributeAccess().getAlternatives()); |
| // InternalFSM.g:1096:1: ( rule__AnnotationAttribute__Alternatives ) |
| // InternalFSM.g:1096:2: rule__AnnotationAttribute__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__AnnotationAttribute__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getAnnotationAttributeAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleAnnotationAttribute" |
| |
| |
| // $ANTLR start "entryRuleSimpleAnnotationAttribute" |
| // InternalFSM.g:1108:1: entryRuleSimpleAnnotationAttribute : ruleSimpleAnnotationAttribute EOF ; |
| public final void entryRuleSimpleAnnotationAttribute() throws RecognitionException { |
| try { |
| // InternalFSM.g:1109:1: ( ruleSimpleAnnotationAttribute EOF ) |
| // InternalFSM.g:1110:1: ruleSimpleAnnotationAttribute EOF |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeRule()); |
| pushFollow(FOLLOW_1); |
| ruleSimpleAnnotationAttribute(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSimpleAnnotationAttributeRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleSimpleAnnotationAttribute" |
| |
| |
| // $ANTLR start "ruleSimpleAnnotationAttribute" |
| // InternalFSM.g:1117:1: ruleSimpleAnnotationAttribute : ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) ; |
| public final void ruleSimpleAnnotationAttribute() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1121:2: ( ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) ) |
| // InternalFSM.g:1122:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) |
| { |
| // InternalFSM.g:1122:1: ( ( rule__SimpleAnnotationAttribute__Group__0 ) ) |
| // InternalFSM.g:1123:1: ( rule__SimpleAnnotationAttribute__Group__0 ) |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getGroup()); |
| // InternalFSM.g:1124:1: ( rule__SimpleAnnotationAttribute__Group__0 ) |
| // InternalFSM.g:1124:2: rule__SimpleAnnotationAttribute__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleAnnotationAttribute__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleSimpleAnnotationAttribute" |
| |
| |
| // $ANTLR start "entryRuleEnumAnnotationAttribute" |
| // InternalFSM.g:1136:1: entryRuleEnumAnnotationAttribute : ruleEnumAnnotationAttribute EOF ; |
| public final void entryRuleEnumAnnotationAttribute() throws RecognitionException { |
| try { |
| // InternalFSM.g:1137:1: ( ruleEnumAnnotationAttribute EOF ) |
| // InternalFSM.g:1138:1: ruleEnumAnnotationAttribute EOF |
| { |
| before(grammarAccess.getEnumAnnotationAttributeRule()); |
| pushFollow(FOLLOW_1); |
| ruleEnumAnnotationAttribute(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getEnumAnnotationAttributeRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleEnumAnnotationAttribute" |
| |
| |
| // $ANTLR start "ruleEnumAnnotationAttribute" |
| // InternalFSM.g:1145:1: ruleEnumAnnotationAttribute : ( ( rule__EnumAnnotationAttribute__Group__0 ) ) ; |
| public final void ruleEnumAnnotationAttribute() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1149:2: ( ( ( rule__EnumAnnotationAttribute__Group__0 ) ) ) |
| // InternalFSM.g:1150:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) ) |
| { |
| // InternalFSM.g:1150:1: ( ( rule__EnumAnnotationAttribute__Group__0 ) ) |
| // InternalFSM.g:1151:1: ( rule__EnumAnnotationAttribute__Group__0 ) |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getGroup()); |
| // InternalFSM.g:1152:1: ( rule__EnumAnnotationAttribute__Group__0 ) |
| // InternalFSM.g:1152:2: rule__EnumAnnotationAttribute__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleEnumAnnotationAttribute" |
| |
| |
| // $ANTLR start "entryRuleImportedFQN" |
| // InternalFSM.g:1166:1: entryRuleImportedFQN : ruleImportedFQN EOF ; |
| public final void entryRuleImportedFQN() throws RecognitionException { |
| try { |
| // InternalFSM.g:1167:1: ( ruleImportedFQN EOF ) |
| // InternalFSM.g:1168:1: ruleImportedFQN EOF |
| { |
| before(grammarAccess.getImportedFQNRule()); |
| pushFollow(FOLLOW_1); |
| ruleImportedFQN(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getImportedFQNRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleImportedFQN" |
| |
| |
| // $ANTLR start "ruleImportedFQN" |
| // InternalFSM.g:1175:1: ruleImportedFQN : ( ( rule__ImportedFQN__Group__0 ) ) ; |
| public final void ruleImportedFQN() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1179:2: ( ( ( rule__ImportedFQN__Group__0 ) ) ) |
| // InternalFSM.g:1180:1: ( ( rule__ImportedFQN__Group__0 ) ) |
| { |
| // InternalFSM.g:1180:1: ( ( rule__ImportedFQN__Group__0 ) ) |
| // InternalFSM.g:1181:1: ( rule__ImportedFQN__Group__0 ) |
| { |
| before(grammarAccess.getImportedFQNAccess().getGroup()); |
| // InternalFSM.g:1182:1: ( rule__ImportedFQN__Group__0 ) |
| // InternalFSM.g:1182:2: rule__ImportedFQN__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ImportedFQN__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getImportedFQNAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleImportedFQN" |
| |
| |
| // $ANTLR start "entryRuleDocumentation" |
| // InternalFSM.g:1194:1: entryRuleDocumentation : ruleDocumentation EOF ; |
| public final void entryRuleDocumentation() throws RecognitionException { |
| try { |
| // InternalFSM.g:1195:1: ( ruleDocumentation EOF ) |
| // InternalFSM.g:1196:1: ruleDocumentation EOF |
| { |
| before(grammarAccess.getDocumentationRule()); |
| pushFollow(FOLLOW_1); |
| ruleDocumentation(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getDocumentationRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDocumentation" |
| |
| |
| // $ANTLR start "ruleDocumentation" |
| // InternalFSM.g:1203:1: ruleDocumentation : ( ( rule__Documentation__Group__0 ) ) ; |
| public final void ruleDocumentation() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1207:2: ( ( ( rule__Documentation__Group__0 ) ) ) |
| // InternalFSM.g:1208:1: ( ( rule__Documentation__Group__0 ) ) |
| { |
| // InternalFSM.g:1208:1: ( ( rule__Documentation__Group__0 ) ) |
| // InternalFSM.g:1209:1: ( rule__Documentation__Group__0 ) |
| { |
| before(grammarAccess.getDocumentationAccess().getGroup()); |
| // InternalFSM.g:1210:1: ( rule__Documentation__Group__0 ) |
| // InternalFSM.g:1210:2: rule__Documentation__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Documentation__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getDocumentationAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDocumentation" |
| |
| |
| // $ANTLR start "entryRuleLiteral" |
| // InternalFSM.g:1226:1: entryRuleLiteral : ruleLiteral EOF ; |
| public final void entryRuleLiteral() throws RecognitionException { |
| try { |
| // InternalFSM.g:1227:1: ( ruleLiteral EOF ) |
| // InternalFSM.g:1228:1: ruleLiteral EOF |
| { |
| before(grammarAccess.getLiteralRule()); |
| pushFollow(FOLLOW_1); |
| ruleLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getLiteralRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleLiteral" |
| |
| |
| // $ANTLR start "ruleLiteral" |
| // InternalFSM.g:1235:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ; |
| public final void ruleLiteral() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1239:2: ( ( ( rule__Literal__Alternatives ) ) ) |
| // InternalFSM.g:1240:1: ( ( rule__Literal__Alternatives ) ) |
| { |
| // InternalFSM.g:1240:1: ( ( rule__Literal__Alternatives ) ) |
| // InternalFSM.g:1241:1: ( rule__Literal__Alternatives ) |
| { |
| before(grammarAccess.getLiteralAccess().getAlternatives()); |
| // InternalFSM.g:1242:1: ( rule__Literal__Alternatives ) |
| // InternalFSM.g:1242:2: rule__Literal__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__Literal__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getLiteralAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteral" |
| |
| |
| // $ANTLR start "entryRuleBooleanLiteral" |
| // InternalFSM.g:1254:1: entryRuleBooleanLiteral : ruleBooleanLiteral EOF ; |
| public final void entryRuleBooleanLiteral() throws RecognitionException { |
| try { |
| // InternalFSM.g:1255:1: ( ruleBooleanLiteral EOF ) |
| // InternalFSM.g:1256:1: ruleBooleanLiteral EOF |
| { |
| before(grammarAccess.getBooleanLiteralRule()); |
| pushFollow(FOLLOW_1); |
| ruleBooleanLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getBooleanLiteralRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleBooleanLiteral" |
| |
| |
| // $ANTLR start "ruleBooleanLiteral" |
| // InternalFSM.g:1263:1: ruleBooleanLiteral : ( ( rule__BooleanLiteral__Group__0 ) ) ; |
| public final void ruleBooleanLiteral() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1267:2: ( ( ( rule__BooleanLiteral__Group__0 ) ) ) |
| // InternalFSM.g:1268:1: ( ( rule__BooleanLiteral__Group__0 ) ) |
| { |
| // InternalFSM.g:1268:1: ( ( rule__BooleanLiteral__Group__0 ) ) |
| // InternalFSM.g:1269:1: ( rule__BooleanLiteral__Group__0 ) |
| { |
| before(grammarAccess.getBooleanLiteralAccess().getGroup()); |
| // InternalFSM.g:1270:1: ( rule__BooleanLiteral__Group__0 ) |
| // InternalFSM.g:1270:2: rule__BooleanLiteral__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__BooleanLiteral__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getBooleanLiteralAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleBooleanLiteral" |
| |
| |
| // $ANTLR start "entryRuleNumberLiteral" |
| // InternalFSM.g:1282:1: entryRuleNumberLiteral : ruleNumberLiteral EOF ; |
| public final void entryRuleNumberLiteral() throws RecognitionException { |
| try { |
| // InternalFSM.g:1283:1: ( ruleNumberLiteral EOF ) |
| // InternalFSM.g:1284:1: ruleNumberLiteral EOF |
| { |
| before(grammarAccess.getNumberLiteralRule()); |
| pushFollow(FOLLOW_1); |
| ruleNumberLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getNumberLiteralRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleNumberLiteral" |
| |
| |
| // $ANTLR start "ruleNumberLiteral" |
| // InternalFSM.g:1291:1: ruleNumberLiteral : ( ( rule__NumberLiteral__Alternatives ) ) ; |
| public final void ruleNumberLiteral() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1295:2: ( ( ( rule__NumberLiteral__Alternatives ) ) ) |
| // InternalFSM.g:1296:1: ( ( rule__NumberLiteral__Alternatives ) ) |
| { |
| // InternalFSM.g:1296:1: ( ( rule__NumberLiteral__Alternatives ) ) |
| // InternalFSM.g:1297:1: ( rule__NumberLiteral__Alternatives ) |
| { |
| before(grammarAccess.getNumberLiteralAccess().getAlternatives()); |
| // InternalFSM.g:1298:1: ( rule__NumberLiteral__Alternatives ) |
| // InternalFSM.g:1298:2: rule__NumberLiteral__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__NumberLiteral__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getNumberLiteralAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleNumberLiteral" |
| |
| |
| // $ANTLR start "entryRuleRealLiteral" |
| // InternalFSM.g:1310:1: entryRuleRealLiteral : ruleRealLiteral EOF ; |
| public final void entryRuleRealLiteral() throws RecognitionException { |
| try { |
| // InternalFSM.g:1311:1: ( ruleRealLiteral EOF ) |
| // InternalFSM.g:1312:1: ruleRealLiteral EOF |
| { |
| before(grammarAccess.getRealLiteralRule()); |
| pushFollow(FOLLOW_1); |
| ruleRealLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRealLiteralRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleRealLiteral" |
| |
| |
| // $ANTLR start "ruleRealLiteral" |
| // InternalFSM.g:1319:1: ruleRealLiteral : ( ( rule__RealLiteral__Group__0 ) ) ; |
| public final void ruleRealLiteral() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1323:2: ( ( ( rule__RealLiteral__Group__0 ) ) ) |
| // InternalFSM.g:1324:1: ( ( rule__RealLiteral__Group__0 ) ) |
| { |
| // InternalFSM.g:1324:1: ( ( rule__RealLiteral__Group__0 ) ) |
| // InternalFSM.g:1325:1: ( rule__RealLiteral__Group__0 ) |
| { |
| before(grammarAccess.getRealLiteralAccess().getGroup()); |
| // InternalFSM.g:1326:1: ( rule__RealLiteral__Group__0 ) |
| // InternalFSM.g:1326:2: rule__RealLiteral__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RealLiteral__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRealLiteralAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleRealLiteral" |
| |
| |
| // $ANTLR start "entryRuleIntLiteral" |
| // InternalFSM.g:1338:1: entryRuleIntLiteral : ruleIntLiteral EOF ; |
| public final void entryRuleIntLiteral() throws RecognitionException { |
| try { |
| // InternalFSM.g:1339:1: ( ruleIntLiteral EOF ) |
| // InternalFSM.g:1340:1: ruleIntLiteral EOF |
| { |
| before(grammarAccess.getIntLiteralRule()); |
| pushFollow(FOLLOW_1); |
| ruleIntLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getIntLiteralRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleIntLiteral" |
| |
| |
| // $ANTLR start "ruleIntLiteral" |
| // InternalFSM.g:1347:1: ruleIntLiteral : ( ( rule__IntLiteral__Group__0 ) ) ; |
| public final void ruleIntLiteral() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1351:2: ( ( ( rule__IntLiteral__Group__0 ) ) ) |
| // InternalFSM.g:1352:1: ( ( rule__IntLiteral__Group__0 ) ) |
| { |
| // InternalFSM.g:1352:1: ( ( rule__IntLiteral__Group__0 ) ) |
| // InternalFSM.g:1353:1: ( rule__IntLiteral__Group__0 ) |
| { |
| before(grammarAccess.getIntLiteralAccess().getGroup()); |
| // InternalFSM.g:1354:1: ( rule__IntLiteral__Group__0 ) |
| // InternalFSM.g:1354:2: rule__IntLiteral__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__IntLiteral__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getIntLiteralAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleIntLiteral" |
| |
| |
| // $ANTLR start "entryRuleStringLiteral" |
| // InternalFSM.g:1366:1: entryRuleStringLiteral : ruleStringLiteral EOF ; |
| public final void entryRuleStringLiteral() throws RecognitionException { |
| try { |
| // InternalFSM.g:1367:1: ( ruleStringLiteral EOF ) |
| // InternalFSM.g:1368:1: ruleStringLiteral EOF |
| { |
| before(grammarAccess.getStringLiteralRule()); |
| pushFollow(FOLLOW_1); |
| ruleStringLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStringLiteralRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleStringLiteral" |
| |
| |
| // $ANTLR start "ruleStringLiteral" |
| // InternalFSM.g:1375:1: ruleStringLiteral : ( ( rule__StringLiteral__Group__0 ) ) ; |
| public final void ruleStringLiteral() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1379:2: ( ( ( rule__StringLiteral__Group__0 ) ) ) |
| // InternalFSM.g:1380:1: ( ( rule__StringLiteral__Group__0 ) ) |
| { |
| // InternalFSM.g:1380:1: ( ( rule__StringLiteral__Group__0 ) ) |
| // InternalFSM.g:1381:1: ( rule__StringLiteral__Group__0 ) |
| { |
| before(grammarAccess.getStringLiteralAccess().getGroup()); |
| // InternalFSM.g:1382:1: ( rule__StringLiteral__Group__0 ) |
| // InternalFSM.g:1382:2: rule__StringLiteral__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StringLiteral__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStringLiteralAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleStringLiteral" |
| |
| |
| // $ANTLR start "entryRuleInteger" |
| // InternalFSM.g:1394:1: entryRuleInteger : ruleInteger EOF ; |
| public final void entryRuleInteger() throws RecognitionException { |
| try { |
| // InternalFSM.g:1395:1: ( ruleInteger EOF ) |
| // InternalFSM.g:1396:1: ruleInteger EOF |
| { |
| before(grammarAccess.getIntegerRule()); |
| pushFollow(FOLLOW_1); |
| ruleInteger(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getIntegerRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleInteger" |
| |
| |
| // $ANTLR start "ruleInteger" |
| // InternalFSM.g:1403:1: ruleInteger : ( ( rule__Integer__Alternatives ) ) ; |
| public final void ruleInteger() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1407:2: ( ( ( rule__Integer__Alternatives ) ) ) |
| // InternalFSM.g:1408:1: ( ( rule__Integer__Alternatives ) ) |
| { |
| // InternalFSM.g:1408:1: ( ( rule__Integer__Alternatives ) ) |
| // InternalFSM.g:1409:1: ( rule__Integer__Alternatives ) |
| { |
| before(grammarAccess.getIntegerAccess().getAlternatives()); |
| // InternalFSM.g:1410:1: ( rule__Integer__Alternatives ) |
| // InternalFSM.g:1410:2: rule__Integer__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__Integer__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getIntegerAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleInteger" |
| |
| |
| // $ANTLR start "entryRuleReal" |
| // InternalFSM.g:1422:1: entryRuleReal : ruleReal EOF ; |
| public final void entryRuleReal() throws RecognitionException { |
| try { |
| // InternalFSM.g:1423:1: ( ruleReal EOF ) |
| // InternalFSM.g:1424:1: ruleReal EOF |
| { |
| before(grammarAccess.getRealRule()); |
| pushFollow(FOLLOW_1); |
| ruleReal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRealRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleReal" |
| |
| |
| // $ANTLR start "ruleReal" |
| // InternalFSM.g:1431:1: ruleReal : ( ( rule__Real__Alternatives ) ) ; |
| public final void ruleReal() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1435:2: ( ( ( rule__Real__Alternatives ) ) ) |
| // InternalFSM.g:1436:1: ( ( rule__Real__Alternatives ) ) |
| { |
| // InternalFSM.g:1436:1: ( ( rule__Real__Alternatives ) ) |
| // InternalFSM.g:1437:1: ( rule__Real__Alternatives ) |
| { |
| before(grammarAccess.getRealAccess().getAlternatives()); |
| // InternalFSM.g:1438:1: ( rule__Real__Alternatives ) |
| // InternalFSM.g:1438:2: rule__Real__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__Real__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRealAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleReal" |
| |
| |
| // $ANTLR start "entryRuleDecimal" |
| // InternalFSM.g:1450:1: entryRuleDecimal : ruleDecimal EOF ; |
| public final void entryRuleDecimal() throws RecognitionException { |
| |
| HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
| |
| try { |
| // InternalFSM.g:1454:1: ( ruleDecimal EOF ) |
| // InternalFSM.g:1455:1: ruleDecimal EOF |
| { |
| before(grammarAccess.getDecimalRule()); |
| pushFollow(FOLLOW_1); |
| ruleDecimal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getDecimalRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| myHiddenTokenState.restore(); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDecimal" |
| |
| |
| // $ANTLR start "ruleDecimal" |
| // InternalFSM.g:1465:1: ruleDecimal : ( ( rule__Decimal__Group__0 ) ) ; |
| public final void ruleDecimal() throws RecognitionException { |
| |
| HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1470:2: ( ( ( rule__Decimal__Group__0 ) ) ) |
| // InternalFSM.g:1471:1: ( ( rule__Decimal__Group__0 ) ) |
| { |
| // InternalFSM.g:1471:1: ( ( rule__Decimal__Group__0 ) ) |
| // InternalFSM.g:1472:1: ( rule__Decimal__Group__0 ) |
| { |
| before(grammarAccess.getDecimalAccess().getGroup()); |
| // InternalFSM.g:1473:1: ( rule__Decimal__Group__0 ) |
| // InternalFSM.g:1473:2: rule__Decimal__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Decimal__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getDecimalAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| myHiddenTokenState.restore(); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDecimal" |
| |
| |
| // $ANTLR start "entryRuleDecimalExp" |
| // InternalFSM.g:1486:1: entryRuleDecimalExp : ruleDecimalExp EOF ; |
| public final void entryRuleDecimalExp() throws RecognitionException { |
| |
| HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
| |
| try { |
| // InternalFSM.g:1490:1: ( ruleDecimalExp EOF ) |
| // InternalFSM.g:1491:1: ruleDecimalExp EOF |
| { |
| before(grammarAccess.getDecimalExpRule()); |
| pushFollow(FOLLOW_1); |
| ruleDecimalExp(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getDecimalExpRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| myHiddenTokenState.restore(); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleDecimalExp" |
| |
| |
| // $ANTLR start "ruleDecimalExp" |
| // InternalFSM.g:1501:1: ruleDecimalExp : ( ( rule__DecimalExp__Group__0 ) ) ; |
| public final void ruleDecimalExp() throws RecognitionException { |
| |
| HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1506:2: ( ( ( rule__DecimalExp__Group__0 ) ) ) |
| // InternalFSM.g:1507:1: ( ( rule__DecimalExp__Group__0 ) ) |
| { |
| // InternalFSM.g:1507:1: ( ( rule__DecimalExp__Group__0 ) ) |
| // InternalFSM.g:1508:1: ( rule__DecimalExp__Group__0 ) |
| { |
| before(grammarAccess.getDecimalExpAccess().getGroup()); |
| // InternalFSM.g:1509:1: ( rule__DecimalExp__Group__0 ) |
| // InternalFSM.g:1509:2: rule__DecimalExp__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getDecimalExpAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| myHiddenTokenState.restore(); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleDecimalExp" |
| |
| |
| // $ANTLR start "entryRuleFQN" |
| // InternalFSM.g:1522:1: entryRuleFQN : ruleFQN EOF ; |
| public final void entryRuleFQN() throws RecognitionException { |
| try { |
| // InternalFSM.g:1523:1: ( ruleFQN EOF ) |
| // InternalFSM.g:1524:1: ruleFQN EOF |
| { |
| before(grammarAccess.getFQNRule()); |
| pushFollow(FOLLOW_1); |
| ruleFQN(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getFQNRule()); |
| match(input,EOF,FOLLOW_2); |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| } |
| return ; |
| } |
| // $ANTLR end "entryRuleFQN" |
| |
| |
| // $ANTLR start "ruleFQN" |
| // InternalFSM.g:1531:1: ruleFQN : ( ( rule__FQN__Group__0 ) ) ; |
| public final void ruleFQN() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1535:2: ( ( ( rule__FQN__Group__0 ) ) ) |
| // InternalFSM.g:1536:1: ( ( rule__FQN__Group__0 ) ) |
| { |
| // InternalFSM.g:1536:1: ( ( rule__FQN__Group__0 ) ) |
| // InternalFSM.g:1537:1: ( rule__FQN__Group__0 ) |
| { |
| before(grammarAccess.getFQNAccess().getGroup()); |
| // InternalFSM.g:1538:1: ( rule__FQN__Group__0 ) |
| // InternalFSM.g:1538:2: rule__FQN__Group__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__FQN__Group__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getFQNAccess().getGroup()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleFQN" |
| |
| |
| // $ANTLR start "ruleComponentCommunicationType" |
| // InternalFSM.g:1551:1: ruleComponentCommunicationType : ( ( rule__ComponentCommunicationType__Alternatives ) ) ; |
| public final void ruleComponentCommunicationType() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1555:1: ( ( ( rule__ComponentCommunicationType__Alternatives ) ) ) |
| // InternalFSM.g:1556:1: ( ( rule__ComponentCommunicationType__Alternatives ) ) |
| { |
| // InternalFSM.g:1556:1: ( ( rule__ComponentCommunicationType__Alternatives ) ) |
| // InternalFSM.g:1557:1: ( rule__ComponentCommunicationType__Alternatives ) |
| { |
| before(grammarAccess.getComponentCommunicationTypeAccess().getAlternatives()); |
| // InternalFSM.g:1558:1: ( rule__ComponentCommunicationType__Alternatives ) |
| // InternalFSM.g:1558:2: rule__ComponentCommunicationType__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__ComponentCommunicationType__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getComponentCommunicationTypeAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleComponentCommunicationType" |
| |
| |
| // $ANTLR start "ruleLiteralType" |
| // InternalFSM.g:1570:1: ruleLiteralType : ( ( rule__LiteralType__Alternatives ) ) ; |
| public final void ruleLiteralType() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1574:1: ( ( ( rule__LiteralType__Alternatives ) ) ) |
| // InternalFSM.g:1575:1: ( ( rule__LiteralType__Alternatives ) ) |
| { |
| // InternalFSM.g:1575:1: ( ( rule__LiteralType__Alternatives ) ) |
| // InternalFSM.g:1576:1: ( rule__LiteralType__Alternatives ) |
| { |
| before(grammarAccess.getLiteralTypeAccess().getAlternatives()); |
| // InternalFSM.g:1577:1: ( rule__LiteralType__Alternatives ) |
| // InternalFSM.g:1577:2: rule__LiteralType__Alternatives |
| { |
| pushFollow(FOLLOW_2); |
| rule__LiteralType__Alternatives(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getLiteralTypeAccess().getAlternatives()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "ruleLiteralType" |
| |
| |
| // $ANTLR start "rule__StateGraphNode__Alternatives" |
| // InternalFSM.g:1588:1: rule__StateGraphNode__Alternatives : ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) ); |
| public final void rule__StateGraphNode__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1592:1: ( ( ruleState ) | ( ruleChoicePoint ) | ( ruleTrPoint ) ) |
| int alt2=3; |
| switch ( input.LA(1) ) { |
| case 31: |
| case 36: |
| { |
| alt2=1; |
| } |
| break; |
| case 40: |
| { |
| alt2=2; |
| } |
| break; |
| case 37: |
| case 38: |
| case 39: |
| case 69: |
| { |
| alt2=3; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 2, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt2) { |
| case 1 : |
| // InternalFSM.g:1593:1: ( ruleState ) |
| { |
| // InternalFSM.g:1593:1: ( ruleState ) |
| // InternalFSM.g:1594:1: ruleState |
| { |
| before(grammarAccess.getStateGraphNodeAccess().getStateParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleState(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateGraphNodeAccess().getStateParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1599:6: ( ruleChoicePoint ) |
| { |
| // InternalFSM.g:1599:6: ( ruleChoicePoint ) |
| // InternalFSM.g:1600:1: ruleChoicePoint |
| { |
| before(grammarAccess.getStateGraphNodeAccess().getChoicePointParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleChoicePoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateGraphNodeAccess().getChoicePointParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalFSM.g:1605:6: ( ruleTrPoint ) |
| { |
| // InternalFSM.g:1605:6: ( ruleTrPoint ) |
| // InternalFSM.g:1606:1: ruleTrPoint |
| { |
| before(grammarAccess.getStateGraphNodeAccess().getTrPointParserRuleCall_2()); |
| pushFollow(FOLLOW_2); |
| ruleTrPoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateGraphNodeAccess().getTrPointParserRuleCall_2()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraphNode__Alternatives" |
| |
| |
| // $ANTLR start "rule__StateGraph__Alternatives_2" |
| // InternalFSM.g:1617:1: rule__StateGraph__Alternatives_2 : ( ( ( rule__StateGraph__StatesAssignment_2_0 ) ) | ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) | ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) | ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) | ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) ); |
| public final void rule__StateGraph__Alternatives_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1621:1: ( ( ( rule__StateGraph__StatesAssignment_2_0 ) ) | ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) | ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) | ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) | ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) ) |
| int alt3=5; |
| switch ( input.LA(1) ) { |
| case 31: |
| case 36: |
| { |
| alt3=1; |
| } |
| break; |
| case 37: |
| case 38: |
| case 39: |
| case 69: |
| { |
| alt3=2; |
| } |
| break; |
| case 40: |
| { |
| alt3=3; |
| } |
| break; |
| case 41: |
| { |
| alt3=4; |
| } |
| break; |
| case 50: |
| { |
| alt3=5; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 3, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt3) { |
| case 1 : |
| // InternalFSM.g:1622:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) ) |
| { |
| // InternalFSM.g:1622:1: ( ( rule__StateGraph__StatesAssignment_2_0 ) ) |
| // InternalFSM.g:1623:1: ( rule__StateGraph__StatesAssignment_2_0 ) |
| { |
| before(grammarAccess.getStateGraphAccess().getStatesAssignment_2_0()); |
| // InternalFSM.g:1624:1: ( rule__StateGraph__StatesAssignment_2_0 ) |
| // InternalFSM.g:1624:2: rule__StateGraph__StatesAssignment_2_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateGraph__StatesAssignment_2_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateGraphAccess().getStatesAssignment_2_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1628:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) |
| { |
| // InternalFSM.g:1628:6: ( ( rule__StateGraph__TrPointsAssignment_2_1 ) ) |
| // InternalFSM.g:1629:1: ( rule__StateGraph__TrPointsAssignment_2_1 ) |
| { |
| before(grammarAccess.getStateGraphAccess().getTrPointsAssignment_2_1()); |
| // InternalFSM.g:1630:1: ( rule__StateGraph__TrPointsAssignment_2_1 ) |
| // InternalFSM.g:1630:2: rule__StateGraph__TrPointsAssignment_2_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateGraph__TrPointsAssignment_2_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateGraphAccess().getTrPointsAssignment_2_1()); |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalFSM.g:1634:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) |
| { |
| // InternalFSM.g:1634:6: ( ( rule__StateGraph__ChPointsAssignment_2_2 ) ) |
| // InternalFSM.g:1635:1: ( rule__StateGraph__ChPointsAssignment_2_2 ) |
| { |
| before(grammarAccess.getStateGraphAccess().getChPointsAssignment_2_2()); |
| // InternalFSM.g:1636:1: ( rule__StateGraph__ChPointsAssignment_2_2 ) |
| // InternalFSM.g:1636:2: rule__StateGraph__ChPointsAssignment_2_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateGraph__ChPointsAssignment_2_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateGraphAccess().getChPointsAssignment_2_2()); |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalFSM.g:1640:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) |
| { |
| // InternalFSM.g:1640:6: ( ( rule__StateGraph__TransitionsAssignment_2_3 ) ) |
| // InternalFSM.g:1641:1: ( rule__StateGraph__TransitionsAssignment_2_3 ) |
| { |
| before(grammarAccess.getStateGraphAccess().getTransitionsAssignment_2_3()); |
| // InternalFSM.g:1642:1: ( rule__StateGraph__TransitionsAssignment_2_3 ) |
| // InternalFSM.g:1642:2: rule__StateGraph__TransitionsAssignment_2_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateGraph__TransitionsAssignment_2_3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateGraphAccess().getTransitionsAssignment_2_3()); |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalFSM.g:1646:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) |
| { |
| // InternalFSM.g:1646:6: ( ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) ) |
| // InternalFSM.g:1647:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) |
| { |
| before(grammarAccess.getStateGraphAccess().getRefinedTransitionsAssignment_2_4()); |
| // InternalFSM.g:1648:1: ( rule__StateGraph__RefinedTransitionsAssignment_2_4 ) |
| // InternalFSM.g:1648:2: rule__StateGraph__RefinedTransitionsAssignment_2_4 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateGraph__RefinedTransitionsAssignment_2_4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateGraphAccess().getRefinedTransitionsAssignment_2_4()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__Alternatives_2" |
| |
| |
| // $ANTLR start "rule__StateMachine__Alternatives_3" |
| // InternalFSM.g:1657:1: rule__StateMachine__Alternatives_3 : ( ( ( rule__StateMachine__StatesAssignment_3_0 ) ) | ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) | ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) | ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) | ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) ); |
| public final void rule__StateMachine__Alternatives_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1661:1: ( ( ( rule__StateMachine__StatesAssignment_3_0 ) ) | ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) | ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) | ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) | ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) ) |
| int alt4=5; |
| switch ( input.LA(1) ) { |
| case 31: |
| case 36: |
| { |
| alt4=1; |
| } |
| break; |
| case 37: |
| case 38: |
| case 39: |
| case 69: |
| { |
| alt4=2; |
| } |
| break; |
| case 40: |
| { |
| alt4=3; |
| } |
| break; |
| case 41: |
| { |
| alt4=4; |
| } |
| break; |
| case 50: |
| { |
| alt4=5; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 4, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt4) { |
| case 1 : |
| // InternalFSM.g:1662:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) ) |
| { |
| // InternalFSM.g:1662:1: ( ( rule__StateMachine__StatesAssignment_3_0 ) ) |
| // InternalFSM.g:1663:1: ( rule__StateMachine__StatesAssignment_3_0 ) |
| { |
| before(grammarAccess.getStateMachineAccess().getStatesAssignment_3_0()); |
| // InternalFSM.g:1664:1: ( rule__StateMachine__StatesAssignment_3_0 ) |
| // InternalFSM.g:1664:2: rule__StateMachine__StatesAssignment_3_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__StatesAssignment_3_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateMachineAccess().getStatesAssignment_3_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1668:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) |
| { |
| // InternalFSM.g:1668:6: ( ( rule__StateMachine__TrPointsAssignment_3_1 ) ) |
| // InternalFSM.g:1669:1: ( rule__StateMachine__TrPointsAssignment_3_1 ) |
| { |
| before(grammarAccess.getStateMachineAccess().getTrPointsAssignment_3_1()); |
| // InternalFSM.g:1670:1: ( rule__StateMachine__TrPointsAssignment_3_1 ) |
| // InternalFSM.g:1670:2: rule__StateMachine__TrPointsAssignment_3_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__TrPointsAssignment_3_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateMachineAccess().getTrPointsAssignment_3_1()); |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalFSM.g:1674:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) |
| { |
| // InternalFSM.g:1674:6: ( ( rule__StateMachine__ChPointsAssignment_3_2 ) ) |
| // InternalFSM.g:1675:1: ( rule__StateMachine__ChPointsAssignment_3_2 ) |
| { |
| before(grammarAccess.getStateMachineAccess().getChPointsAssignment_3_2()); |
| // InternalFSM.g:1676:1: ( rule__StateMachine__ChPointsAssignment_3_2 ) |
| // InternalFSM.g:1676:2: rule__StateMachine__ChPointsAssignment_3_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__ChPointsAssignment_3_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateMachineAccess().getChPointsAssignment_3_2()); |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalFSM.g:1680:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) |
| { |
| // InternalFSM.g:1680:6: ( ( rule__StateMachine__TransitionsAssignment_3_3 ) ) |
| // InternalFSM.g:1681:1: ( rule__StateMachine__TransitionsAssignment_3_3 ) |
| { |
| before(grammarAccess.getStateMachineAccess().getTransitionsAssignment_3_3()); |
| // InternalFSM.g:1682:1: ( rule__StateMachine__TransitionsAssignment_3_3 ) |
| // InternalFSM.g:1682:2: rule__StateMachine__TransitionsAssignment_3_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__TransitionsAssignment_3_3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateMachineAccess().getTransitionsAssignment_3_3()); |
| |
| } |
| |
| |
| } |
| break; |
| case 5 : |
| // InternalFSM.g:1686:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) |
| { |
| // InternalFSM.g:1686:6: ( ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) ) |
| // InternalFSM.g:1687:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) |
| { |
| before(grammarAccess.getStateMachineAccess().getRefinedTransitionsAssignment_3_4()); |
| // InternalFSM.g:1688:1: ( rule__StateMachine__RefinedTransitionsAssignment_3_4 ) |
| // InternalFSM.g:1688:2: rule__StateMachine__RefinedTransitionsAssignment_3_4 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__RefinedTransitionsAssignment_3_4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStateMachineAccess().getRefinedTransitionsAssignment_3_4()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Alternatives_3" |
| |
| |
| // $ANTLR start "rule__State__Alternatives" |
| // InternalFSM.g:1697:1: rule__State__Alternatives : ( ( ruleSimpleState ) | ( ruleRefinedState ) ); |
| public final void rule__State__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1701:1: ( ( ruleSimpleState ) | ( ruleRefinedState ) ) |
| int alt5=2; |
| int LA5_0 = input.LA(1); |
| |
| if ( (LA5_0==31) ) { |
| alt5=1; |
| } |
| else if ( (LA5_0==36) ) { |
| alt5=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 5, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt5) { |
| case 1 : |
| // InternalFSM.g:1702:1: ( ruleSimpleState ) |
| { |
| // InternalFSM.g:1702:1: ( ruleSimpleState ) |
| // InternalFSM.g:1703:1: ruleSimpleState |
| { |
| before(grammarAccess.getStateAccess().getSimpleStateParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleSimpleState(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateAccess().getSimpleStateParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1708:6: ( ruleRefinedState ) |
| { |
| // InternalFSM.g:1708:6: ( ruleRefinedState ) |
| // InternalFSM.g:1709:1: ruleRefinedState |
| { |
| before(grammarAccess.getStateAccess().getRefinedStateParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleRefinedState(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateAccess().getRefinedStateParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__State__Alternatives" |
| |
| |
| // $ANTLR start "rule__TrPoint__Alternatives" |
| // InternalFSM.g:1719:1: rule__TrPoint__Alternatives : ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) ); |
| public final void rule__TrPoint__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1723:1: ( ( ruleTransitionPoint ) | ( ruleEntryPoint ) | ( ruleExitPoint ) ) |
| int alt6=3; |
| switch ( input.LA(1) ) { |
| case 37: |
| case 69: |
| { |
| alt6=1; |
| } |
| break; |
| case 38: |
| { |
| alt6=2; |
| } |
| break; |
| case 39: |
| { |
| alt6=3; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 6, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt6) { |
| case 1 : |
| // InternalFSM.g:1724:1: ( ruleTransitionPoint ) |
| { |
| // InternalFSM.g:1724:1: ( ruleTransitionPoint ) |
| // InternalFSM.g:1725:1: ruleTransitionPoint |
| { |
| before(grammarAccess.getTrPointAccess().getTransitionPointParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionPoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTrPointAccess().getTransitionPointParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1730:6: ( ruleEntryPoint ) |
| { |
| // InternalFSM.g:1730:6: ( ruleEntryPoint ) |
| // InternalFSM.g:1731:1: ruleEntryPoint |
| { |
| before(grammarAccess.getTrPointAccess().getEntryPointParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleEntryPoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTrPointAccess().getEntryPointParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalFSM.g:1736:6: ( ruleExitPoint ) |
| { |
| // InternalFSM.g:1736:6: ( ruleExitPoint ) |
| // InternalFSM.g:1737:1: ruleExitPoint |
| { |
| before(grammarAccess.getTrPointAccess().getExitPointParserRuleCall_2()); |
| pushFollow(FOLLOW_2); |
| ruleExitPoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTrPointAccess().getExitPointParserRuleCall_2()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TrPoint__Alternatives" |
| |
| |
| // $ANTLR start "rule__Transition__Alternatives" |
| // InternalFSM.g:1748:1: rule__Transition__Alternatives : ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) ); |
| public final void rule__Transition__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1752:1: ( ( ruleInitialTransition ) | ( ruleNonInitialTransition ) ) |
| int alt7=2; |
| int LA7_0 = input.LA(1); |
| |
| if ( (LA7_0==41) ) { |
| int LA7_1 = input.LA(2); |
| |
| if ( (LA7_1==RULE_ID) ) { |
| int LA7_2 = input.LA(3); |
| |
| if ( (LA7_2==42) ) { |
| int LA7_3 = input.LA(4); |
| |
| if ( (LA7_3==RULE_ID||LA7_3==51||LA7_3==53) ) { |
| alt7=2; |
| } |
| else if ( (LA7_3==43) ) { |
| alt7=1; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 7, 3, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 7, 2, input); |
| |
| throw nvae; |
| } |
| } |
| else if ( (LA7_1==42) ) { |
| int LA7_3 = input.LA(3); |
| |
| if ( (LA7_3==RULE_ID||LA7_3==51||LA7_3==53) ) { |
| alt7=2; |
| } |
| else if ( (LA7_3==43) ) { |
| alt7=1; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 7, 3, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 7, 1, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 7, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt7) { |
| case 1 : |
| // InternalFSM.g:1753:1: ( ruleInitialTransition ) |
| { |
| // InternalFSM.g:1753:1: ( ruleInitialTransition ) |
| // InternalFSM.g:1754:1: ruleInitialTransition |
| { |
| before(grammarAccess.getTransitionAccess().getInitialTransitionParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleInitialTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionAccess().getInitialTransitionParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1759:6: ( ruleNonInitialTransition ) |
| { |
| // InternalFSM.g:1759:6: ( ruleNonInitialTransition ) |
| // InternalFSM.g:1760:1: ruleNonInitialTransition |
| { |
| before(grammarAccess.getTransitionAccess().getNonInitialTransitionParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleNonInitialTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionAccess().getNonInitialTransitionParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Transition__Alternatives" |
| |
| |
| // $ANTLR start "rule__NonInitialTransition__Alternatives" |
| // InternalFSM.g:1770:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) ); |
| public final void rule__NonInitialTransition__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1774:1: ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) ) |
| int alt8=3; |
| alt8 = dfa8.predict(input); |
| switch (alt8) { |
| case 1 : |
| // InternalFSM.g:1775:1: ( ruleTransitionChainStartTransition ) |
| { |
| // InternalFSM.g:1775:1: ( ruleTransitionChainStartTransition ) |
| // InternalFSM.g:1776:1: ruleTransitionChainStartTransition |
| { |
| before(grammarAccess.getNonInitialTransitionAccess().getTransitionChainStartTransitionParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionChainStartTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getNonInitialTransitionAccess().getTransitionChainStartTransitionParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1781:6: ( ruleContinuationTransition ) |
| { |
| // InternalFSM.g:1781:6: ( ruleContinuationTransition ) |
| // InternalFSM.g:1782:1: ruleContinuationTransition |
| { |
| before(grammarAccess.getNonInitialTransitionAccess().getContinuationTransitionParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleContinuationTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getNonInitialTransitionAccess().getContinuationTransitionParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalFSM.g:1787:6: ( ruleCPBranchTransition ) |
| { |
| // InternalFSM.g:1787:6: ( ruleCPBranchTransition ) |
| // InternalFSM.g:1788:1: ruleCPBranchTransition |
| { |
| before(grammarAccess.getNonInitialTransitionAccess().getCPBranchTransitionParserRuleCall_2()); |
| pushFollow(FOLLOW_2); |
| ruleCPBranchTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getNonInitialTransitionAccess().getCPBranchTransitionParserRuleCall_2()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NonInitialTransition__Alternatives" |
| |
| |
| // $ANTLR start "rule__TransitionChainStartTransition__Alternatives" |
| // InternalFSM.g:1798:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) ); |
| public final void rule__TransitionChainStartTransition__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1802:1: ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) ) |
| int alt9=2; |
| alt9 = dfa9.predict(input); |
| switch (alt9) { |
| case 1 : |
| // InternalFSM.g:1803:1: ( ruleTriggeredTransition ) |
| { |
| // InternalFSM.g:1803:1: ( ruleTriggeredTransition ) |
| // InternalFSM.g:1804:1: ruleTriggeredTransition |
| { |
| before(grammarAccess.getTransitionChainStartTransitionAccess().getTriggeredTransitionParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleTriggeredTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionChainStartTransitionAccess().getTriggeredTransitionParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1809:6: ( ruleGuardedTransition ) |
| { |
| // InternalFSM.g:1809:6: ( ruleGuardedTransition ) |
| // InternalFSM.g:1810:1: ruleGuardedTransition |
| { |
| before(grammarAccess.getTransitionChainStartTransitionAccess().getGuardedTransitionParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleGuardedTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionChainStartTransitionAccess().getGuardedTransitionParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TransitionChainStartTransition__Alternatives" |
| |
| |
| // $ANTLR start "rule__TransitionTerminal__Alternatives" |
| // InternalFSM.g:1820:1: rule__TransitionTerminal__Alternatives : ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) ); |
| public final void rule__TransitionTerminal__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1824:1: ( ( ruleStateTerminal ) | ( ruleTrPointTerminal ) | ( ruleSubStateTrPointTerminal ) | ( ruleChoicepointTerminal ) ) |
| int alt10=4; |
| switch ( input.LA(1) ) { |
| case RULE_ID: |
| { |
| int LA10_1 = input.LA(2); |
| |
| if ( (LA10_1==52) ) { |
| alt10=3; |
| } |
| else if ( (LA10_1==EOF||(LA10_1>=28 && LA10_1<=29)||LA10_1==31||(LA10_1>=36 && LA10_1<=41)||LA10_1==44||LA10_1==50||LA10_1==65||LA10_1==69) ) { |
| alt10=1; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 10, 1, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 51: |
| { |
| alt10=2; |
| } |
| break; |
| case 53: |
| { |
| alt10=4; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 10, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt10) { |
| case 1 : |
| // InternalFSM.g:1825:1: ( ruleStateTerminal ) |
| { |
| // InternalFSM.g:1825:1: ( ruleStateTerminal ) |
| // InternalFSM.g:1826:1: ruleStateTerminal |
| { |
| before(grammarAccess.getTransitionTerminalAccess().getStateTerminalParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleStateTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionTerminalAccess().getStateTerminalParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1831:6: ( ruleTrPointTerminal ) |
| { |
| // InternalFSM.g:1831:6: ( ruleTrPointTerminal ) |
| // InternalFSM.g:1832:1: ruleTrPointTerminal |
| { |
| before(grammarAccess.getTransitionTerminalAccess().getTrPointTerminalParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleTrPointTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionTerminalAccess().getTrPointTerminalParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalFSM.g:1837:6: ( ruleSubStateTrPointTerminal ) |
| { |
| // InternalFSM.g:1837:6: ( ruleSubStateTrPointTerminal ) |
| // InternalFSM.g:1838:1: ruleSubStateTrPointTerminal |
| { |
| before(grammarAccess.getTransitionTerminalAccess().getSubStateTrPointTerminalParserRuleCall_2()); |
| pushFollow(FOLLOW_2); |
| ruleSubStateTrPointTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionTerminalAccess().getSubStateTrPointTerminalParserRuleCall_2()); |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalFSM.g:1843:6: ( ruleChoicepointTerminal ) |
| { |
| // InternalFSM.g:1843:6: ( ruleChoicepointTerminal ) |
| // InternalFSM.g:1844:1: ruleChoicepointTerminal |
| { |
| before(grammarAccess.getTransitionTerminalAccess().getChoicepointTerminalParserRuleCall_3()); |
| pushFollow(FOLLOW_2); |
| ruleChoicepointTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTransitionTerminalAccess().getChoicepointTerminalParserRuleCall_3()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TransitionTerminal__Alternatives" |
| |
| |
| // $ANTLR start "rule__SemanticsRule__Alternatives" |
| // InternalFSM.g:1854:1: rule__SemanticsRule__Alternatives : ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) ); |
| public final void rule__SemanticsRule__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1858:1: ( ( ruleInSemanticsRule ) | ( ruleOutSemanticsRule ) ) |
| int alt11=2; |
| int LA11_0 = input.LA(1); |
| |
| if ( (LA11_0==57) ) { |
| alt11=1; |
| } |
| else if ( (LA11_0==61) ) { |
| alt11=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 11, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt11) { |
| case 1 : |
| // InternalFSM.g:1859:1: ( ruleInSemanticsRule ) |
| { |
| // InternalFSM.g:1859:1: ( ruleInSemanticsRule ) |
| // InternalFSM.g:1860:1: ruleInSemanticsRule |
| { |
| before(grammarAccess.getSemanticsRuleAccess().getInSemanticsRuleParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleInSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSemanticsRuleAccess().getInSemanticsRuleParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1865:6: ( ruleOutSemanticsRule ) |
| { |
| // InternalFSM.g:1865:6: ( ruleOutSemanticsRule ) |
| // InternalFSM.g:1866:1: ruleOutSemanticsRule |
| { |
| before(grammarAccess.getSemanticsRuleAccess().getOutSemanticsRuleParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleOutSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSemanticsRuleAccess().getOutSemanticsRuleParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SemanticsRule__Alternatives" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Alternatives_3_1" |
| // InternalFSM.g:1876:1: rule__InSemanticsRule__Alternatives_3_1 : ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) ); |
| public final void rule__InSemanticsRule__Alternatives_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1880:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) ) |
| int alt12=2; |
| int LA12_0 = input.LA(1); |
| |
| if ( (LA12_0==57||LA12_0==61) ) { |
| alt12=1; |
| } |
| else if ( (LA12_0==58) ) { |
| alt12=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 12, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt12) { |
| case 1 : |
| // InternalFSM.g:1881:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) |
| { |
| // InternalFSM.g:1881:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) ) |
| // InternalFSM.g:1882:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); |
| // InternalFSM.g:1883:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_0 ) |
| // InternalFSM.g:1883:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__FollowUpsAssignment_3_1_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1887:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) |
| { |
| // InternalFSM.g:1887:6: ( ( rule__InSemanticsRule__Group_3_1_1__0 ) ) |
| // InternalFSM.g:1888:1: ( rule__InSemanticsRule__Group_3_1_1__0 ) |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1()); |
| // InternalFSM.g:1889:1: ( rule__InSemanticsRule__Group_3_1_1__0 ) |
| // InternalFSM.g:1889:2: rule__InSemanticsRule__Group_3_1_1__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group_3_1_1__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Alternatives_3_1" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Alternatives_3_1" |
| // InternalFSM.g:1898:1: rule__OutSemanticsRule__Alternatives_3_1 : ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) ); |
| public final void rule__OutSemanticsRule__Alternatives_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1902:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) | ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) ) |
| int alt13=2; |
| int LA13_0 = input.LA(1); |
| |
| if ( (LA13_0==57||LA13_0==61) ) { |
| alt13=1; |
| } |
| else if ( (LA13_0==58) ) { |
| alt13=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 13, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt13) { |
| case 1 : |
| // InternalFSM.g:1903:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) |
| { |
| // InternalFSM.g:1903:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) ) |
| // InternalFSM.g:1904:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); |
| // InternalFSM.g:1905:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 ) |
| // InternalFSM.g:1905:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__FollowUpsAssignment_3_1_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1909:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) |
| { |
| // InternalFSM.g:1909:6: ( ( rule__OutSemanticsRule__Group_3_1_1__0 ) ) |
| // InternalFSM.g:1910:1: ( rule__OutSemanticsRule__Group_3_1_1__0 ) |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1()); |
| // InternalFSM.g:1911:1: ( rule__OutSemanticsRule__Group_3_1_1__0 ) |
| // InternalFSM.g:1911:2: rule__OutSemanticsRule__Group_3_1_1__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group_3_1_1__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Alternatives_3_1" |
| |
| |
| // $ANTLR start "rule__AnnotationAttribute__Alternatives" |
| // InternalFSM.g:1921:1: rule__AnnotationAttribute__Alternatives : ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) ); |
| public final void rule__AnnotationAttribute__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1925:1: ( ( ruleSimpleAnnotationAttribute ) | ( ruleEnumAnnotationAttribute ) ) |
| int alt14=2; |
| int LA14_0 = input.LA(1); |
| |
| if ( (LA14_0==70) ) { |
| int LA14_1 = input.LA(2); |
| |
| if ( (LA14_1==63) ) { |
| int LA14_3 = input.LA(3); |
| |
| if ( (LA14_3==RULE_ID) ) { |
| int LA14_4 = input.LA(4); |
| |
| if ( (LA14_4==42) ) { |
| int LA14_5 = input.LA(5); |
| |
| if ( ((LA14_5>=22 && LA14_5<=25)) ) { |
| alt14=1; |
| } |
| else if ( (LA14_5==28) ) { |
| alt14=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 5, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 4, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 3, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 1, input); |
| |
| throw nvae; |
| } |
| } |
| else if ( (LA14_0==12) ) { |
| int LA14_2 = input.LA(2); |
| |
| if ( (LA14_2==63) ) { |
| int LA14_3 = input.LA(3); |
| |
| if ( (LA14_3==RULE_ID) ) { |
| int LA14_4 = input.LA(4); |
| |
| if ( (LA14_4==42) ) { |
| int LA14_5 = input.LA(5); |
| |
| if ( ((LA14_5>=22 && LA14_5<=25)) ) { |
| alt14=1; |
| } |
| else if ( (LA14_5==28) ) { |
| alt14=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 5, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 4, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 3, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 2, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 14, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt14) { |
| case 1 : |
| // InternalFSM.g:1926:1: ( ruleSimpleAnnotationAttribute ) |
| { |
| // InternalFSM.g:1926:1: ( ruleSimpleAnnotationAttribute ) |
| // InternalFSM.g:1927:1: ruleSimpleAnnotationAttribute |
| { |
| before(grammarAccess.getAnnotationAttributeAccess().getSimpleAnnotationAttributeParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleSimpleAnnotationAttribute(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getAnnotationAttributeAccess().getSimpleAnnotationAttributeParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1932:6: ( ruleEnumAnnotationAttribute ) |
| { |
| // InternalFSM.g:1932:6: ( ruleEnumAnnotationAttribute ) |
| // InternalFSM.g:1933:1: ruleEnumAnnotationAttribute |
| { |
| before(grammarAccess.getAnnotationAttributeAccess().getEnumAnnotationAttributeParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleEnumAnnotationAttribute(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getAnnotationAttributeAccess().getEnumAnnotationAttributeParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__AnnotationAttribute__Alternatives" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Alternatives_0" |
| // InternalFSM.g:1943:1: rule__SimpleAnnotationAttribute__Alternatives_0 : ( ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) ); |
| public final void rule__SimpleAnnotationAttribute__Alternatives_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1947:1: ( ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) ) |
| int alt15=2; |
| int LA15_0 = input.LA(1); |
| |
| if ( (LA15_0==70) ) { |
| alt15=1; |
| } |
| else if ( (LA15_0==12) ) { |
| alt15=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 15, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt15) { |
| case 1 : |
| // InternalFSM.g:1948:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) |
| { |
| // InternalFSM.g:1948:1: ( ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) ) |
| // InternalFSM.g:1949:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalAssignment_0_0()); |
| // InternalFSM.g:1950:1: ( rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 ) |
| // InternalFSM.g:1950:2: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleAnnotationAttribute__OptionalAssignment_0_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalAssignment_0_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1954:6: ( 'mandatory' ) |
| { |
| // InternalFSM.g:1954:6: ( 'mandatory' ) |
| // InternalFSM.g:1955:1: 'mandatory' |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getMandatoryKeyword_0_1()); |
| match(input,12,FOLLOW_2); |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getMandatoryKeyword_0_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Alternatives_0" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Alternatives_0" |
| // InternalFSM.g:1967:1: rule__EnumAnnotationAttribute__Alternatives_0 : ( ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) ); |
| public final void rule__EnumAnnotationAttribute__Alternatives_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1971:1: ( ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) | ( 'mandatory' ) ) |
| int alt16=2; |
| int LA16_0 = input.LA(1); |
| |
| if ( (LA16_0==70) ) { |
| alt16=1; |
| } |
| else if ( (LA16_0==12) ) { |
| alt16=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 16, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt16) { |
| case 1 : |
| // InternalFSM.g:1972:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) |
| { |
| // InternalFSM.g:1972:1: ( ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) ) |
| // InternalFSM.g:1973:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalAssignment_0_0()); |
| // InternalFSM.g:1974:1: ( rule__EnumAnnotationAttribute__OptionalAssignment_0_0 ) |
| // InternalFSM.g:1974:2: rule__EnumAnnotationAttribute__OptionalAssignment_0_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__OptionalAssignment_0_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalAssignment_0_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:1978:6: ( 'mandatory' ) |
| { |
| // InternalFSM.g:1978:6: ( 'mandatory' ) |
| // InternalFSM.g:1979:1: 'mandatory' |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getMandatoryKeyword_0_1()); |
| match(input,12,FOLLOW_2); |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getMandatoryKeyword_0_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Alternatives_0" |
| |
| |
| // $ANTLR start "rule__Literal__Alternatives" |
| // InternalFSM.g:1993:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) ); |
| public final void rule__Literal__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:1997:1: ( ( ruleBooleanLiteral ) | ( ruleNumberLiteral ) | ( ruleStringLiteral ) ) |
| int alt17=3; |
| switch ( input.LA(1) ) { |
| case 13: |
| case 71: |
| { |
| alt17=1; |
| } |
| break; |
| case RULE_HEX: |
| case RULE_INT: |
| case 14: |
| case 15: |
| { |
| alt17=2; |
| } |
| break; |
| case RULE_STRING: |
| { |
| alt17=3; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 17, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt17) { |
| case 1 : |
| // InternalFSM.g:1998:1: ( ruleBooleanLiteral ) |
| { |
| // InternalFSM.g:1998:1: ( ruleBooleanLiteral ) |
| // InternalFSM.g:1999:1: ruleBooleanLiteral |
| { |
| before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleBooleanLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2004:6: ( ruleNumberLiteral ) |
| { |
| // InternalFSM.g:2004:6: ( ruleNumberLiteral ) |
| // InternalFSM.g:2005:1: ruleNumberLiteral |
| { |
| before(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleNumberLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalFSM.g:2010:6: ( ruleStringLiteral ) |
| { |
| // InternalFSM.g:2010:6: ( ruleStringLiteral ) |
| // InternalFSM.g:2011:1: ruleStringLiteral |
| { |
| before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); |
| pushFollow(FOLLOW_2); |
| ruleStringLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Literal__Alternatives" |
| |
| |
| // $ANTLR start "rule__BooleanLiteral__Alternatives_1" |
| // InternalFSM.g:2021:1: rule__BooleanLiteral__Alternatives_1 : ( ( 'false' ) | ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) ); |
| public final void rule__BooleanLiteral__Alternatives_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2025:1: ( ( 'false' ) | ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) ) |
| int alt18=2; |
| int LA18_0 = input.LA(1); |
| |
| if ( (LA18_0==13) ) { |
| alt18=1; |
| } |
| else if ( (LA18_0==71) ) { |
| alt18=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 18, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt18) { |
| case 1 : |
| // InternalFSM.g:2026:1: ( 'false' ) |
| { |
| // InternalFSM.g:2026:1: ( 'false' ) |
| // InternalFSM.g:2027:1: 'false' |
| { |
| before(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_0()); |
| match(input,13,FOLLOW_2); |
| after(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2034:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) |
| { |
| // InternalFSM.g:2034:6: ( ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) ) |
| // InternalFSM.g:2035:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) |
| { |
| before(grammarAccess.getBooleanLiteralAccess().getIsTrueAssignment_1_1()); |
| // InternalFSM.g:2036:1: ( rule__BooleanLiteral__IsTrueAssignment_1_1 ) |
| // InternalFSM.g:2036:2: rule__BooleanLiteral__IsTrueAssignment_1_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__BooleanLiteral__IsTrueAssignment_1_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getBooleanLiteralAccess().getIsTrueAssignment_1_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__BooleanLiteral__Alternatives_1" |
| |
| |
| // $ANTLR start "rule__NumberLiteral__Alternatives" |
| // InternalFSM.g:2045:1: rule__NumberLiteral__Alternatives : ( ( ruleIntLiteral ) | ( ruleRealLiteral ) ); |
| public final void rule__NumberLiteral__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2049:1: ( ( ruleIntLiteral ) | ( ruleRealLiteral ) ) |
| int alt19=2; |
| switch ( input.LA(1) ) { |
| case 14: |
| { |
| int LA19_1 = input.LA(2); |
| |
| if ( (LA19_1==RULE_INT) ) { |
| int LA19_3 = input.LA(3); |
| |
| if ( (LA19_3==EOF) ) { |
| alt19=1; |
| } |
| else if ( (LA19_3==67) ) { |
| alt19=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 19, 3, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 19, 1, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 15: |
| { |
| int LA19_2 = input.LA(2); |
| |
| if ( (LA19_2==RULE_INT) ) { |
| int LA19_3 = input.LA(3); |
| |
| if ( (LA19_3==EOF) ) { |
| alt19=1; |
| } |
| else if ( (LA19_3==67) ) { |
| alt19=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 19, 3, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 19, 2, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case RULE_INT: |
| { |
| int LA19_3 = input.LA(2); |
| |
| if ( (LA19_3==EOF) ) { |
| alt19=1; |
| } |
| else if ( (LA19_3==67) ) { |
| alt19=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 19, 3, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case RULE_HEX: |
| { |
| alt19=1; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 19, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt19) { |
| case 1 : |
| // InternalFSM.g:2050:1: ( ruleIntLiteral ) |
| { |
| // InternalFSM.g:2050:1: ( ruleIntLiteral ) |
| // InternalFSM.g:2051:1: ruleIntLiteral |
| { |
| before(grammarAccess.getNumberLiteralAccess().getIntLiteralParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleIntLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getNumberLiteralAccess().getIntLiteralParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2056:6: ( ruleRealLiteral ) |
| { |
| // InternalFSM.g:2056:6: ( ruleRealLiteral ) |
| // InternalFSM.g:2057:1: ruleRealLiteral |
| { |
| before(grammarAccess.getNumberLiteralAccess().getRealLiteralParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleRealLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getNumberLiteralAccess().getRealLiteralParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__NumberLiteral__Alternatives" |
| |
| |
| // $ANTLR start "rule__Integer__Alternatives" |
| // InternalFSM.g:2067:1: rule__Integer__Alternatives : ( ( ( rule__Integer__Group_0__0 ) ) | ( RULE_HEX ) ); |
| public final void rule__Integer__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2071:1: ( ( ( rule__Integer__Group_0__0 ) ) | ( RULE_HEX ) ) |
| int alt20=2; |
| int LA20_0 = input.LA(1); |
| |
| if ( (LA20_0==RULE_INT||(LA20_0>=14 && LA20_0<=15)) ) { |
| alt20=1; |
| } |
| else if ( (LA20_0==RULE_HEX) ) { |
| alt20=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 20, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt20) { |
| case 1 : |
| // InternalFSM.g:2072:1: ( ( rule__Integer__Group_0__0 ) ) |
| { |
| // InternalFSM.g:2072:1: ( ( rule__Integer__Group_0__0 ) ) |
| // InternalFSM.g:2073:1: ( rule__Integer__Group_0__0 ) |
| { |
| before(grammarAccess.getIntegerAccess().getGroup_0()); |
| // InternalFSM.g:2074:1: ( rule__Integer__Group_0__0 ) |
| // InternalFSM.g:2074:2: rule__Integer__Group_0__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Integer__Group_0__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getIntegerAccess().getGroup_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2078:6: ( RULE_HEX ) |
| { |
| // InternalFSM.g:2078:6: ( RULE_HEX ) |
| // InternalFSM.g:2079:1: RULE_HEX |
| { |
| before(grammarAccess.getIntegerAccess().getHEXTerminalRuleCall_1()); |
| match(input,RULE_HEX,FOLLOW_2); |
| after(grammarAccess.getIntegerAccess().getHEXTerminalRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Integer__Alternatives" |
| |
| |
| // $ANTLR start "rule__Integer__Alternatives_0_0" |
| // InternalFSM.g:2089:1: rule__Integer__Alternatives_0_0 : ( ( '+' ) | ( '-' ) ); |
| public final void rule__Integer__Alternatives_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2093:1: ( ( '+' ) | ( '-' ) ) |
| int alt21=2; |
| int LA21_0 = input.LA(1); |
| |
| if ( (LA21_0==14) ) { |
| alt21=1; |
| } |
| else if ( (LA21_0==15) ) { |
| alt21=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 21, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt21) { |
| case 1 : |
| // InternalFSM.g:2094:1: ( '+' ) |
| { |
| // InternalFSM.g:2094:1: ( '+' ) |
| // InternalFSM.g:2095:1: '+' |
| { |
| before(grammarAccess.getIntegerAccess().getPlusSignKeyword_0_0_0()); |
| match(input,14,FOLLOW_2); |
| after(grammarAccess.getIntegerAccess().getPlusSignKeyword_0_0_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2102:6: ( '-' ) |
| { |
| // InternalFSM.g:2102:6: ( '-' ) |
| // InternalFSM.g:2103:1: '-' |
| { |
| before(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0_0_1()); |
| match(input,15,FOLLOW_2); |
| after(grammarAccess.getIntegerAccess().getHyphenMinusKeyword_0_0_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Integer__Alternatives_0_0" |
| |
| |
| // $ANTLR start "rule__Real__Alternatives" |
| // InternalFSM.g:2115:1: rule__Real__Alternatives : ( ( ruleDecimal ) | ( ruleDecimalExp ) ); |
| public final void rule__Real__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2119:1: ( ( ruleDecimal ) | ( ruleDecimalExp ) ) |
| int alt22=2; |
| switch ( input.LA(1) ) { |
| case 14: |
| { |
| int LA22_1 = input.LA(2); |
| |
| if ( (LA22_1==RULE_INT) ) { |
| int LA22_3 = input.LA(3); |
| |
| if ( (LA22_3==67) ) { |
| int LA22_4 = input.LA(4); |
| |
| if ( (LA22_4==RULE_INT) ) { |
| int LA22_5 = input.LA(5); |
| |
| if ( (LA22_5==EOF) ) { |
| alt22=1; |
| } |
| else if ( ((LA22_5>=16 && LA22_5<=17)) ) { |
| alt22=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 5, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 4, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 3, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 1, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case 15: |
| { |
| int LA22_2 = input.LA(2); |
| |
| if ( (LA22_2==RULE_INT) ) { |
| int LA22_3 = input.LA(3); |
| |
| if ( (LA22_3==67) ) { |
| int LA22_4 = input.LA(4); |
| |
| if ( (LA22_4==RULE_INT) ) { |
| int LA22_5 = input.LA(5); |
| |
| if ( (LA22_5==EOF) ) { |
| alt22=1; |
| } |
| else if ( ((LA22_5>=16 && LA22_5<=17)) ) { |
| alt22=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 5, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 4, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 3, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 2, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| case RULE_INT: |
| { |
| int LA22_3 = input.LA(2); |
| |
| if ( (LA22_3==67) ) { |
| int LA22_4 = input.LA(3); |
| |
| if ( (LA22_4==RULE_INT) ) { |
| int LA22_5 = input.LA(4); |
| |
| if ( (LA22_5==EOF) ) { |
| alt22=1; |
| } |
| else if ( ((LA22_5>=16 && LA22_5<=17)) ) { |
| alt22=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 5, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 4, input); |
| |
| throw nvae; |
| } |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 3, input); |
| |
| throw nvae; |
| } |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 22, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt22) { |
| case 1 : |
| // InternalFSM.g:2120:1: ( ruleDecimal ) |
| { |
| // InternalFSM.g:2120:1: ( ruleDecimal ) |
| // InternalFSM.g:2121:1: ruleDecimal |
| { |
| before(grammarAccess.getRealAccess().getDecimalParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleDecimal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRealAccess().getDecimalParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2126:6: ( ruleDecimalExp ) |
| { |
| // InternalFSM.g:2126:6: ( ruleDecimalExp ) |
| // InternalFSM.g:2127:1: ruleDecimalExp |
| { |
| before(grammarAccess.getRealAccess().getDecimalExpParserRuleCall_1()); |
| pushFollow(FOLLOW_2); |
| ruleDecimalExp(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRealAccess().getDecimalExpParserRuleCall_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Real__Alternatives" |
| |
| |
| // $ANTLR start "rule__Decimal__Alternatives_0" |
| // InternalFSM.g:2137:1: rule__Decimal__Alternatives_0 : ( ( '+' ) | ( '-' ) ); |
| public final void rule__Decimal__Alternatives_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2141:1: ( ( '+' ) | ( '-' ) ) |
| int alt23=2; |
| int LA23_0 = input.LA(1); |
| |
| if ( (LA23_0==14) ) { |
| alt23=1; |
| } |
| else if ( (LA23_0==15) ) { |
| alt23=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 23, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt23) { |
| case 1 : |
| // InternalFSM.g:2142:1: ( '+' ) |
| { |
| // InternalFSM.g:2142:1: ( '+' ) |
| // InternalFSM.g:2143:1: '+' |
| { |
| before(grammarAccess.getDecimalAccess().getPlusSignKeyword_0_0()); |
| match(input,14,FOLLOW_2); |
| after(grammarAccess.getDecimalAccess().getPlusSignKeyword_0_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2150:6: ( '-' ) |
| { |
| // InternalFSM.g:2150:6: ( '-' ) |
| // InternalFSM.g:2151:1: '-' |
| { |
| before(grammarAccess.getDecimalAccess().getHyphenMinusKeyword_0_1()); |
| match(input,15,FOLLOW_2); |
| after(grammarAccess.getDecimalAccess().getHyphenMinusKeyword_0_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Decimal__Alternatives_0" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Alternatives_0" |
| // InternalFSM.g:2163:1: rule__DecimalExp__Alternatives_0 : ( ( '+' ) | ( '-' ) ); |
| public final void rule__DecimalExp__Alternatives_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2167:1: ( ( '+' ) | ( '-' ) ) |
| int alt24=2; |
| int LA24_0 = input.LA(1); |
| |
| if ( (LA24_0==14) ) { |
| alt24=1; |
| } |
| else if ( (LA24_0==15) ) { |
| alt24=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 24, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt24) { |
| case 1 : |
| // InternalFSM.g:2168:1: ( '+' ) |
| { |
| // InternalFSM.g:2168:1: ( '+' ) |
| // InternalFSM.g:2169:1: '+' |
| { |
| before(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_0_0()); |
| match(input,14,FOLLOW_2); |
| after(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_0_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2176:6: ( '-' ) |
| { |
| // InternalFSM.g:2176:6: ( '-' ) |
| // InternalFSM.g:2177:1: '-' |
| { |
| before(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_0_1()); |
| match(input,15,FOLLOW_2); |
| after(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_0_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Alternatives_0" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Alternatives_4" |
| // InternalFSM.g:2189:1: rule__DecimalExp__Alternatives_4 : ( ( 'e' ) | ( 'E' ) ); |
| public final void rule__DecimalExp__Alternatives_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2193:1: ( ( 'e' ) | ( 'E' ) ) |
| int alt25=2; |
| int LA25_0 = input.LA(1); |
| |
| if ( (LA25_0==16) ) { |
| alt25=1; |
| } |
| else if ( (LA25_0==17) ) { |
| alt25=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 25, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt25) { |
| case 1 : |
| // InternalFSM.g:2194:1: ( 'e' ) |
| { |
| // InternalFSM.g:2194:1: ( 'e' ) |
| // InternalFSM.g:2195:1: 'e' |
| { |
| before(grammarAccess.getDecimalExpAccess().getEKeyword_4_0()); |
| match(input,16,FOLLOW_2); |
| after(grammarAccess.getDecimalExpAccess().getEKeyword_4_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2202:6: ( 'E' ) |
| { |
| // InternalFSM.g:2202:6: ( 'E' ) |
| // InternalFSM.g:2203:1: 'E' |
| { |
| before(grammarAccess.getDecimalExpAccess().getEKeyword_4_1()); |
| match(input,17,FOLLOW_2); |
| after(grammarAccess.getDecimalExpAccess().getEKeyword_4_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Alternatives_4" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Alternatives_5" |
| // InternalFSM.g:2215:1: rule__DecimalExp__Alternatives_5 : ( ( '+' ) | ( '-' ) ); |
| public final void rule__DecimalExp__Alternatives_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2219:1: ( ( '+' ) | ( '-' ) ) |
| int alt26=2; |
| int LA26_0 = input.LA(1); |
| |
| if ( (LA26_0==14) ) { |
| alt26=1; |
| } |
| else if ( (LA26_0==15) ) { |
| alt26=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 26, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt26) { |
| case 1 : |
| // InternalFSM.g:2220:1: ( '+' ) |
| { |
| // InternalFSM.g:2220:1: ( '+' ) |
| // InternalFSM.g:2221:1: '+' |
| { |
| before(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_5_0()); |
| match(input,14,FOLLOW_2); |
| after(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_5_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2228:6: ( '-' ) |
| { |
| // InternalFSM.g:2228:6: ( '-' ) |
| // InternalFSM.g:2229:1: '-' |
| { |
| before(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_5_1()); |
| match(input,15,FOLLOW_2); |
| after(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_5_1()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Alternatives_5" |
| |
| |
| // $ANTLR start "rule__ComponentCommunicationType__Alternatives" |
| // InternalFSM.g:2241:1: rule__ComponentCommunicationType__Alternatives : ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) ); |
| public final void rule__ComponentCommunicationType__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2245:1: ( ( ( 'eventdriven' ) ) | ( ( 'datadriven' ) ) | ( ( 'async' ) ) | ( ( 'sync' ) ) ) |
| int alt27=4; |
| switch ( input.LA(1) ) { |
| case 18: |
| { |
| alt27=1; |
| } |
| break; |
| case 19: |
| { |
| alt27=2; |
| } |
| break; |
| case 20: |
| { |
| alt27=3; |
| } |
| break; |
| case 21: |
| { |
| alt27=4; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 27, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt27) { |
| case 1 : |
| // InternalFSM.g:2246:1: ( ( 'eventdriven' ) ) |
| { |
| // InternalFSM.g:2246:1: ( ( 'eventdriven' ) ) |
| // InternalFSM.g:2247:1: ( 'eventdriven' ) |
| { |
| before(grammarAccess.getComponentCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); |
| // InternalFSM.g:2248:1: ( 'eventdriven' ) |
| // InternalFSM.g:2248:3: 'eventdriven' |
| { |
| match(input,18,FOLLOW_2); |
| |
| } |
| |
| after(grammarAccess.getComponentCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2253:6: ( ( 'datadriven' ) ) |
| { |
| // InternalFSM.g:2253:6: ( ( 'datadriven' ) ) |
| // InternalFSM.g:2254:1: ( 'datadriven' ) |
| { |
| before(grammarAccess.getComponentCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); |
| // InternalFSM.g:2255:1: ( 'datadriven' ) |
| // InternalFSM.g:2255:3: 'datadriven' |
| { |
| match(input,19,FOLLOW_2); |
| |
| } |
| |
| after(grammarAccess.getComponentCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalFSM.g:2260:6: ( ( 'async' ) ) |
| { |
| // InternalFSM.g:2260:6: ( ( 'async' ) ) |
| // InternalFSM.g:2261:1: ( 'async' ) |
| { |
| before(grammarAccess.getComponentCommunicationTypeAccess().getASYNCHRONOUSEnumLiteralDeclaration_2()); |
| // InternalFSM.g:2262:1: ( 'async' ) |
| // InternalFSM.g:2262:3: 'async' |
| { |
| match(input,20,FOLLOW_2); |
| |
| } |
| |
| after(grammarAccess.getComponentCommunicationTypeAccess().getASYNCHRONOUSEnumLiteralDeclaration_2()); |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalFSM.g:2267:6: ( ( 'sync' ) ) |
| { |
| // InternalFSM.g:2267:6: ( ( 'sync' ) ) |
| // InternalFSM.g:2268:1: ( 'sync' ) |
| { |
| before(grammarAccess.getComponentCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_3()); |
| // InternalFSM.g:2269:1: ( 'sync' ) |
| // InternalFSM.g:2269:3: 'sync' |
| { |
| match(input,21,FOLLOW_2); |
| |
| } |
| |
| after(grammarAccess.getComponentCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_3()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ComponentCommunicationType__Alternatives" |
| |
| |
| // $ANTLR start "rule__LiteralType__Alternatives" |
| // InternalFSM.g:2279:1: rule__LiteralType__Alternatives : ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) ); |
| public final void rule__LiteralType__Alternatives() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2283:1: ( ( ( 'ptBoolean' ) ) | ( ( 'ptInteger' ) ) | ( ( 'ptReal' ) ) | ( ( 'ptCharacter' ) ) ) |
| int alt28=4; |
| switch ( input.LA(1) ) { |
| case 22: |
| { |
| alt28=1; |
| } |
| break; |
| case 23: |
| { |
| alt28=2; |
| } |
| break; |
| case 24: |
| { |
| alt28=3; |
| } |
| break; |
| case 25: |
| { |
| alt28=4; |
| } |
| break; |
| default: |
| NoViableAltException nvae = |
| new NoViableAltException("", 28, 0, input); |
| |
| throw nvae; |
| } |
| |
| switch (alt28) { |
| case 1 : |
| // InternalFSM.g:2284:1: ( ( 'ptBoolean' ) ) |
| { |
| // InternalFSM.g:2284:1: ( ( 'ptBoolean' ) ) |
| // InternalFSM.g:2285:1: ( 'ptBoolean' ) |
| { |
| before(grammarAccess.getLiteralTypeAccess().getBOOLEnumLiteralDeclaration_0()); |
| // InternalFSM.g:2286:1: ( 'ptBoolean' ) |
| // InternalFSM.g:2286:3: 'ptBoolean' |
| { |
| match(input,22,FOLLOW_2); |
| |
| } |
| |
| after(grammarAccess.getLiteralTypeAccess().getBOOLEnumLiteralDeclaration_0()); |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:2291:6: ( ( 'ptInteger' ) ) |
| { |
| // InternalFSM.g:2291:6: ( ( 'ptInteger' ) ) |
| // InternalFSM.g:2292:1: ( 'ptInteger' ) |
| { |
| before(grammarAccess.getLiteralTypeAccess().getINTEnumLiteralDeclaration_1()); |
| // InternalFSM.g:2293:1: ( 'ptInteger' ) |
| // InternalFSM.g:2293:3: 'ptInteger' |
| { |
| match(input,23,FOLLOW_2); |
| |
| } |
| |
| after(grammarAccess.getLiteralTypeAccess().getINTEnumLiteralDeclaration_1()); |
| |
| } |
| |
| |
| } |
| break; |
| case 3 : |
| // InternalFSM.g:2298:6: ( ( 'ptReal' ) ) |
| { |
| // InternalFSM.g:2298:6: ( ( 'ptReal' ) ) |
| // InternalFSM.g:2299:1: ( 'ptReal' ) |
| { |
| before(grammarAccess.getLiteralTypeAccess().getREALEnumLiteralDeclaration_2()); |
| // InternalFSM.g:2300:1: ( 'ptReal' ) |
| // InternalFSM.g:2300:3: 'ptReal' |
| { |
| match(input,24,FOLLOW_2); |
| |
| } |
| |
| after(grammarAccess.getLiteralTypeAccess().getREALEnumLiteralDeclaration_2()); |
| |
| } |
| |
| |
| } |
| break; |
| case 4 : |
| // InternalFSM.g:2305:6: ( ( 'ptCharacter' ) ) |
| { |
| // InternalFSM.g:2305:6: ( ( 'ptCharacter' ) ) |
| // InternalFSM.g:2306:1: ( 'ptCharacter' ) |
| { |
| before(grammarAccess.getLiteralTypeAccess().getCHAREnumLiteralDeclaration_3()); |
| // InternalFSM.g:2307:1: ( 'ptCharacter' ) |
| // InternalFSM.g:2307:3: 'ptCharacter' |
| { |
| match(input,25,FOLLOW_2); |
| |
| } |
| |
| after(grammarAccess.getLiteralTypeAccess().getCHAREnumLiteralDeclaration_3()); |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__LiteralType__Alternatives" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group__0" |
| // InternalFSM.g:2319:1: rule__ModelComponent__Group__0 : rule__ModelComponent__Group__0__Impl rule__ModelComponent__Group__1 ; |
| public final void rule__ModelComponent__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2323:1: ( rule__ModelComponent__Group__0__Impl rule__ModelComponent__Group__1 ) |
| // InternalFSM.g:2324:2: rule__ModelComponent__Group__0__Impl rule__ModelComponent__Group__1 |
| { |
| pushFollow(FOLLOW_4); |
| rule__ModelComponent__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group__0" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group__0__Impl" |
| // InternalFSM.g:2331:1: rule__ModelComponent__Group__0__Impl : ( ( rule__ModelComponent__UnorderedGroup_0 ) ) ; |
| public final void rule__ModelComponent__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2335:1: ( ( ( rule__ModelComponent__UnorderedGroup_0 ) ) ) |
| // InternalFSM.g:2336:1: ( ( rule__ModelComponent__UnorderedGroup_0 ) ) |
| { |
| // InternalFSM.g:2336:1: ( ( rule__ModelComponent__UnorderedGroup_0 ) ) |
| // InternalFSM.g:2337:1: ( rule__ModelComponent__UnorderedGroup_0 ) |
| { |
| before(grammarAccess.getModelComponentAccess().getUnorderedGroup_0()); |
| // InternalFSM.g:2338:1: ( rule__ModelComponent__UnorderedGroup_0 ) |
| // InternalFSM.g:2338:2: rule__ModelComponent__UnorderedGroup_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__UnorderedGroup_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getModelComponentAccess().getUnorderedGroup_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group__1" |
| // InternalFSM.g:2348:1: rule__ModelComponent__Group__1 : rule__ModelComponent__Group__1__Impl rule__ModelComponent__Group__2 ; |
| public final void rule__ModelComponent__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2352:1: ( rule__ModelComponent__Group__1__Impl rule__ModelComponent__Group__2 ) |
| // InternalFSM.g:2353:2: rule__ModelComponent__Group__1__Impl rule__ModelComponent__Group__2 |
| { |
| pushFollow(FOLLOW_5); |
| rule__ModelComponent__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group__1" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group__1__Impl" |
| // InternalFSM.g:2360:1: rule__ModelComponent__Group__1__Impl : ( 'ModelComponent' ) ; |
| public final void rule__ModelComponent__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2364:1: ( ( 'ModelComponent' ) ) |
| // InternalFSM.g:2365:1: ( 'ModelComponent' ) |
| { |
| // InternalFSM.g:2365:1: ( 'ModelComponent' ) |
| // InternalFSM.g:2366:1: 'ModelComponent' |
| { |
| before(grammarAccess.getModelComponentAccess().getModelComponentKeyword_1()); |
| match(input,26,FOLLOW_2); |
| after(grammarAccess.getModelComponentAccess().getModelComponentKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group__2" |
| // InternalFSM.g:2379:1: rule__ModelComponent__Group__2 : rule__ModelComponent__Group__2__Impl rule__ModelComponent__Group__3 ; |
| public final void rule__ModelComponent__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2383:1: ( rule__ModelComponent__Group__2__Impl rule__ModelComponent__Group__3 ) |
| // InternalFSM.g:2384:2: rule__ModelComponent__Group__2__Impl rule__ModelComponent__Group__3 |
| { |
| pushFollow(FOLLOW_6); |
| rule__ModelComponent__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group__2" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group__2__Impl" |
| // InternalFSM.g:2391:1: rule__ModelComponent__Group__2__Impl : ( ( rule__ModelComponent__ComponentNameAssignment_2 ) ) ; |
| public final void rule__ModelComponent__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2395:1: ( ( ( rule__ModelComponent__ComponentNameAssignment_2 ) ) ) |
| // InternalFSM.g:2396:1: ( ( rule__ModelComponent__ComponentNameAssignment_2 ) ) |
| { |
| // InternalFSM.g:2396:1: ( ( rule__ModelComponent__ComponentNameAssignment_2 ) ) |
| // InternalFSM.g:2397:1: ( rule__ModelComponent__ComponentNameAssignment_2 ) |
| { |
| before(grammarAccess.getModelComponentAccess().getComponentNameAssignment_2()); |
| // InternalFSM.g:2398:1: ( rule__ModelComponent__ComponentNameAssignment_2 ) |
| // InternalFSM.g:2398:2: rule__ModelComponent__ComponentNameAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__ComponentNameAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getModelComponentAccess().getComponentNameAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group__3" |
| // InternalFSM.g:2408:1: rule__ModelComponent__Group__3 : rule__ModelComponent__Group__3__Impl rule__ModelComponent__Group__4 ; |
| public final void rule__ModelComponent__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2412:1: ( rule__ModelComponent__Group__3__Impl rule__ModelComponent__Group__4 ) |
| // InternalFSM.g:2413:2: rule__ModelComponent__Group__3__Impl rule__ModelComponent__Group__4 |
| { |
| pushFollow(FOLLOW_6); |
| rule__ModelComponent__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group__3" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group__3__Impl" |
| // InternalFSM.g:2420:1: rule__ModelComponent__Group__3__Impl : ( ( rule__ModelComponent__Group_3__0 )? ) ; |
| public final void rule__ModelComponent__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2424:1: ( ( ( rule__ModelComponent__Group_3__0 )? ) ) |
| // InternalFSM.g:2425:1: ( ( rule__ModelComponent__Group_3__0 )? ) |
| { |
| // InternalFSM.g:2425:1: ( ( rule__ModelComponent__Group_3__0 )? ) |
| // InternalFSM.g:2426:1: ( rule__ModelComponent__Group_3__0 )? |
| { |
| before(grammarAccess.getModelComponentAccess().getGroup_3()); |
| // InternalFSM.g:2427:1: ( rule__ModelComponent__Group_3__0 )? |
| int alt29=2; |
| int LA29_0 = input.LA(1); |
| |
| if ( (LA29_0==27) ) { |
| alt29=1; |
| } |
| switch (alt29) { |
| case 1 : |
| // InternalFSM.g:2427:2: rule__ModelComponent__Group_3__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__Group_3__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getModelComponentAccess().getGroup_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group__4" |
| // InternalFSM.g:2437:1: rule__ModelComponent__Group__4 : rule__ModelComponent__Group__4__Impl ; |
| public final void rule__ModelComponent__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2441:1: ( rule__ModelComponent__Group__4__Impl ) |
| // InternalFSM.g:2442:2: rule__ModelComponent__Group__4__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group__4" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group__4__Impl" |
| // InternalFSM.g:2448:1: rule__ModelComponent__Group__4__Impl : ( ( rule__ModelComponent__StateMachineAssignment_4 ) ) ; |
| public final void rule__ModelComponent__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2452:1: ( ( ( rule__ModelComponent__StateMachineAssignment_4 ) ) ) |
| // InternalFSM.g:2453:1: ( ( rule__ModelComponent__StateMachineAssignment_4 ) ) |
| { |
| // InternalFSM.g:2453:1: ( ( rule__ModelComponent__StateMachineAssignment_4 ) ) |
| // InternalFSM.g:2454:1: ( rule__ModelComponent__StateMachineAssignment_4 ) |
| { |
| before(grammarAccess.getModelComponentAccess().getStateMachineAssignment_4()); |
| // InternalFSM.g:2455:1: ( rule__ModelComponent__StateMachineAssignment_4 ) |
| // InternalFSM.g:2455:2: rule__ModelComponent__StateMachineAssignment_4 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__StateMachineAssignment_4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getModelComponentAccess().getStateMachineAssignment_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group_3__0" |
| // InternalFSM.g:2475:1: rule__ModelComponent__Group_3__0 : rule__ModelComponent__Group_3__0__Impl rule__ModelComponent__Group_3__1 ; |
| public final void rule__ModelComponent__Group_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2479:1: ( rule__ModelComponent__Group_3__0__Impl rule__ModelComponent__Group_3__1 ) |
| // InternalFSM.g:2480:2: rule__ModelComponent__Group_3__0__Impl rule__ModelComponent__Group_3__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__ModelComponent__Group_3__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__Group_3__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group_3__0" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group_3__0__Impl" |
| // InternalFSM.g:2487:1: rule__ModelComponent__Group_3__0__Impl : ( 'extends' ) ; |
| public final void rule__ModelComponent__Group_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2491:1: ( ( 'extends' ) ) |
| // InternalFSM.g:2492:1: ( 'extends' ) |
| { |
| // InternalFSM.g:2492:1: ( 'extends' ) |
| // InternalFSM.g:2493:1: 'extends' |
| { |
| before(grammarAccess.getModelComponentAccess().getExtendsKeyword_3_0()); |
| match(input,27,FOLLOW_2); |
| after(grammarAccess.getModelComponentAccess().getExtendsKeyword_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group_3__1" |
| // InternalFSM.g:2506:1: rule__ModelComponent__Group_3__1 : rule__ModelComponent__Group_3__1__Impl ; |
| public final void rule__ModelComponent__Group_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2510:1: ( rule__ModelComponent__Group_3__1__Impl ) |
| // InternalFSM.g:2511:2: rule__ModelComponent__Group_3__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__Group_3__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group_3__1" |
| |
| |
| // $ANTLR start "rule__ModelComponent__Group_3__1__Impl" |
| // InternalFSM.g:2517:1: rule__ModelComponent__Group_3__1__Impl : ( ( rule__ModelComponent__BaseAssignment_3_1 ) ) ; |
| public final void rule__ModelComponent__Group_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2521:1: ( ( ( rule__ModelComponent__BaseAssignment_3_1 ) ) ) |
| // InternalFSM.g:2522:1: ( ( rule__ModelComponent__BaseAssignment_3_1 ) ) |
| { |
| // InternalFSM.g:2522:1: ( ( rule__ModelComponent__BaseAssignment_3_1 ) ) |
| // InternalFSM.g:2523:1: ( rule__ModelComponent__BaseAssignment_3_1 ) |
| { |
| before(grammarAccess.getModelComponentAccess().getBaseAssignment_3_1()); |
| // InternalFSM.g:2524:1: ( rule__ModelComponent__BaseAssignment_3_1 ) |
| // InternalFSM.g:2524:2: rule__ModelComponent__BaseAssignment_3_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__BaseAssignment_3_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getModelComponentAccess().getBaseAssignment_3_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__Group_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__StateGraph__Group__0" |
| // InternalFSM.g:2538:1: rule__StateGraph__Group__0 : rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 ; |
| public final void rule__StateGraph__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2542:1: ( rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 ) |
| // InternalFSM.g:2543:2: rule__StateGraph__Group__0__Impl rule__StateGraph__Group__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__StateGraph__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__StateGraph__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__Group__0" |
| |
| |
| // $ANTLR start "rule__StateGraph__Group__0__Impl" |
| // InternalFSM.g:2550:1: rule__StateGraph__Group__0__Impl : ( () ) ; |
| public final void rule__StateGraph__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2554:1: ( ( () ) ) |
| // InternalFSM.g:2555:1: ( () ) |
| { |
| // InternalFSM.g:2555:1: ( () ) |
| // InternalFSM.g:2556:1: () |
| { |
| before(grammarAccess.getStateGraphAccess().getStateGraphAction_0()); |
| // InternalFSM.g:2557:1: () |
| // InternalFSM.g:2559:1: |
| { |
| } |
| |
| after(grammarAccess.getStateGraphAccess().getStateGraphAction_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__StateGraph__Group__1" |
| // InternalFSM.g:2569:1: rule__StateGraph__Group__1 : rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 ; |
| public final void rule__StateGraph__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2573:1: ( rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 ) |
| // InternalFSM.g:2574:2: rule__StateGraph__Group__1__Impl rule__StateGraph__Group__2 |
| { |
| pushFollow(FOLLOW_8); |
| rule__StateGraph__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__StateGraph__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__Group__1" |
| |
| |
| // $ANTLR start "rule__StateGraph__Group__1__Impl" |
| // InternalFSM.g:2581:1: rule__StateGraph__Group__1__Impl : ( '{' ) ; |
| public final void rule__StateGraph__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2585:1: ( ( '{' ) ) |
| // InternalFSM.g:2586:1: ( '{' ) |
| { |
| // InternalFSM.g:2586:1: ( '{' ) |
| // InternalFSM.g:2587:1: '{' |
| { |
| before(grammarAccess.getStateGraphAccess().getLeftCurlyBracketKeyword_1()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getStateGraphAccess().getLeftCurlyBracketKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__StateGraph__Group__2" |
| // InternalFSM.g:2600:1: rule__StateGraph__Group__2 : rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 ; |
| public final void rule__StateGraph__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2604:1: ( rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 ) |
| // InternalFSM.g:2605:2: rule__StateGraph__Group__2__Impl rule__StateGraph__Group__3 |
| { |
| pushFollow(FOLLOW_8); |
| rule__StateGraph__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__StateGraph__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__Group__2" |
| |
| |
| // $ANTLR start "rule__StateGraph__Group__2__Impl" |
| // InternalFSM.g:2612:1: rule__StateGraph__Group__2__Impl : ( ( rule__StateGraph__Alternatives_2 )* ) ; |
| public final void rule__StateGraph__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2616:1: ( ( ( rule__StateGraph__Alternatives_2 )* ) ) |
| // InternalFSM.g:2617:1: ( ( rule__StateGraph__Alternatives_2 )* ) |
| { |
| // InternalFSM.g:2617:1: ( ( rule__StateGraph__Alternatives_2 )* ) |
| // InternalFSM.g:2618:1: ( rule__StateGraph__Alternatives_2 )* |
| { |
| before(grammarAccess.getStateGraphAccess().getAlternatives_2()); |
| // InternalFSM.g:2619:1: ( rule__StateGraph__Alternatives_2 )* |
| loop30: |
| do { |
| int alt30=2; |
| int LA30_0 = input.LA(1); |
| |
| if ( (LA30_0==31||(LA30_0>=36 && LA30_0<=41)||LA30_0==50||LA30_0==69) ) { |
| alt30=1; |
| } |
| |
| |
| switch (alt30) { |
| case 1 : |
| // InternalFSM.g:2619:2: rule__StateGraph__Alternatives_2 |
| { |
| pushFollow(FOLLOW_9); |
| rule__StateGraph__Alternatives_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop30; |
| } |
| } while (true); |
| |
| after(grammarAccess.getStateGraphAccess().getAlternatives_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__StateGraph__Group__3" |
| // InternalFSM.g:2629:1: rule__StateGraph__Group__3 : rule__StateGraph__Group__3__Impl ; |
| public final void rule__StateGraph__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2633:1: ( rule__StateGraph__Group__3__Impl ) |
| // InternalFSM.g:2634:2: rule__StateGraph__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateGraph__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__Group__3" |
| |
| |
| // $ANTLR start "rule__StateGraph__Group__3__Impl" |
| // InternalFSM.g:2640:1: rule__StateGraph__Group__3__Impl : ( '}' ) ; |
| public final void rule__StateGraph__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2644:1: ( ( '}' ) ) |
| // InternalFSM.g:2645:1: ( '}' ) |
| { |
| // InternalFSM.g:2645:1: ( '}' ) |
| // InternalFSM.g:2646:1: '}' |
| { |
| before(grammarAccess.getStateGraphAccess().getRightCurlyBracketKeyword_3()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getStateGraphAccess().getRightCurlyBracketKeyword_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__StateMachine__Group__0" |
| // InternalFSM.g:2667:1: rule__StateMachine__Group__0 : rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 ; |
| public final void rule__StateMachine__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2671:1: ( rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 ) |
| // InternalFSM.g:2672:2: rule__StateMachine__Group__0__Impl rule__StateMachine__Group__1 |
| { |
| pushFollow(FOLLOW_6); |
| rule__StateMachine__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Group__0" |
| |
| |
| // $ANTLR start "rule__StateMachine__Group__0__Impl" |
| // InternalFSM.g:2679:1: rule__StateMachine__Group__0__Impl : ( () ) ; |
| public final void rule__StateMachine__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2683:1: ( ( () ) ) |
| // InternalFSM.g:2684:1: ( () ) |
| { |
| // InternalFSM.g:2684:1: ( () ) |
| // InternalFSM.g:2685:1: () |
| { |
| before(grammarAccess.getStateMachineAccess().getStateGraphAction_0()); |
| // InternalFSM.g:2686:1: () |
| // InternalFSM.g:2688:1: |
| { |
| } |
| |
| after(grammarAccess.getStateMachineAccess().getStateGraphAction_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__StateMachine__Group__1" |
| // InternalFSM.g:2698:1: rule__StateMachine__Group__1 : rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 ; |
| public final void rule__StateMachine__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2702:1: ( rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 ) |
| // InternalFSM.g:2703:2: rule__StateMachine__Group__1__Impl rule__StateMachine__Group__2 |
| { |
| pushFollow(FOLLOW_7); |
| rule__StateMachine__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Group__1" |
| |
| |
| // $ANTLR start "rule__StateMachine__Group__1__Impl" |
| // InternalFSM.g:2710:1: rule__StateMachine__Group__1__Impl : ( 'StateMachine' ) ; |
| public final void rule__StateMachine__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2714:1: ( ( 'StateMachine' ) ) |
| // InternalFSM.g:2715:1: ( 'StateMachine' ) |
| { |
| // InternalFSM.g:2715:1: ( 'StateMachine' ) |
| // InternalFSM.g:2716:1: 'StateMachine' |
| { |
| before(grammarAccess.getStateMachineAccess().getStateMachineKeyword_1()); |
| match(input,30,FOLLOW_2); |
| after(grammarAccess.getStateMachineAccess().getStateMachineKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__StateMachine__Group__2" |
| // InternalFSM.g:2729:1: rule__StateMachine__Group__2 : rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 ; |
| public final void rule__StateMachine__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2733:1: ( rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 ) |
| // InternalFSM.g:2734:2: rule__StateMachine__Group__2__Impl rule__StateMachine__Group__3 |
| { |
| pushFollow(FOLLOW_8); |
| rule__StateMachine__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Group__2" |
| |
| |
| // $ANTLR start "rule__StateMachine__Group__2__Impl" |
| // InternalFSM.g:2741:1: rule__StateMachine__Group__2__Impl : ( '{' ) ; |
| public final void rule__StateMachine__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2745:1: ( ( '{' ) ) |
| // InternalFSM.g:2746:1: ( '{' ) |
| { |
| // InternalFSM.g:2746:1: ( '{' ) |
| // InternalFSM.g:2747:1: '{' |
| { |
| before(grammarAccess.getStateMachineAccess().getLeftCurlyBracketKeyword_2()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getStateMachineAccess().getLeftCurlyBracketKeyword_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__StateMachine__Group__3" |
| // InternalFSM.g:2760:1: rule__StateMachine__Group__3 : rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 ; |
| public final void rule__StateMachine__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2764:1: ( rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 ) |
| // InternalFSM.g:2765:2: rule__StateMachine__Group__3__Impl rule__StateMachine__Group__4 |
| { |
| pushFollow(FOLLOW_8); |
| rule__StateMachine__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Group__3" |
| |
| |
| // $ANTLR start "rule__StateMachine__Group__3__Impl" |
| // InternalFSM.g:2772:1: rule__StateMachine__Group__3__Impl : ( ( rule__StateMachine__Alternatives_3 )* ) ; |
| public final void rule__StateMachine__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2776:1: ( ( ( rule__StateMachine__Alternatives_3 )* ) ) |
| // InternalFSM.g:2777:1: ( ( rule__StateMachine__Alternatives_3 )* ) |
| { |
| // InternalFSM.g:2777:1: ( ( rule__StateMachine__Alternatives_3 )* ) |
| // InternalFSM.g:2778:1: ( rule__StateMachine__Alternatives_3 )* |
| { |
| before(grammarAccess.getStateMachineAccess().getAlternatives_3()); |
| // InternalFSM.g:2779:1: ( rule__StateMachine__Alternatives_3 )* |
| loop31: |
| do { |
| int alt31=2; |
| int LA31_0 = input.LA(1); |
| |
| if ( (LA31_0==31||(LA31_0>=36 && LA31_0<=41)||LA31_0==50||LA31_0==69) ) { |
| alt31=1; |
| } |
| |
| |
| switch (alt31) { |
| case 1 : |
| // InternalFSM.g:2779:2: rule__StateMachine__Alternatives_3 |
| { |
| pushFollow(FOLLOW_9); |
| rule__StateMachine__Alternatives_3(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop31; |
| } |
| } while (true); |
| |
| after(grammarAccess.getStateMachineAccess().getAlternatives_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__StateMachine__Group__4" |
| // InternalFSM.g:2789:1: rule__StateMachine__Group__4 : rule__StateMachine__Group__4__Impl ; |
| public final void rule__StateMachine__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2793:1: ( rule__StateMachine__Group__4__Impl ) |
| // InternalFSM.g:2794:2: rule__StateMachine__Group__4__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__StateMachine__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Group__4" |
| |
| |
| // $ANTLR start "rule__StateMachine__Group__4__Impl" |
| // InternalFSM.g:2800:1: rule__StateMachine__Group__4__Impl : ( '}' ) ; |
| public final void rule__StateMachine__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2804:1: ( ( '}' ) ) |
| // InternalFSM.g:2805:1: ( '}' ) |
| { |
| // InternalFSM.g:2805:1: ( '}' ) |
| // InternalFSM.g:2806:1: '}' |
| { |
| before(grammarAccess.getStateMachineAccess().getRightCurlyBracketKeyword_4()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getStateMachineAccess().getRightCurlyBracketKeyword_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group__0" |
| // InternalFSM.g:2829:1: rule__SimpleState__Group__0 : rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 ; |
| public final void rule__SimpleState__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2833:1: ( rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 ) |
| // InternalFSM.g:2834:2: rule__SimpleState__Group__0__Impl rule__SimpleState__Group__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__SimpleState__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group__0" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group__0__Impl" |
| // InternalFSM.g:2841:1: rule__SimpleState__Group__0__Impl : ( 'State' ) ; |
| public final void rule__SimpleState__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2845:1: ( ( 'State' ) ) |
| // InternalFSM.g:2846:1: ( 'State' ) |
| { |
| // InternalFSM.g:2846:1: ( 'State' ) |
| // InternalFSM.g:2847:1: 'State' |
| { |
| before(grammarAccess.getSimpleStateAccess().getStateKeyword_0()); |
| match(input,31,FOLLOW_2); |
| after(grammarAccess.getSimpleStateAccess().getStateKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group__1" |
| // InternalFSM.g:2860:1: rule__SimpleState__Group__1 : rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 ; |
| public final void rule__SimpleState__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2864:1: ( rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 ) |
| // InternalFSM.g:2865:2: rule__SimpleState__Group__1__Impl rule__SimpleState__Group__2 |
| { |
| pushFollow(FOLLOW_10); |
| rule__SimpleState__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group__1" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group__1__Impl" |
| // InternalFSM.g:2872:1: rule__SimpleState__Group__1__Impl : ( ( rule__SimpleState__NameAssignment_1 ) ) ; |
| public final void rule__SimpleState__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2876:1: ( ( ( rule__SimpleState__NameAssignment_1 ) ) ) |
| // InternalFSM.g:2877:1: ( ( rule__SimpleState__NameAssignment_1 ) ) |
| { |
| // InternalFSM.g:2877:1: ( ( rule__SimpleState__NameAssignment_1 ) ) |
| // InternalFSM.g:2878:1: ( rule__SimpleState__NameAssignment_1 ) |
| { |
| before(grammarAccess.getSimpleStateAccess().getNameAssignment_1()); |
| // InternalFSM.g:2879:1: ( rule__SimpleState__NameAssignment_1 ) |
| // InternalFSM.g:2879:2: rule__SimpleState__NameAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__NameAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getNameAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group__2" |
| // InternalFSM.g:2889:1: rule__SimpleState__Group__2 : rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 ; |
| public final void rule__SimpleState__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2893:1: ( rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 ) |
| // InternalFSM.g:2894:2: rule__SimpleState__Group__2__Impl rule__SimpleState__Group__3 |
| { |
| pushFollow(FOLLOW_10); |
| rule__SimpleState__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group__2" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group__2__Impl" |
| // InternalFSM.g:2901:1: rule__SimpleState__Group__2__Impl : ( ( rule__SimpleState__DocuAssignment_2 )? ) ; |
| public final void rule__SimpleState__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2905:1: ( ( ( rule__SimpleState__DocuAssignment_2 )? ) ) |
| // InternalFSM.g:2906:1: ( ( rule__SimpleState__DocuAssignment_2 )? ) |
| { |
| // InternalFSM.g:2906:1: ( ( rule__SimpleState__DocuAssignment_2 )? ) |
| // InternalFSM.g:2907:1: ( rule__SimpleState__DocuAssignment_2 )? |
| { |
| before(grammarAccess.getSimpleStateAccess().getDocuAssignment_2()); |
| // InternalFSM.g:2908:1: ( rule__SimpleState__DocuAssignment_2 )? |
| int alt32=2; |
| int LA32_0 = input.LA(1); |
| |
| if ( (LA32_0==65) ) { |
| alt32=1; |
| } |
| switch (alt32) { |
| case 1 : |
| // InternalFSM.g:2908:2: rule__SimpleState__DocuAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__DocuAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getDocuAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group__3" |
| // InternalFSM.g:2918:1: rule__SimpleState__Group__3 : rule__SimpleState__Group__3__Impl ; |
| public final void rule__SimpleState__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2922:1: ( rule__SimpleState__Group__3__Impl ) |
| // InternalFSM.g:2923:2: rule__SimpleState__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group__3" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group__3__Impl" |
| // InternalFSM.g:2929:1: rule__SimpleState__Group__3__Impl : ( ( rule__SimpleState__Group_3__0 )? ) ; |
| public final void rule__SimpleState__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2933:1: ( ( ( rule__SimpleState__Group_3__0 )? ) ) |
| // InternalFSM.g:2934:1: ( ( rule__SimpleState__Group_3__0 )? ) |
| { |
| // InternalFSM.g:2934:1: ( ( rule__SimpleState__Group_3__0 )? ) |
| // InternalFSM.g:2935:1: ( rule__SimpleState__Group_3__0 )? |
| { |
| before(grammarAccess.getSimpleStateAccess().getGroup_3()); |
| // InternalFSM.g:2936:1: ( rule__SimpleState__Group_3__0 )? |
| int alt33=2; |
| int LA33_0 = input.LA(1); |
| |
| if ( (LA33_0==28) ) { |
| alt33=1; |
| } |
| switch (alt33) { |
| case 1 : |
| // InternalFSM.g:2936:2: rule__SimpleState__Group_3__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getGroup_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__0" |
| // InternalFSM.g:2954:1: rule__SimpleState__Group_3__0 : rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 ; |
| public final void rule__SimpleState__Group_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2958:1: ( rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 ) |
| // InternalFSM.g:2959:2: rule__SimpleState__Group_3__0__Impl rule__SimpleState__Group_3__1 |
| { |
| pushFollow(FOLLOW_11); |
| rule__SimpleState__Group_3__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__0" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__0__Impl" |
| // InternalFSM.g:2966:1: rule__SimpleState__Group_3__0__Impl : ( '{' ) ; |
| public final void rule__SimpleState__Group_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2970:1: ( ( '{' ) ) |
| // InternalFSM.g:2971:1: ( '{' ) |
| { |
| // InternalFSM.g:2971:1: ( '{' ) |
| // InternalFSM.g:2972:1: '{' |
| { |
| before(grammarAccess.getSimpleStateAccess().getLeftCurlyBracketKeyword_3_0()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getSimpleStateAccess().getLeftCurlyBracketKeyword_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__1" |
| // InternalFSM.g:2985:1: rule__SimpleState__Group_3__1 : rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 ; |
| public final void rule__SimpleState__Group_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:2989:1: ( rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 ) |
| // InternalFSM.g:2990:2: rule__SimpleState__Group_3__1__Impl rule__SimpleState__Group_3__2 |
| { |
| pushFollow(FOLLOW_11); |
| rule__SimpleState__Group_3__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__1" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__1__Impl" |
| // InternalFSM.g:2997:1: rule__SimpleState__Group_3__1__Impl : ( ( rule__SimpleState__Group_3_1__0 )? ) ; |
| public final void rule__SimpleState__Group_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3001:1: ( ( ( rule__SimpleState__Group_3_1__0 )? ) ) |
| // InternalFSM.g:3002:1: ( ( rule__SimpleState__Group_3_1__0 )? ) |
| { |
| // InternalFSM.g:3002:1: ( ( rule__SimpleState__Group_3_1__0 )? ) |
| // InternalFSM.g:3003:1: ( rule__SimpleState__Group_3_1__0 )? |
| { |
| before(grammarAccess.getSimpleStateAccess().getGroup_3_1()); |
| // InternalFSM.g:3004:1: ( rule__SimpleState__Group_3_1__0 )? |
| int alt34=2; |
| int LA34_0 = input.LA(1); |
| |
| if ( (LA34_0==32) ) { |
| alt34=1; |
| } |
| switch (alt34) { |
| case 1 : |
| // InternalFSM.g:3004:2: rule__SimpleState__Group_3_1__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_1__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getGroup_3_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__2" |
| // InternalFSM.g:3014:1: rule__SimpleState__Group_3__2 : rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 ; |
| public final void rule__SimpleState__Group_3__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3018:1: ( rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 ) |
| // InternalFSM.g:3019:2: rule__SimpleState__Group_3__2__Impl rule__SimpleState__Group_3__3 |
| { |
| pushFollow(FOLLOW_11); |
| rule__SimpleState__Group_3__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__2" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__2__Impl" |
| // InternalFSM.g:3026:1: rule__SimpleState__Group_3__2__Impl : ( ( rule__SimpleState__Group_3_2__0 )? ) ; |
| public final void rule__SimpleState__Group_3__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3030:1: ( ( ( rule__SimpleState__Group_3_2__0 )? ) ) |
| // InternalFSM.g:3031:1: ( ( rule__SimpleState__Group_3_2__0 )? ) |
| { |
| // InternalFSM.g:3031:1: ( ( rule__SimpleState__Group_3_2__0 )? ) |
| // InternalFSM.g:3032:1: ( rule__SimpleState__Group_3_2__0 )? |
| { |
| before(grammarAccess.getSimpleStateAccess().getGroup_3_2()); |
| // InternalFSM.g:3033:1: ( rule__SimpleState__Group_3_2__0 )? |
| int alt35=2; |
| int LA35_0 = input.LA(1); |
| |
| if ( (LA35_0==33) ) { |
| alt35=1; |
| } |
| switch (alt35) { |
| case 1 : |
| // InternalFSM.g:3033:2: rule__SimpleState__Group_3_2__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_2__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getGroup_3_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__2__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__3" |
| // InternalFSM.g:3043:1: rule__SimpleState__Group_3__3 : rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 ; |
| public final void rule__SimpleState__Group_3__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3047:1: ( rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 ) |
| // InternalFSM.g:3048:2: rule__SimpleState__Group_3__3__Impl rule__SimpleState__Group_3__4 |
| { |
| pushFollow(FOLLOW_11); |
| rule__SimpleState__Group_3__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__3" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__3__Impl" |
| // InternalFSM.g:3055:1: rule__SimpleState__Group_3__3__Impl : ( ( rule__SimpleState__Group_3_3__0 )? ) ; |
| public final void rule__SimpleState__Group_3__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3059:1: ( ( ( rule__SimpleState__Group_3_3__0 )? ) ) |
| // InternalFSM.g:3060:1: ( ( rule__SimpleState__Group_3_3__0 )? ) |
| { |
| // InternalFSM.g:3060:1: ( ( rule__SimpleState__Group_3_3__0 )? ) |
| // InternalFSM.g:3061:1: ( rule__SimpleState__Group_3_3__0 )? |
| { |
| before(grammarAccess.getSimpleStateAccess().getGroup_3_3()); |
| // InternalFSM.g:3062:1: ( rule__SimpleState__Group_3_3__0 )? |
| int alt36=2; |
| int LA36_0 = input.LA(1); |
| |
| if ( (LA36_0==34) ) { |
| alt36=1; |
| } |
| switch (alt36) { |
| case 1 : |
| // InternalFSM.g:3062:2: rule__SimpleState__Group_3_3__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_3__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getGroup_3_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__3__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__4" |
| // InternalFSM.g:3072:1: rule__SimpleState__Group_3__4 : rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 ; |
| public final void rule__SimpleState__Group_3__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3076:1: ( rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 ) |
| // InternalFSM.g:3077:2: rule__SimpleState__Group_3__4__Impl rule__SimpleState__Group_3__5 |
| { |
| pushFollow(FOLLOW_11); |
| rule__SimpleState__Group_3__4__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3__5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__4" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__4__Impl" |
| // InternalFSM.g:3084:1: rule__SimpleState__Group_3__4__Impl : ( ( rule__SimpleState__Group_3_4__0 )? ) ; |
| public final void rule__SimpleState__Group_3__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3088:1: ( ( ( rule__SimpleState__Group_3_4__0 )? ) ) |
| // InternalFSM.g:3089:1: ( ( rule__SimpleState__Group_3_4__0 )? ) |
| { |
| // InternalFSM.g:3089:1: ( ( rule__SimpleState__Group_3_4__0 )? ) |
| // InternalFSM.g:3090:1: ( rule__SimpleState__Group_3_4__0 )? |
| { |
| before(grammarAccess.getSimpleStateAccess().getGroup_3_4()); |
| // InternalFSM.g:3091:1: ( rule__SimpleState__Group_3_4__0 )? |
| int alt37=2; |
| int LA37_0 = input.LA(1); |
| |
| if ( (LA37_0==35) ) { |
| alt37=1; |
| } |
| switch (alt37) { |
| case 1 : |
| // InternalFSM.g:3091:2: rule__SimpleState__Group_3_4__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_4__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getGroup_3_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__4__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__5" |
| // InternalFSM.g:3101:1: rule__SimpleState__Group_3__5 : rule__SimpleState__Group_3__5__Impl ; |
| public final void rule__SimpleState__Group_3__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3105:1: ( rule__SimpleState__Group_3__5__Impl ) |
| // InternalFSM.g:3106:2: rule__SimpleState__Group_3__5__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3__5__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__5" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3__5__Impl" |
| // InternalFSM.g:3112:1: rule__SimpleState__Group_3__5__Impl : ( '}' ) ; |
| public final void rule__SimpleState__Group_3__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3116:1: ( ( '}' ) ) |
| // InternalFSM.g:3117:1: ( '}' ) |
| { |
| // InternalFSM.g:3117:1: ( '}' ) |
| // InternalFSM.g:3118:1: '}' |
| { |
| before(grammarAccess.getSimpleStateAccess().getRightCurlyBracketKeyword_3_5()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getSimpleStateAccess().getRightCurlyBracketKeyword_3_5()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3__5__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_1__0" |
| // InternalFSM.g:3143:1: rule__SimpleState__Group_3_1__0 : rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 ; |
| public final void rule__SimpleState__Group_3_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3147:1: ( rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 ) |
| // InternalFSM.g:3148:2: rule__SimpleState__Group_3_1__0__Impl rule__SimpleState__Group_3_1__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__SimpleState__Group_3_1__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_1__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_1__0" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_1__0__Impl" |
| // InternalFSM.g:3155:1: rule__SimpleState__Group_3_1__0__Impl : ( 'entry' ) ; |
| public final void rule__SimpleState__Group_3_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3159:1: ( ( 'entry' ) ) |
| // InternalFSM.g:3160:1: ( 'entry' ) |
| { |
| // InternalFSM.g:3160:1: ( 'entry' ) |
| // InternalFSM.g:3161:1: 'entry' |
| { |
| before(grammarAccess.getSimpleStateAccess().getEntryKeyword_3_1_0()); |
| match(input,32,FOLLOW_2); |
| after(grammarAccess.getSimpleStateAccess().getEntryKeyword_3_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_1__1" |
| // InternalFSM.g:3174:1: rule__SimpleState__Group_3_1__1 : rule__SimpleState__Group_3_1__1__Impl ; |
| public final void rule__SimpleState__Group_3_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3178:1: ( rule__SimpleState__Group_3_1__1__Impl ) |
| // InternalFSM.g:3179:2: rule__SimpleState__Group_3_1__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_1__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_1__1" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_1__1__Impl" |
| // InternalFSM.g:3185:1: rule__SimpleState__Group_3_1__1__Impl : ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) ; |
| public final void rule__SimpleState__Group_3_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3189:1: ( ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) ) |
| // InternalFSM.g:3190:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) |
| { |
| // InternalFSM.g:3190:1: ( ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) ) |
| // InternalFSM.g:3191:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) |
| { |
| before(grammarAccess.getSimpleStateAccess().getEntryCodeAssignment_3_1_1()); |
| // InternalFSM.g:3192:1: ( rule__SimpleState__EntryCodeAssignment_3_1_1 ) |
| // InternalFSM.g:3192:2: rule__SimpleState__EntryCodeAssignment_3_1_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__EntryCodeAssignment_3_1_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getEntryCodeAssignment_3_1_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_2__0" |
| // InternalFSM.g:3206:1: rule__SimpleState__Group_3_2__0 : rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 ; |
| public final void rule__SimpleState__Group_3_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3210:1: ( rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 ) |
| // InternalFSM.g:3211:2: rule__SimpleState__Group_3_2__0__Impl rule__SimpleState__Group_3_2__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__SimpleState__Group_3_2__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_2__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_2__0" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_2__0__Impl" |
| // InternalFSM.g:3218:1: rule__SimpleState__Group_3_2__0__Impl : ( 'exit' ) ; |
| public final void rule__SimpleState__Group_3_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3222:1: ( ( 'exit' ) ) |
| // InternalFSM.g:3223:1: ( 'exit' ) |
| { |
| // InternalFSM.g:3223:1: ( 'exit' ) |
| // InternalFSM.g:3224:1: 'exit' |
| { |
| before(grammarAccess.getSimpleStateAccess().getExitKeyword_3_2_0()); |
| match(input,33,FOLLOW_2); |
| after(grammarAccess.getSimpleStateAccess().getExitKeyword_3_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_2__1" |
| // InternalFSM.g:3237:1: rule__SimpleState__Group_3_2__1 : rule__SimpleState__Group_3_2__1__Impl ; |
| public final void rule__SimpleState__Group_3_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3241:1: ( rule__SimpleState__Group_3_2__1__Impl ) |
| // InternalFSM.g:3242:2: rule__SimpleState__Group_3_2__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_2__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_2__1" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_2__1__Impl" |
| // InternalFSM.g:3248:1: rule__SimpleState__Group_3_2__1__Impl : ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) ; |
| public final void rule__SimpleState__Group_3_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3252:1: ( ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) ) |
| // InternalFSM.g:3253:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) |
| { |
| // InternalFSM.g:3253:1: ( ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) ) |
| // InternalFSM.g:3254:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) |
| { |
| before(grammarAccess.getSimpleStateAccess().getExitCodeAssignment_3_2_1()); |
| // InternalFSM.g:3255:1: ( rule__SimpleState__ExitCodeAssignment_3_2_1 ) |
| // InternalFSM.g:3255:2: rule__SimpleState__ExitCodeAssignment_3_2_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__ExitCodeAssignment_3_2_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getExitCodeAssignment_3_2_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_3__0" |
| // InternalFSM.g:3269:1: rule__SimpleState__Group_3_3__0 : rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 ; |
| public final void rule__SimpleState__Group_3_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3273:1: ( rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 ) |
| // InternalFSM.g:3274:2: rule__SimpleState__Group_3_3__0__Impl rule__SimpleState__Group_3_3__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__SimpleState__Group_3_3__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_3__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_3__0" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_3__0__Impl" |
| // InternalFSM.g:3281:1: rule__SimpleState__Group_3_3__0__Impl : ( 'do' ) ; |
| public final void rule__SimpleState__Group_3_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3285:1: ( ( 'do' ) ) |
| // InternalFSM.g:3286:1: ( 'do' ) |
| { |
| // InternalFSM.g:3286:1: ( 'do' ) |
| // InternalFSM.g:3287:1: 'do' |
| { |
| before(grammarAccess.getSimpleStateAccess().getDoKeyword_3_3_0()); |
| match(input,34,FOLLOW_2); |
| after(grammarAccess.getSimpleStateAccess().getDoKeyword_3_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_3__1" |
| // InternalFSM.g:3300:1: rule__SimpleState__Group_3_3__1 : rule__SimpleState__Group_3_3__1__Impl ; |
| public final void rule__SimpleState__Group_3_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3304:1: ( rule__SimpleState__Group_3_3__1__Impl ) |
| // InternalFSM.g:3305:2: rule__SimpleState__Group_3_3__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_3__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_3__1" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_3__1__Impl" |
| // InternalFSM.g:3311:1: rule__SimpleState__Group_3_3__1__Impl : ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) ; |
| public final void rule__SimpleState__Group_3_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3315:1: ( ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) ) |
| // InternalFSM.g:3316:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) |
| { |
| // InternalFSM.g:3316:1: ( ( rule__SimpleState__DoCodeAssignment_3_3_1 ) ) |
| // InternalFSM.g:3317:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 ) |
| { |
| before(grammarAccess.getSimpleStateAccess().getDoCodeAssignment_3_3_1()); |
| // InternalFSM.g:3318:1: ( rule__SimpleState__DoCodeAssignment_3_3_1 ) |
| // InternalFSM.g:3318:2: rule__SimpleState__DoCodeAssignment_3_3_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__DoCodeAssignment_3_3_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getDoCodeAssignment_3_3_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_4__0" |
| // InternalFSM.g:3332:1: rule__SimpleState__Group_3_4__0 : rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 ; |
| public final void rule__SimpleState__Group_3_4__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3336:1: ( rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 ) |
| // InternalFSM.g:3337:2: rule__SimpleState__Group_3_4__0__Impl rule__SimpleState__Group_3_4__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__SimpleState__Group_3_4__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_4__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_4__0" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_4__0__Impl" |
| // InternalFSM.g:3344:1: rule__SimpleState__Group_3_4__0__Impl : ( 'subgraph' ) ; |
| public final void rule__SimpleState__Group_3_4__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3348:1: ( ( 'subgraph' ) ) |
| // InternalFSM.g:3349:1: ( 'subgraph' ) |
| { |
| // InternalFSM.g:3349:1: ( 'subgraph' ) |
| // InternalFSM.g:3350:1: 'subgraph' |
| { |
| before(grammarAccess.getSimpleStateAccess().getSubgraphKeyword_3_4_0()); |
| match(input,35,FOLLOW_2); |
| after(grammarAccess.getSimpleStateAccess().getSubgraphKeyword_3_4_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_4__0__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_4__1" |
| // InternalFSM.g:3363:1: rule__SimpleState__Group_3_4__1 : rule__SimpleState__Group_3_4__1__Impl ; |
| public final void rule__SimpleState__Group_3_4__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3367:1: ( rule__SimpleState__Group_3_4__1__Impl ) |
| // InternalFSM.g:3368:2: rule__SimpleState__Group_3_4__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__Group_3_4__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_4__1" |
| |
| |
| // $ANTLR start "rule__SimpleState__Group_3_4__1__Impl" |
| // InternalFSM.g:3374:1: rule__SimpleState__Group_3_4__1__Impl : ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) ; |
| public final void rule__SimpleState__Group_3_4__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3378:1: ( ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) ) |
| // InternalFSM.g:3379:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) |
| { |
| // InternalFSM.g:3379:1: ( ( rule__SimpleState__SubgraphAssignment_3_4_1 ) ) |
| // InternalFSM.g:3380:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 ) |
| { |
| before(grammarAccess.getSimpleStateAccess().getSubgraphAssignment_3_4_1()); |
| // InternalFSM.g:3381:1: ( rule__SimpleState__SubgraphAssignment_3_4_1 ) |
| // InternalFSM.g:3381:2: rule__SimpleState__SubgraphAssignment_3_4_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleState__SubgraphAssignment_3_4_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleStateAccess().getSubgraphAssignment_3_4_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__Group_3_4__1__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__0" |
| // InternalFSM.g:3395:1: rule__RefinedState__Group__0 : rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 ; |
| public final void rule__RefinedState__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3399:1: ( rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 ) |
| // InternalFSM.g:3400:2: rule__RefinedState__Group__0__Impl rule__RefinedState__Group__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__RefinedState__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__0" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__0__Impl" |
| // InternalFSM.g:3407:1: rule__RefinedState__Group__0__Impl : ( 'RefinedState' ) ; |
| public final void rule__RefinedState__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3411:1: ( ( 'RefinedState' ) ) |
| // InternalFSM.g:3412:1: ( 'RefinedState' ) |
| { |
| // InternalFSM.g:3412:1: ( 'RefinedState' ) |
| // InternalFSM.g:3413:1: 'RefinedState' |
| { |
| before(grammarAccess.getRefinedStateAccess().getRefinedStateKeyword_0()); |
| match(input,36,FOLLOW_2); |
| after(grammarAccess.getRefinedStateAccess().getRefinedStateKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__1" |
| // InternalFSM.g:3426:1: rule__RefinedState__Group__1 : rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 ; |
| public final void rule__RefinedState__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3430:1: ( rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 ) |
| // InternalFSM.g:3431:2: rule__RefinedState__Group__1__Impl rule__RefinedState__Group__2 |
| { |
| pushFollow(FOLLOW_10); |
| rule__RefinedState__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__1" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__1__Impl" |
| // InternalFSM.g:3438:1: rule__RefinedState__Group__1__Impl : ( ( rule__RefinedState__TargetAssignment_1 ) ) ; |
| public final void rule__RefinedState__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3442:1: ( ( ( rule__RefinedState__TargetAssignment_1 ) ) ) |
| // InternalFSM.g:3443:1: ( ( rule__RefinedState__TargetAssignment_1 ) ) |
| { |
| // InternalFSM.g:3443:1: ( ( rule__RefinedState__TargetAssignment_1 ) ) |
| // InternalFSM.g:3444:1: ( rule__RefinedState__TargetAssignment_1 ) |
| { |
| before(grammarAccess.getRefinedStateAccess().getTargetAssignment_1()); |
| // InternalFSM.g:3445:1: ( rule__RefinedState__TargetAssignment_1 ) |
| // InternalFSM.g:3445:2: rule__RefinedState__TargetAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__TargetAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getTargetAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__2" |
| // InternalFSM.g:3455:1: rule__RefinedState__Group__2 : rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 ; |
| public final void rule__RefinedState__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3459:1: ( rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 ) |
| // InternalFSM.g:3460:2: rule__RefinedState__Group__2__Impl rule__RefinedState__Group__3 |
| { |
| pushFollow(FOLLOW_10); |
| rule__RefinedState__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__2" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__2__Impl" |
| // InternalFSM.g:3467:1: rule__RefinedState__Group__2__Impl : ( ( rule__RefinedState__DocuAssignment_2 )? ) ; |
| public final void rule__RefinedState__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3471:1: ( ( ( rule__RefinedState__DocuAssignment_2 )? ) ) |
| // InternalFSM.g:3472:1: ( ( rule__RefinedState__DocuAssignment_2 )? ) |
| { |
| // InternalFSM.g:3472:1: ( ( rule__RefinedState__DocuAssignment_2 )? ) |
| // InternalFSM.g:3473:1: ( rule__RefinedState__DocuAssignment_2 )? |
| { |
| before(grammarAccess.getRefinedStateAccess().getDocuAssignment_2()); |
| // InternalFSM.g:3474:1: ( rule__RefinedState__DocuAssignment_2 )? |
| int alt38=2; |
| int LA38_0 = input.LA(1); |
| |
| if ( (LA38_0==65) ) { |
| alt38=1; |
| } |
| switch (alt38) { |
| case 1 : |
| // InternalFSM.g:3474:2: rule__RefinedState__DocuAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__DocuAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getDocuAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__3" |
| // InternalFSM.g:3484:1: rule__RefinedState__Group__3 : rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 ; |
| public final void rule__RefinedState__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3488:1: ( rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 ) |
| // InternalFSM.g:3489:2: rule__RefinedState__Group__3__Impl rule__RefinedState__Group__4 |
| { |
| pushFollow(FOLLOW_11); |
| rule__RefinedState__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__3" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__3__Impl" |
| // InternalFSM.g:3496:1: rule__RefinedState__Group__3__Impl : ( '{' ) ; |
| public final void rule__RefinedState__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3500:1: ( ( '{' ) ) |
| // InternalFSM.g:3501:1: ( '{' ) |
| { |
| // InternalFSM.g:3501:1: ( '{' ) |
| // InternalFSM.g:3502:1: '{' |
| { |
| before(grammarAccess.getRefinedStateAccess().getLeftCurlyBracketKeyword_3()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getRefinedStateAccess().getLeftCurlyBracketKeyword_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__4" |
| // InternalFSM.g:3515:1: rule__RefinedState__Group__4 : rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 ; |
| public final void rule__RefinedState__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3519:1: ( rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 ) |
| // InternalFSM.g:3520:2: rule__RefinedState__Group__4__Impl rule__RefinedState__Group__5 |
| { |
| pushFollow(FOLLOW_11); |
| rule__RefinedState__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group__5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__4" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__4__Impl" |
| // InternalFSM.g:3527:1: rule__RefinedState__Group__4__Impl : ( ( rule__RefinedState__Group_4__0 )? ) ; |
| public final void rule__RefinedState__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3531:1: ( ( ( rule__RefinedState__Group_4__0 )? ) ) |
| // InternalFSM.g:3532:1: ( ( rule__RefinedState__Group_4__0 )? ) |
| { |
| // InternalFSM.g:3532:1: ( ( rule__RefinedState__Group_4__0 )? ) |
| // InternalFSM.g:3533:1: ( rule__RefinedState__Group_4__0 )? |
| { |
| before(grammarAccess.getRefinedStateAccess().getGroup_4()); |
| // InternalFSM.g:3534:1: ( rule__RefinedState__Group_4__0 )? |
| int alt39=2; |
| int LA39_0 = input.LA(1); |
| |
| if ( (LA39_0==32) ) { |
| alt39=1; |
| } |
| switch (alt39) { |
| case 1 : |
| // InternalFSM.g:3534:2: rule__RefinedState__Group_4__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_4__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getGroup_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__5" |
| // InternalFSM.g:3544:1: rule__RefinedState__Group__5 : rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 ; |
| public final void rule__RefinedState__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3548:1: ( rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 ) |
| // InternalFSM.g:3549:2: rule__RefinedState__Group__5__Impl rule__RefinedState__Group__6 |
| { |
| pushFollow(FOLLOW_11); |
| rule__RefinedState__Group__5__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group__6(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__5" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__5__Impl" |
| // InternalFSM.g:3556:1: rule__RefinedState__Group__5__Impl : ( ( rule__RefinedState__Group_5__0 )? ) ; |
| public final void rule__RefinedState__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3560:1: ( ( ( rule__RefinedState__Group_5__0 )? ) ) |
| // InternalFSM.g:3561:1: ( ( rule__RefinedState__Group_5__0 )? ) |
| { |
| // InternalFSM.g:3561:1: ( ( rule__RefinedState__Group_5__0 )? ) |
| // InternalFSM.g:3562:1: ( rule__RefinedState__Group_5__0 )? |
| { |
| before(grammarAccess.getRefinedStateAccess().getGroup_5()); |
| // InternalFSM.g:3563:1: ( rule__RefinedState__Group_5__0 )? |
| int alt40=2; |
| int LA40_0 = input.LA(1); |
| |
| if ( (LA40_0==33) ) { |
| alt40=1; |
| } |
| switch (alt40) { |
| case 1 : |
| // InternalFSM.g:3563:2: rule__RefinedState__Group_5__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_5__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getGroup_5()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__6" |
| // InternalFSM.g:3573:1: rule__RefinedState__Group__6 : rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 ; |
| public final void rule__RefinedState__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3577:1: ( rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 ) |
| // InternalFSM.g:3578:2: rule__RefinedState__Group__6__Impl rule__RefinedState__Group__7 |
| { |
| pushFollow(FOLLOW_11); |
| rule__RefinedState__Group__6__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group__7(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__6" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__6__Impl" |
| // InternalFSM.g:3585:1: rule__RefinedState__Group__6__Impl : ( ( rule__RefinedState__Group_6__0 )? ) ; |
| public final void rule__RefinedState__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3589:1: ( ( ( rule__RefinedState__Group_6__0 )? ) ) |
| // InternalFSM.g:3590:1: ( ( rule__RefinedState__Group_6__0 )? ) |
| { |
| // InternalFSM.g:3590:1: ( ( rule__RefinedState__Group_6__0 )? ) |
| // InternalFSM.g:3591:1: ( rule__RefinedState__Group_6__0 )? |
| { |
| before(grammarAccess.getRefinedStateAccess().getGroup_6()); |
| // InternalFSM.g:3592:1: ( rule__RefinedState__Group_6__0 )? |
| int alt41=2; |
| int LA41_0 = input.LA(1); |
| |
| if ( (LA41_0==34) ) { |
| alt41=1; |
| } |
| switch (alt41) { |
| case 1 : |
| // InternalFSM.g:3592:2: rule__RefinedState__Group_6__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_6__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getGroup_6()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__7" |
| // InternalFSM.g:3602:1: rule__RefinedState__Group__7 : rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 ; |
| public final void rule__RefinedState__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3606:1: ( rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 ) |
| // InternalFSM.g:3607:2: rule__RefinedState__Group__7__Impl rule__RefinedState__Group__8 |
| { |
| pushFollow(FOLLOW_11); |
| rule__RefinedState__Group__7__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group__8(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__7" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__7__Impl" |
| // InternalFSM.g:3614:1: rule__RefinedState__Group__7__Impl : ( ( rule__RefinedState__Group_7__0 )? ) ; |
| public final void rule__RefinedState__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3618:1: ( ( ( rule__RefinedState__Group_7__0 )? ) ) |
| // InternalFSM.g:3619:1: ( ( rule__RefinedState__Group_7__0 )? ) |
| { |
| // InternalFSM.g:3619:1: ( ( rule__RefinedState__Group_7__0 )? ) |
| // InternalFSM.g:3620:1: ( rule__RefinedState__Group_7__0 )? |
| { |
| before(grammarAccess.getRefinedStateAccess().getGroup_7()); |
| // InternalFSM.g:3621:1: ( rule__RefinedState__Group_7__0 )? |
| int alt42=2; |
| int LA42_0 = input.LA(1); |
| |
| if ( (LA42_0==35) ) { |
| alt42=1; |
| } |
| switch (alt42) { |
| case 1 : |
| // InternalFSM.g:3621:2: rule__RefinedState__Group_7__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_7__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getGroup_7()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__8" |
| // InternalFSM.g:3631:1: rule__RefinedState__Group__8 : rule__RefinedState__Group__8__Impl ; |
| public final void rule__RefinedState__Group__8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3635:1: ( rule__RefinedState__Group__8__Impl ) |
| // InternalFSM.g:3636:2: rule__RefinedState__Group__8__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group__8__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__8" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group__8__Impl" |
| // InternalFSM.g:3642:1: rule__RefinedState__Group__8__Impl : ( '}' ) ; |
| public final void rule__RefinedState__Group__8__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3646:1: ( ( '}' ) ) |
| // InternalFSM.g:3647:1: ( '}' ) |
| { |
| // InternalFSM.g:3647:1: ( '}' ) |
| // InternalFSM.g:3648:1: '}' |
| { |
| before(grammarAccess.getRefinedStateAccess().getRightCurlyBracketKeyword_8()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getRefinedStateAccess().getRightCurlyBracketKeyword_8()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group__8__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_4__0" |
| // InternalFSM.g:3679:1: rule__RefinedState__Group_4__0 : rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 ; |
| public final void rule__RefinedState__Group_4__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3683:1: ( rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 ) |
| // InternalFSM.g:3684:2: rule__RefinedState__Group_4__0__Impl rule__RefinedState__Group_4__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__RefinedState__Group_4__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_4__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_4__0" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_4__0__Impl" |
| // InternalFSM.g:3691:1: rule__RefinedState__Group_4__0__Impl : ( 'entry' ) ; |
| public final void rule__RefinedState__Group_4__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3695:1: ( ( 'entry' ) ) |
| // InternalFSM.g:3696:1: ( 'entry' ) |
| { |
| // InternalFSM.g:3696:1: ( 'entry' ) |
| // InternalFSM.g:3697:1: 'entry' |
| { |
| before(grammarAccess.getRefinedStateAccess().getEntryKeyword_4_0()); |
| match(input,32,FOLLOW_2); |
| after(grammarAccess.getRefinedStateAccess().getEntryKeyword_4_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_4__0__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_4__1" |
| // InternalFSM.g:3710:1: rule__RefinedState__Group_4__1 : rule__RefinedState__Group_4__1__Impl ; |
| public final void rule__RefinedState__Group_4__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3714:1: ( rule__RefinedState__Group_4__1__Impl ) |
| // InternalFSM.g:3715:2: rule__RefinedState__Group_4__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_4__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_4__1" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_4__1__Impl" |
| // InternalFSM.g:3721:1: rule__RefinedState__Group_4__1__Impl : ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) ; |
| public final void rule__RefinedState__Group_4__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3725:1: ( ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) ) |
| // InternalFSM.g:3726:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) |
| { |
| // InternalFSM.g:3726:1: ( ( rule__RefinedState__EntryCodeAssignment_4_1 ) ) |
| // InternalFSM.g:3727:1: ( rule__RefinedState__EntryCodeAssignment_4_1 ) |
| { |
| before(grammarAccess.getRefinedStateAccess().getEntryCodeAssignment_4_1()); |
| // InternalFSM.g:3728:1: ( rule__RefinedState__EntryCodeAssignment_4_1 ) |
| // InternalFSM.g:3728:2: rule__RefinedState__EntryCodeAssignment_4_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__EntryCodeAssignment_4_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getEntryCodeAssignment_4_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_4__1__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_5__0" |
| // InternalFSM.g:3742:1: rule__RefinedState__Group_5__0 : rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 ; |
| public final void rule__RefinedState__Group_5__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3746:1: ( rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 ) |
| // InternalFSM.g:3747:2: rule__RefinedState__Group_5__0__Impl rule__RefinedState__Group_5__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__RefinedState__Group_5__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_5__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_5__0" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_5__0__Impl" |
| // InternalFSM.g:3754:1: rule__RefinedState__Group_5__0__Impl : ( 'exit' ) ; |
| public final void rule__RefinedState__Group_5__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3758:1: ( ( 'exit' ) ) |
| // InternalFSM.g:3759:1: ( 'exit' ) |
| { |
| // InternalFSM.g:3759:1: ( 'exit' ) |
| // InternalFSM.g:3760:1: 'exit' |
| { |
| before(grammarAccess.getRefinedStateAccess().getExitKeyword_5_0()); |
| match(input,33,FOLLOW_2); |
| after(grammarAccess.getRefinedStateAccess().getExitKeyword_5_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_5__0__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_5__1" |
| // InternalFSM.g:3773:1: rule__RefinedState__Group_5__1 : rule__RefinedState__Group_5__1__Impl ; |
| public final void rule__RefinedState__Group_5__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3777:1: ( rule__RefinedState__Group_5__1__Impl ) |
| // InternalFSM.g:3778:2: rule__RefinedState__Group_5__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_5__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_5__1" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_5__1__Impl" |
| // InternalFSM.g:3784:1: rule__RefinedState__Group_5__1__Impl : ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) ; |
| public final void rule__RefinedState__Group_5__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3788:1: ( ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) ) |
| // InternalFSM.g:3789:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) |
| { |
| // InternalFSM.g:3789:1: ( ( rule__RefinedState__ExitCodeAssignment_5_1 ) ) |
| // InternalFSM.g:3790:1: ( rule__RefinedState__ExitCodeAssignment_5_1 ) |
| { |
| before(grammarAccess.getRefinedStateAccess().getExitCodeAssignment_5_1()); |
| // InternalFSM.g:3791:1: ( rule__RefinedState__ExitCodeAssignment_5_1 ) |
| // InternalFSM.g:3791:2: rule__RefinedState__ExitCodeAssignment_5_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__ExitCodeAssignment_5_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getExitCodeAssignment_5_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_5__1__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_6__0" |
| // InternalFSM.g:3805:1: rule__RefinedState__Group_6__0 : rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 ; |
| public final void rule__RefinedState__Group_6__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3809:1: ( rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 ) |
| // InternalFSM.g:3810:2: rule__RefinedState__Group_6__0__Impl rule__RefinedState__Group_6__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__RefinedState__Group_6__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_6__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_6__0" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_6__0__Impl" |
| // InternalFSM.g:3817:1: rule__RefinedState__Group_6__0__Impl : ( 'do' ) ; |
| public final void rule__RefinedState__Group_6__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3821:1: ( ( 'do' ) ) |
| // InternalFSM.g:3822:1: ( 'do' ) |
| { |
| // InternalFSM.g:3822:1: ( 'do' ) |
| // InternalFSM.g:3823:1: 'do' |
| { |
| before(grammarAccess.getRefinedStateAccess().getDoKeyword_6_0()); |
| match(input,34,FOLLOW_2); |
| after(grammarAccess.getRefinedStateAccess().getDoKeyword_6_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_6__0__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_6__1" |
| // InternalFSM.g:3836:1: rule__RefinedState__Group_6__1 : rule__RefinedState__Group_6__1__Impl ; |
| public final void rule__RefinedState__Group_6__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3840:1: ( rule__RefinedState__Group_6__1__Impl ) |
| // InternalFSM.g:3841:2: rule__RefinedState__Group_6__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_6__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_6__1" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_6__1__Impl" |
| // InternalFSM.g:3847:1: rule__RefinedState__Group_6__1__Impl : ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) ; |
| public final void rule__RefinedState__Group_6__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3851:1: ( ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) ) |
| // InternalFSM.g:3852:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) |
| { |
| // InternalFSM.g:3852:1: ( ( rule__RefinedState__DoCodeAssignment_6_1 ) ) |
| // InternalFSM.g:3853:1: ( rule__RefinedState__DoCodeAssignment_6_1 ) |
| { |
| before(grammarAccess.getRefinedStateAccess().getDoCodeAssignment_6_1()); |
| // InternalFSM.g:3854:1: ( rule__RefinedState__DoCodeAssignment_6_1 ) |
| // InternalFSM.g:3854:2: rule__RefinedState__DoCodeAssignment_6_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__DoCodeAssignment_6_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getDoCodeAssignment_6_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_6__1__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_7__0" |
| // InternalFSM.g:3868:1: rule__RefinedState__Group_7__0 : rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 ; |
| public final void rule__RefinedState__Group_7__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3872:1: ( rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 ) |
| // InternalFSM.g:3873:2: rule__RefinedState__Group_7__0__Impl rule__RefinedState__Group_7__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__RefinedState__Group_7__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_7__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_7__0" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_7__0__Impl" |
| // InternalFSM.g:3880:1: rule__RefinedState__Group_7__0__Impl : ( 'subgraph' ) ; |
| public final void rule__RefinedState__Group_7__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3884:1: ( ( 'subgraph' ) ) |
| // InternalFSM.g:3885:1: ( 'subgraph' ) |
| { |
| // InternalFSM.g:3885:1: ( 'subgraph' ) |
| // InternalFSM.g:3886:1: 'subgraph' |
| { |
| before(grammarAccess.getRefinedStateAccess().getSubgraphKeyword_7_0()); |
| match(input,35,FOLLOW_2); |
| after(grammarAccess.getRefinedStateAccess().getSubgraphKeyword_7_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_7__0__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_7__1" |
| // InternalFSM.g:3899:1: rule__RefinedState__Group_7__1 : rule__RefinedState__Group_7__1__Impl ; |
| public final void rule__RefinedState__Group_7__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3903:1: ( rule__RefinedState__Group_7__1__Impl ) |
| // InternalFSM.g:3904:2: rule__RefinedState__Group_7__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__Group_7__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_7__1" |
| |
| |
| // $ANTLR start "rule__RefinedState__Group_7__1__Impl" |
| // InternalFSM.g:3910:1: rule__RefinedState__Group_7__1__Impl : ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) ; |
| public final void rule__RefinedState__Group_7__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3914:1: ( ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) ) |
| // InternalFSM.g:3915:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) |
| { |
| // InternalFSM.g:3915:1: ( ( rule__RefinedState__SubgraphAssignment_7_1 ) ) |
| // InternalFSM.g:3916:1: ( rule__RefinedState__SubgraphAssignment_7_1 ) |
| { |
| before(grammarAccess.getRefinedStateAccess().getSubgraphAssignment_7_1()); |
| // InternalFSM.g:3917:1: ( rule__RefinedState__SubgraphAssignment_7_1 ) |
| // InternalFSM.g:3917:2: rule__RefinedState__SubgraphAssignment_7_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedState__SubgraphAssignment_7_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getSubgraphAssignment_7_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__Group_7__1__Impl" |
| |
| |
| // $ANTLR start "rule__DetailCode__Group__0" |
| // InternalFSM.g:3931:1: rule__DetailCode__Group__0 : rule__DetailCode__Group__0__Impl rule__DetailCode__Group__1 ; |
| public final void rule__DetailCode__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3935:1: ( rule__DetailCode__Group__0__Impl rule__DetailCode__Group__1 ) |
| // InternalFSM.g:3936:2: rule__DetailCode__Group__0__Impl rule__DetailCode__Group__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__DetailCode__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__DetailCode__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DetailCode__Group__0" |
| |
| |
| // $ANTLR start "rule__DetailCode__Group__0__Impl" |
| // InternalFSM.g:3943:1: rule__DetailCode__Group__0__Impl : ( () ) ; |
| public final void rule__DetailCode__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3947:1: ( ( () ) ) |
| // InternalFSM.g:3948:1: ( () ) |
| { |
| // InternalFSM.g:3948:1: ( () ) |
| // InternalFSM.g:3949:1: () |
| { |
| before(grammarAccess.getDetailCodeAccess().getDetailCodeAction_0()); |
| // InternalFSM.g:3950:1: () |
| // InternalFSM.g:3952:1: |
| { |
| } |
| |
| after(grammarAccess.getDetailCodeAccess().getDetailCodeAction_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DetailCode__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__DetailCode__Group__1" |
| // InternalFSM.g:3962:1: rule__DetailCode__Group__1 : rule__DetailCode__Group__1__Impl rule__DetailCode__Group__2 ; |
| public final void rule__DetailCode__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3966:1: ( rule__DetailCode__Group__1__Impl rule__DetailCode__Group__2 ) |
| // InternalFSM.g:3967:2: rule__DetailCode__Group__1__Impl rule__DetailCode__Group__2 |
| { |
| pushFollow(FOLLOW_12); |
| rule__DetailCode__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__DetailCode__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DetailCode__Group__1" |
| |
| |
| // $ANTLR start "rule__DetailCode__Group__1__Impl" |
| // InternalFSM.g:3974:1: rule__DetailCode__Group__1__Impl : ( ( rule__DetailCode__UsedAssignment_1 ) ) ; |
| public final void rule__DetailCode__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3978:1: ( ( ( rule__DetailCode__UsedAssignment_1 ) ) ) |
| // InternalFSM.g:3979:1: ( ( rule__DetailCode__UsedAssignment_1 ) ) |
| { |
| // InternalFSM.g:3979:1: ( ( rule__DetailCode__UsedAssignment_1 ) ) |
| // InternalFSM.g:3980:1: ( rule__DetailCode__UsedAssignment_1 ) |
| { |
| before(grammarAccess.getDetailCodeAccess().getUsedAssignment_1()); |
| // InternalFSM.g:3981:1: ( rule__DetailCode__UsedAssignment_1 ) |
| // InternalFSM.g:3981:2: rule__DetailCode__UsedAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__DetailCode__UsedAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getDetailCodeAccess().getUsedAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DetailCode__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__DetailCode__Group__2" |
| // InternalFSM.g:3991:1: rule__DetailCode__Group__2 : rule__DetailCode__Group__2__Impl rule__DetailCode__Group__3 ; |
| public final void rule__DetailCode__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:3995:1: ( rule__DetailCode__Group__2__Impl rule__DetailCode__Group__3 ) |
| // InternalFSM.g:3996:2: rule__DetailCode__Group__2__Impl rule__DetailCode__Group__3 |
| { |
| pushFollow(FOLLOW_12); |
| rule__DetailCode__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__DetailCode__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DetailCode__Group__2" |
| |
| |
| // $ANTLR start "rule__DetailCode__Group__2__Impl" |
| // InternalFSM.g:4003:1: rule__DetailCode__Group__2__Impl : ( ( rule__DetailCode__LinesAssignment_2 )* ) ; |
| public final void rule__DetailCode__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4007:1: ( ( ( rule__DetailCode__LinesAssignment_2 )* ) ) |
| // InternalFSM.g:4008:1: ( ( rule__DetailCode__LinesAssignment_2 )* ) |
| { |
| // InternalFSM.g:4008:1: ( ( rule__DetailCode__LinesAssignment_2 )* ) |
| // InternalFSM.g:4009:1: ( rule__DetailCode__LinesAssignment_2 )* |
| { |
| before(grammarAccess.getDetailCodeAccess().getLinesAssignment_2()); |
| // InternalFSM.g:4010:1: ( rule__DetailCode__LinesAssignment_2 )* |
| loop43: |
| do { |
| int alt43=2; |
| int LA43_0 = input.LA(1); |
| |
| if ( (LA43_0==RULE_STRING) ) { |
| alt43=1; |
| } |
| |
| |
| switch (alt43) { |
| case 1 : |
| // InternalFSM.g:4010:2: rule__DetailCode__LinesAssignment_2 |
| { |
| pushFollow(FOLLOW_13); |
| rule__DetailCode__LinesAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop43; |
| } |
| } while (true); |
| |
| after(grammarAccess.getDetailCodeAccess().getLinesAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DetailCode__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__DetailCode__Group__3" |
| // InternalFSM.g:4020:1: rule__DetailCode__Group__3 : rule__DetailCode__Group__3__Impl ; |
| public final void rule__DetailCode__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4024:1: ( rule__DetailCode__Group__3__Impl ) |
| // InternalFSM.g:4025:2: rule__DetailCode__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__DetailCode__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DetailCode__Group__3" |
| |
| |
| // $ANTLR start "rule__DetailCode__Group__3__Impl" |
| // InternalFSM.g:4031:1: rule__DetailCode__Group__3__Impl : ( '}' ) ; |
| public final void rule__DetailCode__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4035:1: ( ( '}' ) ) |
| // InternalFSM.g:4036:1: ( '}' ) |
| { |
| // InternalFSM.g:4036:1: ( '}' ) |
| // InternalFSM.g:4037:1: '}' |
| { |
| before(grammarAccess.getDetailCodeAccess().getRightCurlyBracketKeyword_3()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getDetailCodeAccess().getRightCurlyBracketKeyword_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DetailCode__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__TransitionPoint__Group__0" |
| // InternalFSM.g:4058:1: rule__TransitionPoint__Group__0 : rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 ; |
| public final void rule__TransitionPoint__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4062:1: ( rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 ) |
| // InternalFSM.g:4063:2: rule__TransitionPoint__Group__0__Impl rule__TransitionPoint__Group__1 |
| { |
| pushFollow(FOLLOW_14); |
| rule__TransitionPoint__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TransitionPoint__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TransitionPoint__Group__0" |
| |
| |
| // $ANTLR start "rule__TransitionPoint__Group__0__Impl" |
| // InternalFSM.g:4070:1: rule__TransitionPoint__Group__0__Impl : ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) ; |
| public final void rule__TransitionPoint__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4074:1: ( ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) ) |
| // InternalFSM.g:4075:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) |
| { |
| // InternalFSM.g:4075:1: ( ( rule__TransitionPoint__HandlerAssignment_0 )? ) |
| // InternalFSM.g:4076:1: ( rule__TransitionPoint__HandlerAssignment_0 )? |
| { |
| before(grammarAccess.getTransitionPointAccess().getHandlerAssignment_0()); |
| // InternalFSM.g:4077:1: ( rule__TransitionPoint__HandlerAssignment_0 )? |
| int alt44=2; |
| int LA44_0 = input.LA(1); |
| |
| if ( (LA44_0==69) ) { |
| alt44=1; |
| } |
| switch (alt44) { |
| case 1 : |
| // InternalFSM.g:4077:2: rule__TransitionPoint__HandlerAssignment_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TransitionPoint__HandlerAssignment_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getTransitionPointAccess().getHandlerAssignment_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TransitionPoint__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TransitionPoint__Group__1" |
| // InternalFSM.g:4087:1: rule__TransitionPoint__Group__1 : rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 ; |
| public final void rule__TransitionPoint__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4091:1: ( rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 ) |
| // InternalFSM.g:4092:2: rule__TransitionPoint__Group__1__Impl rule__TransitionPoint__Group__2 |
| { |
| pushFollow(FOLLOW_5); |
| rule__TransitionPoint__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TransitionPoint__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TransitionPoint__Group__1" |
| |
| |
| // $ANTLR start "rule__TransitionPoint__Group__1__Impl" |
| // InternalFSM.g:4099:1: rule__TransitionPoint__Group__1__Impl : ( 'TransitionPoint' ) ; |
| public final void rule__TransitionPoint__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4103:1: ( ( 'TransitionPoint' ) ) |
| // InternalFSM.g:4104:1: ( 'TransitionPoint' ) |
| { |
| // InternalFSM.g:4104:1: ( 'TransitionPoint' ) |
| // InternalFSM.g:4105:1: 'TransitionPoint' |
| { |
| before(grammarAccess.getTransitionPointAccess().getTransitionPointKeyword_1()); |
| match(input,37,FOLLOW_2); |
| after(grammarAccess.getTransitionPointAccess().getTransitionPointKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TransitionPoint__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TransitionPoint__Group__2" |
| // InternalFSM.g:4118:1: rule__TransitionPoint__Group__2 : rule__TransitionPoint__Group__2__Impl ; |
| public final void rule__TransitionPoint__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4122:1: ( rule__TransitionPoint__Group__2__Impl ) |
| // InternalFSM.g:4123:2: rule__TransitionPoint__Group__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__TransitionPoint__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TransitionPoint__Group__2" |
| |
| |
| // $ANTLR start "rule__TransitionPoint__Group__2__Impl" |
| // InternalFSM.g:4129:1: rule__TransitionPoint__Group__2__Impl : ( ( rule__TransitionPoint__NameAssignment_2 ) ) ; |
| public final void rule__TransitionPoint__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4133:1: ( ( ( rule__TransitionPoint__NameAssignment_2 ) ) ) |
| // InternalFSM.g:4134:1: ( ( rule__TransitionPoint__NameAssignment_2 ) ) |
| { |
| // InternalFSM.g:4134:1: ( ( rule__TransitionPoint__NameAssignment_2 ) ) |
| // InternalFSM.g:4135:1: ( rule__TransitionPoint__NameAssignment_2 ) |
| { |
| before(grammarAccess.getTransitionPointAccess().getNameAssignment_2()); |
| // InternalFSM.g:4136:1: ( rule__TransitionPoint__NameAssignment_2 ) |
| // InternalFSM.g:4136:2: rule__TransitionPoint__NameAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TransitionPoint__NameAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTransitionPointAccess().getNameAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TransitionPoint__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__EntryPoint__Group__0" |
| // InternalFSM.g:4152:1: rule__EntryPoint__Group__0 : rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 ; |
| public final void rule__EntryPoint__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4156:1: ( rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 ) |
| // InternalFSM.g:4157:2: rule__EntryPoint__Group__0__Impl rule__EntryPoint__Group__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__EntryPoint__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__EntryPoint__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EntryPoint__Group__0" |
| |
| |
| // $ANTLR start "rule__EntryPoint__Group__0__Impl" |
| // InternalFSM.g:4164:1: rule__EntryPoint__Group__0__Impl : ( 'EntryPoint' ) ; |
| public final void rule__EntryPoint__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4168:1: ( ( 'EntryPoint' ) ) |
| // InternalFSM.g:4169:1: ( 'EntryPoint' ) |
| { |
| // InternalFSM.g:4169:1: ( 'EntryPoint' ) |
| // InternalFSM.g:4170:1: 'EntryPoint' |
| { |
| before(grammarAccess.getEntryPointAccess().getEntryPointKeyword_0()); |
| match(input,38,FOLLOW_2); |
| after(grammarAccess.getEntryPointAccess().getEntryPointKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EntryPoint__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__EntryPoint__Group__1" |
| // InternalFSM.g:4183:1: rule__EntryPoint__Group__1 : rule__EntryPoint__Group__1__Impl ; |
| public final void rule__EntryPoint__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4187:1: ( rule__EntryPoint__Group__1__Impl ) |
| // InternalFSM.g:4188:2: rule__EntryPoint__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__EntryPoint__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EntryPoint__Group__1" |
| |
| |
| // $ANTLR start "rule__EntryPoint__Group__1__Impl" |
| // InternalFSM.g:4194:1: rule__EntryPoint__Group__1__Impl : ( ( rule__EntryPoint__NameAssignment_1 ) ) ; |
| public final void rule__EntryPoint__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4198:1: ( ( ( rule__EntryPoint__NameAssignment_1 ) ) ) |
| // InternalFSM.g:4199:1: ( ( rule__EntryPoint__NameAssignment_1 ) ) |
| { |
| // InternalFSM.g:4199:1: ( ( rule__EntryPoint__NameAssignment_1 ) ) |
| // InternalFSM.g:4200:1: ( rule__EntryPoint__NameAssignment_1 ) |
| { |
| before(grammarAccess.getEntryPointAccess().getNameAssignment_1()); |
| // InternalFSM.g:4201:1: ( rule__EntryPoint__NameAssignment_1 ) |
| // InternalFSM.g:4201:2: rule__EntryPoint__NameAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EntryPoint__NameAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getEntryPointAccess().getNameAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EntryPoint__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ExitPoint__Group__0" |
| // InternalFSM.g:4215:1: rule__ExitPoint__Group__0 : rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 ; |
| public final void rule__ExitPoint__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4219:1: ( rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 ) |
| // InternalFSM.g:4220:2: rule__ExitPoint__Group__0__Impl rule__ExitPoint__Group__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__ExitPoint__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ExitPoint__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExitPoint__Group__0" |
| |
| |
| // $ANTLR start "rule__ExitPoint__Group__0__Impl" |
| // InternalFSM.g:4227:1: rule__ExitPoint__Group__0__Impl : ( 'ExitPoint' ) ; |
| public final void rule__ExitPoint__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4231:1: ( ( 'ExitPoint' ) ) |
| // InternalFSM.g:4232:1: ( 'ExitPoint' ) |
| { |
| // InternalFSM.g:4232:1: ( 'ExitPoint' ) |
| // InternalFSM.g:4233:1: 'ExitPoint' |
| { |
| before(grammarAccess.getExitPointAccess().getExitPointKeyword_0()); |
| match(input,39,FOLLOW_2); |
| after(grammarAccess.getExitPointAccess().getExitPointKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExitPoint__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ExitPoint__Group__1" |
| // InternalFSM.g:4246:1: rule__ExitPoint__Group__1 : rule__ExitPoint__Group__1__Impl ; |
| public final void rule__ExitPoint__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4250:1: ( rule__ExitPoint__Group__1__Impl ) |
| // InternalFSM.g:4251:2: rule__ExitPoint__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ExitPoint__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExitPoint__Group__1" |
| |
| |
| // $ANTLR start "rule__ExitPoint__Group__1__Impl" |
| // InternalFSM.g:4257:1: rule__ExitPoint__Group__1__Impl : ( ( rule__ExitPoint__NameAssignment_1 ) ) ; |
| public final void rule__ExitPoint__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4261:1: ( ( ( rule__ExitPoint__NameAssignment_1 ) ) ) |
| // InternalFSM.g:4262:1: ( ( rule__ExitPoint__NameAssignment_1 ) ) |
| { |
| // InternalFSM.g:4262:1: ( ( rule__ExitPoint__NameAssignment_1 ) ) |
| // InternalFSM.g:4263:1: ( rule__ExitPoint__NameAssignment_1 ) |
| { |
| before(grammarAccess.getExitPointAccess().getNameAssignment_1()); |
| // InternalFSM.g:4264:1: ( rule__ExitPoint__NameAssignment_1 ) |
| // InternalFSM.g:4264:2: rule__ExitPoint__NameAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ExitPoint__NameAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getExitPointAccess().getNameAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExitPoint__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ChoicePoint__Group__0" |
| // InternalFSM.g:4278:1: rule__ChoicePoint__Group__0 : rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 ; |
| public final void rule__ChoicePoint__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4282:1: ( rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 ) |
| // InternalFSM.g:4283:2: rule__ChoicePoint__Group__0__Impl rule__ChoicePoint__Group__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__ChoicePoint__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ChoicePoint__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicePoint__Group__0" |
| |
| |
| // $ANTLR start "rule__ChoicePoint__Group__0__Impl" |
| // InternalFSM.g:4290:1: rule__ChoicePoint__Group__0__Impl : ( 'ChoicePoint' ) ; |
| public final void rule__ChoicePoint__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4294:1: ( ( 'ChoicePoint' ) ) |
| // InternalFSM.g:4295:1: ( 'ChoicePoint' ) |
| { |
| // InternalFSM.g:4295:1: ( 'ChoicePoint' ) |
| // InternalFSM.g:4296:1: 'ChoicePoint' |
| { |
| before(grammarAccess.getChoicePointAccess().getChoicePointKeyword_0()); |
| match(input,40,FOLLOW_2); |
| after(grammarAccess.getChoicePointAccess().getChoicePointKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicePoint__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ChoicePoint__Group__1" |
| // InternalFSM.g:4309:1: rule__ChoicePoint__Group__1 : rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 ; |
| public final void rule__ChoicePoint__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4313:1: ( rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 ) |
| // InternalFSM.g:4314:2: rule__ChoicePoint__Group__1__Impl rule__ChoicePoint__Group__2 |
| { |
| pushFollow(FOLLOW_15); |
| rule__ChoicePoint__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ChoicePoint__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicePoint__Group__1" |
| |
| |
| // $ANTLR start "rule__ChoicePoint__Group__1__Impl" |
| // InternalFSM.g:4321:1: rule__ChoicePoint__Group__1__Impl : ( ( rule__ChoicePoint__NameAssignment_1 ) ) ; |
| public final void rule__ChoicePoint__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4325:1: ( ( ( rule__ChoicePoint__NameAssignment_1 ) ) ) |
| // InternalFSM.g:4326:1: ( ( rule__ChoicePoint__NameAssignment_1 ) ) |
| { |
| // InternalFSM.g:4326:1: ( ( rule__ChoicePoint__NameAssignment_1 ) ) |
| // InternalFSM.g:4327:1: ( rule__ChoicePoint__NameAssignment_1 ) |
| { |
| before(grammarAccess.getChoicePointAccess().getNameAssignment_1()); |
| // InternalFSM.g:4328:1: ( rule__ChoicePoint__NameAssignment_1 ) |
| // InternalFSM.g:4328:2: rule__ChoicePoint__NameAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ChoicePoint__NameAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getChoicePointAccess().getNameAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicePoint__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ChoicePoint__Group__2" |
| // InternalFSM.g:4338:1: rule__ChoicePoint__Group__2 : rule__ChoicePoint__Group__2__Impl ; |
| public final void rule__ChoicePoint__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4342:1: ( rule__ChoicePoint__Group__2__Impl ) |
| // InternalFSM.g:4343:2: rule__ChoicePoint__Group__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ChoicePoint__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicePoint__Group__2" |
| |
| |
| // $ANTLR start "rule__ChoicePoint__Group__2__Impl" |
| // InternalFSM.g:4349:1: rule__ChoicePoint__Group__2__Impl : ( ( rule__ChoicePoint__DocuAssignment_2 )? ) ; |
| public final void rule__ChoicePoint__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4353:1: ( ( ( rule__ChoicePoint__DocuAssignment_2 )? ) ) |
| // InternalFSM.g:4354:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? ) |
| { |
| // InternalFSM.g:4354:1: ( ( rule__ChoicePoint__DocuAssignment_2 )? ) |
| // InternalFSM.g:4355:1: ( rule__ChoicePoint__DocuAssignment_2 )? |
| { |
| before(grammarAccess.getChoicePointAccess().getDocuAssignment_2()); |
| // InternalFSM.g:4356:1: ( rule__ChoicePoint__DocuAssignment_2 )? |
| int alt45=2; |
| int LA45_0 = input.LA(1); |
| |
| if ( (LA45_0==65) ) { |
| alt45=1; |
| } |
| switch (alt45) { |
| case 1 : |
| // InternalFSM.g:4356:2: rule__ChoicePoint__DocuAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ChoicePoint__DocuAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getChoicePointAccess().getDocuAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicePoint__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__0" |
| // InternalFSM.g:4372:1: rule__InitialTransition__Group__0 : rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 ; |
| public final void rule__InitialTransition__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4376:1: ( rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 ) |
| // InternalFSM.g:4377:2: rule__InitialTransition__Group__0__Impl rule__InitialTransition__Group__1 |
| { |
| pushFollow(FOLLOW_16); |
| rule__InitialTransition__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__0" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__0__Impl" |
| // InternalFSM.g:4384:1: rule__InitialTransition__Group__0__Impl : ( 'Transition' ) ; |
| public final void rule__InitialTransition__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4388:1: ( ( 'Transition' ) ) |
| // InternalFSM.g:4389:1: ( 'Transition' ) |
| { |
| // InternalFSM.g:4389:1: ( 'Transition' ) |
| // InternalFSM.g:4390:1: 'Transition' |
| { |
| before(grammarAccess.getInitialTransitionAccess().getTransitionKeyword_0()); |
| match(input,41,FOLLOW_2); |
| after(grammarAccess.getInitialTransitionAccess().getTransitionKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__1" |
| // InternalFSM.g:4403:1: rule__InitialTransition__Group__1 : rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 ; |
| public final void rule__InitialTransition__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4407:1: ( rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 ) |
| // InternalFSM.g:4408:2: rule__InitialTransition__Group__1__Impl rule__InitialTransition__Group__2 |
| { |
| pushFollow(FOLLOW_16); |
| rule__InitialTransition__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__1" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__1__Impl" |
| // InternalFSM.g:4415:1: rule__InitialTransition__Group__1__Impl : ( ( rule__InitialTransition__NameAssignment_1 )? ) ; |
| public final void rule__InitialTransition__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4419:1: ( ( ( rule__InitialTransition__NameAssignment_1 )? ) ) |
| // InternalFSM.g:4420:1: ( ( rule__InitialTransition__NameAssignment_1 )? ) |
| { |
| // InternalFSM.g:4420:1: ( ( rule__InitialTransition__NameAssignment_1 )? ) |
| // InternalFSM.g:4421:1: ( rule__InitialTransition__NameAssignment_1 )? |
| { |
| before(grammarAccess.getInitialTransitionAccess().getNameAssignment_1()); |
| // InternalFSM.g:4422:1: ( rule__InitialTransition__NameAssignment_1 )? |
| int alt46=2; |
| int LA46_0 = input.LA(1); |
| |
| if ( (LA46_0==RULE_ID) ) { |
| alt46=1; |
| } |
| switch (alt46) { |
| case 1 : |
| // InternalFSM.g:4422:2: rule__InitialTransition__NameAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__NameAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getInitialTransitionAccess().getNameAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__2" |
| // InternalFSM.g:4432:1: rule__InitialTransition__Group__2 : rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 ; |
| public final void rule__InitialTransition__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4436:1: ( rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 ) |
| // InternalFSM.g:4437:2: rule__InitialTransition__Group__2__Impl rule__InitialTransition__Group__3 |
| { |
| pushFollow(FOLLOW_17); |
| rule__InitialTransition__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__2" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__2__Impl" |
| // InternalFSM.g:4444:1: rule__InitialTransition__Group__2__Impl : ( ':' ) ; |
| public final void rule__InitialTransition__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4448:1: ( ( ':' ) ) |
| // InternalFSM.g:4449:1: ( ':' ) |
| { |
| // InternalFSM.g:4449:1: ( ':' ) |
| // InternalFSM.g:4450:1: ':' |
| { |
| before(grammarAccess.getInitialTransitionAccess().getColonKeyword_2()); |
| match(input,42,FOLLOW_2); |
| after(grammarAccess.getInitialTransitionAccess().getColonKeyword_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__3" |
| // InternalFSM.g:4463:1: rule__InitialTransition__Group__3 : rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 ; |
| public final void rule__InitialTransition__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4467:1: ( rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 ) |
| // InternalFSM.g:4468:2: rule__InitialTransition__Group__3__Impl rule__InitialTransition__Group__4 |
| { |
| pushFollow(FOLLOW_18); |
| rule__InitialTransition__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__3" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__3__Impl" |
| // InternalFSM.g:4475:1: rule__InitialTransition__Group__3__Impl : ( 'initial' ) ; |
| public final void rule__InitialTransition__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4479:1: ( ( 'initial' ) ) |
| // InternalFSM.g:4480:1: ( 'initial' ) |
| { |
| // InternalFSM.g:4480:1: ( 'initial' ) |
| // InternalFSM.g:4481:1: 'initial' |
| { |
| before(grammarAccess.getInitialTransitionAccess().getInitialKeyword_3()); |
| match(input,43,FOLLOW_2); |
| after(grammarAccess.getInitialTransitionAccess().getInitialKeyword_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__4" |
| // InternalFSM.g:4494:1: rule__InitialTransition__Group__4 : rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 ; |
| public final void rule__InitialTransition__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4498:1: ( rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 ) |
| // InternalFSM.g:4499:2: rule__InitialTransition__Group__4__Impl rule__InitialTransition__Group__5 |
| { |
| pushFollow(FOLLOW_19); |
| rule__InitialTransition__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group__5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__4" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__4__Impl" |
| // InternalFSM.g:4506:1: rule__InitialTransition__Group__4__Impl : ( '->' ) ; |
| public final void rule__InitialTransition__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4510:1: ( ( '->' ) ) |
| // InternalFSM.g:4511:1: ( '->' ) |
| { |
| // InternalFSM.g:4511:1: ( '->' ) |
| // InternalFSM.g:4512:1: '->' |
| { |
| before(grammarAccess.getInitialTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); |
| match(input,44,FOLLOW_2); |
| after(grammarAccess.getInitialTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__5" |
| // InternalFSM.g:4525:1: rule__InitialTransition__Group__5 : rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 ; |
| public final void rule__InitialTransition__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4529:1: ( rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 ) |
| // InternalFSM.g:4530:2: rule__InitialTransition__Group__5__Impl rule__InitialTransition__Group__6 |
| { |
| pushFollow(FOLLOW_10); |
| rule__InitialTransition__Group__5__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group__6(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__5" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__5__Impl" |
| // InternalFSM.g:4537:1: rule__InitialTransition__Group__5__Impl : ( ( rule__InitialTransition__ToAssignment_5 ) ) ; |
| public final void rule__InitialTransition__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4541:1: ( ( ( rule__InitialTransition__ToAssignment_5 ) ) ) |
| // InternalFSM.g:4542:1: ( ( rule__InitialTransition__ToAssignment_5 ) ) |
| { |
| // InternalFSM.g:4542:1: ( ( rule__InitialTransition__ToAssignment_5 ) ) |
| // InternalFSM.g:4543:1: ( rule__InitialTransition__ToAssignment_5 ) |
| { |
| before(grammarAccess.getInitialTransitionAccess().getToAssignment_5()); |
| // InternalFSM.g:4544:1: ( rule__InitialTransition__ToAssignment_5 ) |
| // InternalFSM.g:4544:2: rule__InitialTransition__ToAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__ToAssignment_5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInitialTransitionAccess().getToAssignment_5()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__6" |
| // InternalFSM.g:4554:1: rule__InitialTransition__Group__6 : rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 ; |
| public final void rule__InitialTransition__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4558:1: ( rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 ) |
| // InternalFSM.g:4559:2: rule__InitialTransition__Group__6__Impl rule__InitialTransition__Group__7 |
| { |
| pushFollow(FOLLOW_10); |
| rule__InitialTransition__Group__6__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group__7(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__6" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__6__Impl" |
| // InternalFSM.g:4566:1: rule__InitialTransition__Group__6__Impl : ( ( rule__InitialTransition__DocuAssignment_6 )? ) ; |
| public final void rule__InitialTransition__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4570:1: ( ( ( rule__InitialTransition__DocuAssignment_6 )? ) ) |
| // InternalFSM.g:4571:1: ( ( rule__InitialTransition__DocuAssignment_6 )? ) |
| { |
| // InternalFSM.g:4571:1: ( ( rule__InitialTransition__DocuAssignment_6 )? ) |
| // InternalFSM.g:4572:1: ( rule__InitialTransition__DocuAssignment_6 )? |
| { |
| before(grammarAccess.getInitialTransitionAccess().getDocuAssignment_6()); |
| // InternalFSM.g:4573:1: ( rule__InitialTransition__DocuAssignment_6 )? |
| int alt47=2; |
| int LA47_0 = input.LA(1); |
| |
| if ( (LA47_0==65) ) { |
| alt47=1; |
| } |
| switch (alt47) { |
| case 1 : |
| // InternalFSM.g:4573:2: rule__InitialTransition__DocuAssignment_6 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__DocuAssignment_6(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getInitialTransitionAccess().getDocuAssignment_6()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__7" |
| // InternalFSM.g:4583:1: rule__InitialTransition__Group__7 : rule__InitialTransition__Group__7__Impl ; |
| public final void rule__InitialTransition__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4587:1: ( rule__InitialTransition__Group__7__Impl ) |
| // InternalFSM.g:4588:2: rule__InitialTransition__Group__7__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group__7__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__7" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group__7__Impl" |
| // InternalFSM.g:4594:1: rule__InitialTransition__Group__7__Impl : ( ( rule__InitialTransition__Group_7__0 )? ) ; |
| public final void rule__InitialTransition__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4598:1: ( ( ( rule__InitialTransition__Group_7__0 )? ) ) |
| // InternalFSM.g:4599:1: ( ( rule__InitialTransition__Group_7__0 )? ) |
| { |
| // InternalFSM.g:4599:1: ( ( rule__InitialTransition__Group_7__0 )? ) |
| // InternalFSM.g:4600:1: ( rule__InitialTransition__Group_7__0 )? |
| { |
| before(grammarAccess.getInitialTransitionAccess().getGroup_7()); |
| // InternalFSM.g:4601:1: ( rule__InitialTransition__Group_7__0 )? |
| int alt48=2; |
| int LA48_0 = input.LA(1); |
| |
| if ( (LA48_0==28) ) { |
| alt48=1; |
| } |
| switch (alt48) { |
| case 1 : |
| // InternalFSM.g:4601:2: rule__InitialTransition__Group_7__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group_7__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getInitialTransitionAccess().getGroup_7()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group_7__0" |
| // InternalFSM.g:4627:1: rule__InitialTransition__Group_7__0 : rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 ; |
| public final void rule__InitialTransition__Group_7__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4631:1: ( rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 ) |
| // InternalFSM.g:4632:2: rule__InitialTransition__Group_7__0__Impl rule__InitialTransition__Group_7__1 |
| { |
| pushFollow(FOLLOW_20); |
| rule__InitialTransition__Group_7__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group_7__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group_7__0" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group_7__0__Impl" |
| // InternalFSM.g:4639:1: rule__InitialTransition__Group_7__0__Impl : ( '{' ) ; |
| public final void rule__InitialTransition__Group_7__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4643:1: ( ( '{' ) ) |
| // InternalFSM.g:4644:1: ( '{' ) |
| { |
| // InternalFSM.g:4644:1: ( '{' ) |
| // InternalFSM.g:4645:1: '{' |
| { |
| before(grammarAccess.getInitialTransitionAccess().getLeftCurlyBracketKeyword_7_0()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getInitialTransitionAccess().getLeftCurlyBracketKeyword_7_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group_7__0__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group_7__1" |
| // InternalFSM.g:4658:1: rule__InitialTransition__Group_7__1 : rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 ; |
| public final void rule__InitialTransition__Group_7__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4662:1: ( rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 ) |
| // InternalFSM.g:4663:2: rule__InitialTransition__Group_7__1__Impl rule__InitialTransition__Group_7__2 |
| { |
| pushFollow(FOLLOW_20); |
| rule__InitialTransition__Group_7__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group_7__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group_7__1" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group_7__1__Impl" |
| // InternalFSM.g:4670:1: rule__InitialTransition__Group_7__1__Impl : ( ( rule__InitialTransition__Group_7_1__0 )? ) ; |
| public final void rule__InitialTransition__Group_7__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4674:1: ( ( ( rule__InitialTransition__Group_7_1__0 )? ) ) |
| // InternalFSM.g:4675:1: ( ( rule__InitialTransition__Group_7_1__0 )? ) |
| { |
| // InternalFSM.g:4675:1: ( ( rule__InitialTransition__Group_7_1__0 )? ) |
| // InternalFSM.g:4676:1: ( rule__InitialTransition__Group_7_1__0 )? |
| { |
| before(grammarAccess.getInitialTransitionAccess().getGroup_7_1()); |
| // InternalFSM.g:4677:1: ( rule__InitialTransition__Group_7_1__0 )? |
| int alt49=2; |
| int LA49_0 = input.LA(1); |
| |
| if ( (LA49_0==45) ) { |
| alt49=1; |
| } |
| switch (alt49) { |
| case 1 : |
| // InternalFSM.g:4677:2: rule__InitialTransition__Group_7_1__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group_7_1__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getInitialTransitionAccess().getGroup_7_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group_7__1__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group_7__2" |
| // InternalFSM.g:4687:1: rule__InitialTransition__Group_7__2 : rule__InitialTransition__Group_7__2__Impl ; |
| public final void rule__InitialTransition__Group_7__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4691:1: ( rule__InitialTransition__Group_7__2__Impl ) |
| // InternalFSM.g:4692:2: rule__InitialTransition__Group_7__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group_7__2__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group_7__2" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group_7__2__Impl" |
| // InternalFSM.g:4698:1: rule__InitialTransition__Group_7__2__Impl : ( '}' ) ; |
| public final void rule__InitialTransition__Group_7__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4702:1: ( ( '}' ) ) |
| // InternalFSM.g:4703:1: ( '}' ) |
| { |
| // InternalFSM.g:4703:1: ( '}' ) |
| // InternalFSM.g:4704:1: '}' |
| { |
| before(grammarAccess.getInitialTransitionAccess().getRightCurlyBracketKeyword_7_2()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getInitialTransitionAccess().getRightCurlyBracketKeyword_7_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group_7__2__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group_7_1__0" |
| // InternalFSM.g:4723:1: rule__InitialTransition__Group_7_1__0 : rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 ; |
| public final void rule__InitialTransition__Group_7_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4727:1: ( rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 ) |
| // InternalFSM.g:4728:2: rule__InitialTransition__Group_7_1__0__Impl rule__InitialTransition__Group_7_1__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__InitialTransition__Group_7_1__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group_7_1__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group_7_1__0" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group_7_1__0__Impl" |
| // InternalFSM.g:4735:1: rule__InitialTransition__Group_7_1__0__Impl : ( 'action' ) ; |
| public final void rule__InitialTransition__Group_7_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4739:1: ( ( 'action' ) ) |
| // InternalFSM.g:4740:1: ( 'action' ) |
| { |
| // InternalFSM.g:4740:1: ( 'action' ) |
| // InternalFSM.g:4741:1: 'action' |
| { |
| before(grammarAccess.getInitialTransitionAccess().getActionKeyword_7_1_0()); |
| match(input,45,FOLLOW_2); |
| after(grammarAccess.getInitialTransitionAccess().getActionKeyword_7_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group_7_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group_7_1__1" |
| // InternalFSM.g:4754:1: rule__InitialTransition__Group_7_1__1 : rule__InitialTransition__Group_7_1__1__Impl ; |
| public final void rule__InitialTransition__Group_7_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4758:1: ( rule__InitialTransition__Group_7_1__1__Impl ) |
| // InternalFSM.g:4759:2: rule__InitialTransition__Group_7_1__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__Group_7_1__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group_7_1__1" |
| |
| |
| // $ANTLR start "rule__InitialTransition__Group_7_1__1__Impl" |
| // InternalFSM.g:4765:1: rule__InitialTransition__Group_7_1__1__Impl : ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) ; |
| public final void rule__InitialTransition__Group_7_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4769:1: ( ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) ) |
| // InternalFSM.g:4770:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) |
| { |
| // InternalFSM.g:4770:1: ( ( rule__InitialTransition__ActionAssignment_7_1_1 ) ) |
| // InternalFSM.g:4771:1: ( rule__InitialTransition__ActionAssignment_7_1_1 ) |
| { |
| before(grammarAccess.getInitialTransitionAccess().getActionAssignment_7_1_1()); |
| // InternalFSM.g:4772:1: ( rule__InitialTransition__ActionAssignment_7_1_1 ) |
| // InternalFSM.g:4772:2: rule__InitialTransition__ActionAssignment_7_1_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InitialTransition__ActionAssignment_7_1_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInitialTransitionAccess().getActionAssignment_7_1_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__Group_7_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__0" |
| // InternalFSM.g:4786:1: rule__ContinuationTransition__Group__0 : rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 ; |
| public final void rule__ContinuationTransition__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4790:1: ( rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 ) |
| // InternalFSM.g:4791:2: rule__ContinuationTransition__Group__0__Impl rule__ContinuationTransition__Group__1 |
| { |
| pushFollow(FOLLOW_16); |
| rule__ContinuationTransition__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__0" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__0__Impl" |
| // InternalFSM.g:4798:1: rule__ContinuationTransition__Group__0__Impl : ( 'Transition' ) ; |
| public final void rule__ContinuationTransition__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4802:1: ( ( 'Transition' ) ) |
| // InternalFSM.g:4803:1: ( 'Transition' ) |
| { |
| // InternalFSM.g:4803:1: ( 'Transition' ) |
| // InternalFSM.g:4804:1: 'Transition' |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getTransitionKeyword_0()); |
| match(input,41,FOLLOW_2); |
| after(grammarAccess.getContinuationTransitionAccess().getTransitionKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__1" |
| // InternalFSM.g:4817:1: rule__ContinuationTransition__Group__1 : rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 ; |
| public final void rule__ContinuationTransition__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4821:1: ( rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 ) |
| // InternalFSM.g:4822:2: rule__ContinuationTransition__Group__1__Impl rule__ContinuationTransition__Group__2 |
| { |
| pushFollow(FOLLOW_16); |
| rule__ContinuationTransition__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__1" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__1__Impl" |
| // InternalFSM.g:4829:1: rule__ContinuationTransition__Group__1__Impl : ( ( rule__ContinuationTransition__NameAssignment_1 )? ) ; |
| public final void rule__ContinuationTransition__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4833:1: ( ( ( rule__ContinuationTransition__NameAssignment_1 )? ) ) |
| // InternalFSM.g:4834:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? ) |
| { |
| // InternalFSM.g:4834:1: ( ( rule__ContinuationTransition__NameAssignment_1 )? ) |
| // InternalFSM.g:4835:1: ( rule__ContinuationTransition__NameAssignment_1 )? |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getNameAssignment_1()); |
| // InternalFSM.g:4836:1: ( rule__ContinuationTransition__NameAssignment_1 )? |
| int alt50=2; |
| int LA50_0 = input.LA(1); |
| |
| if ( (LA50_0==RULE_ID) ) { |
| alt50=1; |
| } |
| switch (alt50) { |
| case 1 : |
| // InternalFSM.g:4836:2: rule__ContinuationTransition__NameAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__NameAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getContinuationTransitionAccess().getNameAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__2" |
| // InternalFSM.g:4846:1: rule__ContinuationTransition__Group__2 : rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 ; |
| public final void rule__ContinuationTransition__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4850:1: ( rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 ) |
| // InternalFSM.g:4851:2: rule__ContinuationTransition__Group__2__Impl rule__ContinuationTransition__Group__3 |
| { |
| pushFollow(FOLLOW_19); |
| rule__ContinuationTransition__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__2" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__2__Impl" |
| // InternalFSM.g:4858:1: rule__ContinuationTransition__Group__2__Impl : ( ':' ) ; |
| public final void rule__ContinuationTransition__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4862:1: ( ( ':' ) ) |
| // InternalFSM.g:4863:1: ( ':' ) |
| { |
| // InternalFSM.g:4863:1: ( ':' ) |
| // InternalFSM.g:4864:1: ':' |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getColonKeyword_2()); |
| match(input,42,FOLLOW_2); |
| after(grammarAccess.getContinuationTransitionAccess().getColonKeyword_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__3" |
| // InternalFSM.g:4877:1: rule__ContinuationTransition__Group__3 : rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 ; |
| public final void rule__ContinuationTransition__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4881:1: ( rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 ) |
| // InternalFSM.g:4882:2: rule__ContinuationTransition__Group__3__Impl rule__ContinuationTransition__Group__4 |
| { |
| pushFollow(FOLLOW_18); |
| rule__ContinuationTransition__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__3" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__3__Impl" |
| // InternalFSM.g:4889:1: rule__ContinuationTransition__Group__3__Impl : ( ( rule__ContinuationTransition__FromAssignment_3 ) ) ; |
| public final void rule__ContinuationTransition__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4893:1: ( ( ( rule__ContinuationTransition__FromAssignment_3 ) ) ) |
| // InternalFSM.g:4894:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) ) |
| { |
| // InternalFSM.g:4894:1: ( ( rule__ContinuationTransition__FromAssignment_3 ) ) |
| // InternalFSM.g:4895:1: ( rule__ContinuationTransition__FromAssignment_3 ) |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getFromAssignment_3()); |
| // InternalFSM.g:4896:1: ( rule__ContinuationTransition__FromAssignment_3 ) |
| // InternalFSM.g:4896:2: rule__ContinuationTransition__FromAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__FromAssignment_3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getContinuationTransitionAccess().getFromAssignment_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__4" |
| // InternalFSM.g:4906:1: rule__ContinuationTransition__Group__4 : rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 ; |
| public final void rule__ContinuationTransition__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4910:1: ( rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 ) |
| // InternalFSM.g:4911:2: rule__ContinuationTransition__Group__4__Impl rule__ContinuationTransition__Group__5 |
| { |
| pushFollow(FOLLOW_19); |
| rule__ContinuationTransition__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group__5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__4" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__4__Impl" |
| // InternalFSM.g:4918:1: rule__ContinuationTransition__Group__4__Impl : ( '->' ) ; |
| public final void rule__ContinuationTransition__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4922:1: ( ( '->' ) ) |
| // InternalFSM.g:4923:1: ( '->' ) |
| { |
| // InternalFSM.g:4923:1: ( '->' ) |
| // InternalFSM.g:4924:1: '->' |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); |
| match(input,44,FOLLOW_2); |
| after(grammarAccess.getContinuationTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__5" |
| // InternalFSM.g:4937:1: rule__ContinuationTransition__Group__5 : rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 ; |
| public final void rule__ContinuationTransition__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4941:1: ( rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 ) |
| // InternalFSM.g:4942:2: rule__ContinuationTransition__Group__5__Impl rule__ContinuationTransition__Group__6 |
| { |
| pushFollow(FOLLOW_10); |
| rule__ContinuationTransition__Group__5__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group__6(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__5" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__5__Impl" |
| // InternalFSM.g:4949:1: rule__ContinuationTransition__Group__5__Impl : ( ( rule__ContinuationTransition__ToAssignment_5 ) ) ; |
| public final void rule__ContinuationTransition__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4953:1: ( ( ( rule__ContinuationTransition__ToAssignment_5 ) ) ) |
| // InternalFSM.g:4954:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) ) |
| { |
| // InternalFSM.g:4954:1: ( ( rule__ContinuationTransition__ToAssignment_5 ) ) |
| // InternalFSM.g:4955:1: ( rule__ContinuationTransition__ToAssignment_5 ) |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getToAssignment_5()); |
| // InternalFSM.g:4956:1: ( rule__ContinuationTransition__ToAssignment_5 ) |
| // InternalFSM.g:4956:2: rule__ContinuationTransition__ToAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__ToAssignment_5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getContinuationTransitionAccess().getToAssignment_5()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__6" |
| // InternalFSM.g:4966:1: rule__ContinuationTransition__Group__6 : rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 ; |
| public final void rule__ContinuationTransition__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4970:1: ( rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 ) |
| // InternalFSM.g:4971:2: rule__ContinuationTransition__Group__6__Impl rule__ContinuationTransition__Group__7 |
| { |
| pushFollow(FOLLOW_10); |
| rule__ContinuationTransition__Group__6__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group__7(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__6" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__6__Impl" |
| // InternalFSM.g:4978:1: rule__ContinuationTransition__Group__6__Impl : ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) ; |
| public final void rule__ContinuationTransition__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4982:1: ( ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) ) |
| // InternalFSM.g:4983:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) |
| { |
| // InternalFSM.g:4983:1: ( ( rule__ContinuationTransition__DocuAssignment_6 )? ) |
| // InternalFSM.g:4984:1: ( rule__ContinuationTransition__DocuAssignment_6 )? |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getDocuAssignment_6()); |
| // InternalFSM.g:4985:1: ( rule__ContinuationTransition__DocuAssignment_6 )? |
| int alt51=2; |
| int LA51_0 = input.LA(1); |
| |
| if ( (LA51_0==65) ) { |
| alt51=1; |
| } |
| switch (alt51) { |
| case 1 : |
| // InternalFSM.g:4985:2: rule__ContinuationTransition__DocuAssignment_6 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__DocuAssignment_6(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getContinuationTransitionAccess().getDocuAssignment_6()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__7" |
| // InternalFSM.g:4995:1: rule__ContinuationTransition__Group__7 : rule__ContinuationTransition__Group__7__Impl ; |
| public final void rule__ContinuationTransition__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:4999:1: ( rule__ContinuationTransition__Group__7__Impl ) |
| // InternalFSM.g:5000:2: rule__ContinuationTransition__Group__7__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group__7__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__7" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group__7__Impl" |
| // InternalFSM.g:5006:1: rule__ContinuationTransition__Group__7__Impl : ( ( rule__ContinuationTransition__Group_7__0 )? ) ; |
| public final void rule__ContinuationTransition__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5010:1: ( ( ( rule__ContinuationTransition__Group_7__0 )? ) ) |
| // InternalFSM.g:5011:1: ( ( rule__ContinuationTransition__Group_7__0 )? ) |
| { |
| // InternalFSM.g:5011:1: ( ( rule__ContinuationTransition__Group_7__0 )? ) |
| // InternalFSM.g:5012:1: ( rule__ContinuationTransition__Group_7__0 )? |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getGroup_7()); |
| // InternalFSM.g:5013:1: ( rule__ContinuationTransition__Group_7__0 )? |
| int alt52=2; |
| int LA52_0 = input.LA(1); |
| |
| if ( (LA52_0==28) ) { |
| alt52=1; |
| } |
| switch (alt52) { |
| case 1 : |
| // InternalFSM.g:5013:2: rule__ContinuationTransition__Group_7__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group_7__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getContinuationTransitionAccess().getGroup_7()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group_7__0" |
| // InternalFSM.g:5039:1: rule__ContinuationTransition__Group_7__0 : rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 ; |
| public final void rule__ContinuationTransition__Group_7__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5043:1: ( rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 ) |
| // InternalFSM.g:5044:2: rule__ContinuationTransition__Group_7__0__Impl rule__ContinuationTransition__Group_7__1 |
| { |
| pushFollow(FOLLOW_20); |
| rule__ContinuationTransition__Group_7__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group_7__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group_7__0" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group_7__0__Impl" |
| // InternalFSM.g:5051:1: rule__ContinuationTransition__Group_7__0__Impl : ( '{' ) ; |
| public final void rule__ContinuationTransition__Group_7__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5055:1: ( ( '{' ) ) |
| // InternalFSM.g:5056:1: ( '{' ) |
| { |
| // InternalFSM.g:5056:1: ( '{' ) |
| // InternalFSM.g:5057:1: '{' |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getLeftCurlyBracketKeyword_7_0()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getContinuationTransitionAccess().getLeftCurlyBracketKeyword_7_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group_7__0__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group_7__1" |
| // InternalFSM.g:5070:1: rule__ContinuationTransition__Group_7__1 : rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 ; |
| public final void rule__ContinuationTransition__Group_7__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5074:1: ( rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 ) |
| // InternalFSM.g:5075:2: rule__ContinuationTransition__Group_7__1__Impl rule__ContinuationTransition__Group_7__2 |
| { |
| pushFollow(FOLLOW_20); |
| rule__ContinuationTransition__Group_7__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group_7__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group_7__1" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group_7__1__Impl" |
| // InternalFSM.g:5082:1: rule__ContinuationTransition__Group_7__1__Impl : ( ( rule__ContinuationTransition__Group_7_1__0 )? ) ; |
| public final void rule__ContinuationTransition__Group_7__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5086:1: ( ( ( rule__ContinuationTransition__Group_7_1__0 )? ) ) |
| // InternalFSM.g:5087:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? ) |
| { |
| // InternalFSM.g:5087:1: ( ( rule__ContinuationTransition__Group_7_1__0 )? ) |
| // InternalFSM.g:5088:1: ( rule__ContinuationTransition__Group_7_1__0 )? |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getGroup_7_1()); |
| // InternalFSM.g:5089:1: ( rule__ContinuationTransition__Group_7_1__0 )? |
| int alt53=2; |
| int LA53_0 = input.LA(1); |
| |
| if ( (LA53_0==45) ) { |
| alt53=1; |
| } |
| switch (alt53) { |
| case 1 : |
| // InternalFSM.g:5089:2: rule__ContinuationTransition__Group_7_1__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group_7_1__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getContinuationTransitionAccess().getGroup_7_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group_7__1__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group_7__2" |
| // InternalFSM.g:5099:1: rule__ContinuationTransition__Group_7__2 : rule__ContinuationTransition__Group_7__2__Impl ; |
| public final void rule__ContinuationTransition__Group_7__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5103:1: ( rule__ContinuationTransition__Group_7__2__Impl ) |
| // InternalFSM.g:5104:2: rule__ContinuationTransition__Group_7__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group_7__2__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group_7__2" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group_7__2__Impl" |
| // InternalFSM.g:5110:1: rule__ContinuationTransition__Group_7__2__Impl : ( '}' ) ; |
| public final void rule__ContinuationTransition__Group_7__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5114:1: ( ( '}' ) ) |
| // InternalFSM.g:5115:1: ( '}' ) |
| { |
| // InternalFSM.g:5115:1: ( '}' ) |
| // InternalFSM.g:5116:1: '}' |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getRightCurlyBracketKeyword_7_2()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getContinuationTransitionAccess().getRightCurlyBracketKeyword_7_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group_7__2__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group_7_1__0" |
| // InternalFSM.g:5135:1: rule__ContinuationTransition__Group_7_1__0 : rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 ; |
| public final void rule__ContinuationTransition__Group_7_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5139:1: ( rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 ) |
| // InternalFSM.g:5140:2: rule__ContinuationTransition__Group_7_1__0__Impl rule__ContinuationTransition__Group_7_1__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__ContinuationTransition__Group_7_1__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group_7_1__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group_7_1__0" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group_7_1__0__Impl" |
| // InternalFSM.g:5147:1: rule__ContinuationTransition__Group_7_1__0__Impl : ( 'action' ) ; |
| public final void rule__ContinuationTransition__Group_7_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5151:1: ( ( 'action' ) ) |
| // InternalFSM.g:5152:1: ( 'action' ) |
| { |
| // InternalFSM.g:5152:1: ( 'action' ) |
| // InternalFSM.g:5153:1: 'action' |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getActionKeyword_7_1_0()); |
| match(input,45,FOLLOW_2); |
| after(grammarAccess.getContinuationTransitionAccess().getActionKeyword_7_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group_7_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group_7_1__1" |
| // InternalFSM.g:5166:1: rule__ContinuationTransition__Group_7_1__1 : rule__ContinuationTransition__Group_7_1__1__Impl ; |
| public final void rule__ContinuationTransition__Group_7_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5170:1: ( rule__ContinuationTransition__Group_7_1__1__Impl ) |
| // InternalFSM.g:5171:2: rule__ContinuationTransition__Group_7_1__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__Group_7_1__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group_7_1__1" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__Group_7_1__1__Impl" |
| // InternalFSM.g:5177:1: rule__ContinuationTransition__Group_7_1__1__Impl : ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) ; |
| public final void rule__ContinuationTransition__Group_7_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5181:1: ( ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) ) |
| // InternalFSM.g:5182:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) |
| { |
| // InternalFSM.g:5182:1: ( ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) ) |
| // InternalFSM.g:5183:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getActionAssignment_7_1_1()); |
| // InternalFSM.g:5184:1: ( rule__ContinuationTransition__ActionAssignment_7_1_1 ) |
| // InternalFSM.g:5184:2: rule__ContinuationTransition__ActionAssignment_7_1_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ContinuationTransition__ActionAssignment_7_1_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getContinuationTransitionAccess().getActionAssignment_7_1_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__Group_7_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__0" |
| // InternalFSM.g:5198:1: rule__TriggeredTransition__Group__0 : rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 ; |
| public final void rule__TriggeredTransition__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5202:1: ( rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 ) |
| // InternalFSM.g:5203:2: rule__TriggeredTransition__Group__0__Impl rule__TriggeredTransition__Group__1 |
| { |
| pushFollow(FOLLOW_16); |
| rule__TriggeredTransition__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__0" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__0__Impl" |
| // InternalFSM.g:5210:1: rule__TriggeredTransition__Group__0__Impl : ( 'Transition' ) ; |
| public final void rule__TriggeredTransition__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5214:1: ( ( 'Transition' ) ) |
| // InternalFSM.g:5215:1: ( 'Transition' ) |
| { |
| // InternalFSM.g:5215:1: ( 'Transition' ) |
| // InternalFSM.g:5216:1: 'Transition' |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getTransitionKeyword_0()); |
| match(input,41,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getTransitionKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__1" |
| // InternalFSM.g:5229:1: rule__TriggeredTransition__Group__1 : rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 ; |
| public final void rule__TriggeredTransition__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5233:1: ( rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 ) |
| // InternalFSM.g:5234:2: rule__TriggeredTransition__Group__1__Impl rule__TriggeredTransition__Group__2 |
| { |
| pushFollow(FOLLOW_16); |
| rule__TriggeredTransition__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__1" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__1__Impl" |
| // InternalFSM.g:5241:1: rule__TriggeredTransition__Group__1__Impl : ( ( rule__TriggeredTransition__NameAssignment_1 )? ) ; |
| public final void rule__TriggeredTransition__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5245:1: ( ( ( rule__TriggeredTransition__NameAssignment_1 )? ) ) |
| // InternalFSM.g:5246:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? ) |
| { |
| // InternalFSM.g:5246:1: ( ( rule__TriggeredTransition__NameAssignment_1 )? ) |
| // InternalFSM.g:5247:1: ( rule__TriggeredTransition__NameAssignment_1 )? |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getNameAssignment_1()); |
| // InternalFSM.g:5248:1: ( rule__TriggeredTransition__NameAssignment_1 )? |
| int alt54=2; |
| int LA54_0 = input.LA(1); |
| |
| if ( (LA54_0==RULE_ID) ) { |
| alt54=1; |
| } |
| switch (alt54) { |
| case 1 : |
| // InternalFSM.g:5248:2: rule__TriggeredTransition__NameAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__NameAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getNameAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__2" |
| // InternalFSM.g:5258:1: rule__TriggeredTransition__Group__2 : rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 ; |
| public final void rule__TriggeredTransition__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5262:1: ( rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 ) |
| // InternalFSM.g:5263:2: rule__TriggeredTransition__Group__2__Impl rule__TriggeredTransition__Group__3 |
| { |
| pushFollow(FOLLOW_19); |
| rule__TriggeredTransition__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__2" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__2__Impl" |
| // InternalFSM.g:5270:1: rule__TriggeredTransition__Group__2__Impl : ( ':' ) ; |
| public final void rule__TriggeredTransition__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5274:1: ( ( ':' ) ) |
| // InternalFSM.g:5275:1: ( ':' ) |
| { |
| // InternalFSM.g:5275:1: ( ':' ) |
| // InternalFSM.g:5276:1: ':' |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getColonKeyword_2()); |
| match(input,42,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getColonKeyword_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__3" |
| // InternalFSM.g:5289:1: rule__TriggeredTransition__Group__3 : rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 ; |
| public final void rule__TriggeredTransition__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5293:1: ( rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 ) |
| // InternalFSM.g:5294:2: rule__TriggeredTransition__Group__3__Impl rule__TriggeredTransition__Group__4 |
| { |
| pushFollow(FOLLOW_18); |
| rule__TriggeredTransition__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__3" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__3__Impl" |
| // InternalFSM.g:5301:1: rule__TriggeredTransition__Group__3__Impl : ( ( rule__TriggeredTransition__FromAssignment_3 ) ) ; |
| public final void rule__TriggeredTransition__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5305:1: ( ( ( rule__TriggeredTransition__FromAssignment_3 ) ) ) |
| // InternalFSM.g:5306:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) ) |
| { |
| // InternalFSM.g:5306:1: ( ( rule__TriggeredTransition__FromAssignment_3 ) ) |
| // InternalFSM.g:5307:1: ( rule__TriggeredTransition__FromAssignment_3 ) |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getFromAssignment_3()); |
| // InternalFSM.g:5308:1: ( rule__TriggeredTransition__FromAssignment_3 ) |
| // InternalFSM.g:5308:2: rule__TriggeredTransition__FromAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__FromAssignment_3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getFromAssignment_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__4" |
| // InternalFSM.g:5318:1: rule__TriggeredTransition__Group__4 : rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 ; |
| public final void rule__TriggeredTransition__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5322:1: ( rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 ) |
| // InternalFSM.g:5323:2: rule__TriggeredTransition__Group__4__Impl rule__TriggeredTransition__Group__5 |
| { |
| pushFollow(FOLLOW_19); |
| rule__TriggeredTransition__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__4" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__4__Impl" |
| // InternalFSM.g:5330:1: rule__TriggeredTransition__Group__4__Impl : ( '->' ) ; |
| public final void rule__TriggeredTransition__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5334:1: ( ( '->' ) ) |
| // InternalFSM.g:5335:1: ( '->' ) |
| { |
| // InternalFSM.g:5335:1: ( '->' ) |
| // InternalFSM.g:5336:1: '->' |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); |
| match(input,44,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__5" |
| // InternalFSM.g:5349:1: rule__TriggeredTransition__Group__5 : rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 ; |
| public final void rule__TriggeredTransition__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5353:1: ( rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 ) |
| // InternalFSM.g:5354:2: rule__TriggeredTransition__Group__5__Impl rule__TriggeredTransition__Group__6 |
| { |
| pushFollow(FOLLOW_10); |
| rule__TriggeredTransition__Group__5__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__6(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__5" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__5__Impl" |
| // InternalFSM.g:5361:1: rule__TriggeredTransition__Group__5__Impl : ( ( rule__TriggeredTransition__ToAssignment_5 ) ) ; |
| public final void rule__TriggeredTransition__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5365:1: ( ( ( rule__TriggeredTransition__ToAssignment_5 ) ) ) |
| // InternalFSM.g:5366:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) ) |
| { |
| // InternalFSM.g:5366:1: ( ( rule__TriggeredTransition__ToAssignment_5 ) ) |
| // InternalFSM.g:5367:1: ( rule__TriggeredTransition__ToAssignment_5 ) |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getToAssignment_5()); |
| // InternalFSM.g:5368:1: ( rule__TriggeredTransition__ToAssignment_5 ) |
| // InternalFSM.g:5368:2: rule__TriggeredTransition__ToAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__ToAssignment_5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getToAssignment_5()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__6" |
| // InternalFSM.g:5378:1: rule__TriggeredTransition__Group__6 : rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 ; |
| public final void rule__TriggeredTransition__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5382:1: ( rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 ) |
| // InternalFSM.g:5383:2: rule__TriggeredTransition__Group__6__Impl rule__TriggeredTransition__Group__7 |
| { |
| pushFollow(FOLLOW_10); |
| rule__TriggeredTransition__Group__6__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__7(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__6" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__6__Impl" |
| // InternalFSM.g:5390:1: rule__TriggeredTransition__Group__6__Impl : ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) ; |
| public final void rule__TriggeredTransition__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5394:1: ( ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) ) |
| // InternalFSM.g:5395:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) |
| { |
| // InternalFSM.g:5395:1: ( ( rule__TriggeredTransition__DocuAssignment_6 )? ) |
| // InternalFSM.g:5396:1: ( rule__TriggeredTransition__DocuAssignment_6 )? |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getDocuAssignment_6()); |
| // InternalFSM.g:5397:1: ( rule__TriggeredTransition__DocuAssignment_6 )? |
| int alt55=2; |
| int LA55_0 = input.LA(1); |
| |
| if ( (LA55_0==65) ) { |
| alt55=1; |
| } |
| switch (alt55) { |
| case 1 : |
| // InternalFSM.g:5397:2: rule__TriggeredTransition__DocuAssignment_6 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__DocuAssignment_6(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getDocuAssignment_6()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__7" |
| // InternalFSM.g:5407:1: rule__TriggeredTransition__Group__7 : rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 ; |
| public final void rule__TriggeredTransition__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5411:1: ( rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 ) |
| // InternalFSM.g:5412:2: rule__TriggeredTransition__Group__7__Impl rule__TriggeredTransition__Group__8 |
| { |
| pushFollow(FOLLOW_21); |
| rule__TriggeredTransition__Group__7__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__8(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__7" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__7__Impl" |
| // InternalFSM.g:5419:1: rule__TriggeredTransition__Group__7__Impl : ( '{' ) ; |
| public final void rule__TriggeredTransition__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5423:1: ( ( '{' ) ) |
| // InternalFSM.g:5424:1: ( '{' ) |
| { |
| // InternalFSM.g:5424:1: ( '{' ) |
| // InternalFSM.g:5425:1: '{' |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_7()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_7()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__8" |
| // InternalFSM.g:5438:1: rule__TriggeredTransition__Group__8 : rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 ; |
| public final void rule__TriggeredTransition__Group__8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5442:1: ( rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 ) |
| // InternalFSM.g:5443:2: rule__TriggeredTransition__Group__8__Impl rule__TriggeredTransition__Group__9 |
| { |
| pushFollow(FOLLOW_7); |
| rule__TriggeredTransition__Group__8__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__9(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__8" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__8__Impl" |
| // InternalFSM.g:5450:1: rule__TriggeredTransition__Group__8__Impl : ( 'triggers' ) ; |
| public final void rule__TriggeredTransition__Group__8__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5454:1: ( ( 'triggers' ) ) |
| // InternalFSM.g:5455:1: ( 'triggers' ) |
| { |
| // InternalFSM.g:5455:1: ( 'triggers' ) |
| // InternalFSM.g:5456:1: 'triggers' |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getTriggersKeyword_8()); |
| match(input,46,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getTriggersKeyword_8()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__8__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__9" |
| // InternalFSM.g:5469:1: rule__TriggeredTransition__Group__9 : rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 ; |
| public final void rule__TriggeredTransition__Group__9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5473:1: ( rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 ) |
| // InternalFSM.g:5474:2: rule__TriggeredTransition__Group__9__Impl rule__TriggeredTransition__Group__10 |
| { |
| pushFollow(FOLLOW_22); |
| rule__TriggeredTransition__Group__9__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__10(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__9" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__9__Impl" |
| // InternalFSM.g:5481:1: rule__TriggeredTransition__Group__9__Impl : ( '{' ) ; |
| public final void rule__TriggeredTransition__Group__9__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5485:1: ( ( '{' ) ) |
| // InternalFSM.g:5486:1: ( '{' ) |
| { |
| // InternalFSM.g:5486:1: ( '{' ) |
| // InternalFSM.g:5487:1: '{' |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_9()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_9()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__9__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__10" |
| // InternalFSM.g:5500:1: rule__TriggeredTransition__Group__10 : rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 ; |
| public final void rule__TriggeredTransition__Group__10() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5504:1: ( rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 ) |
| // InternalFSM.g:5505:2: rule__TriggeredTransition__Group__10__Impl rule__TriggeredTransition__Group__11 |
| { |
| pushFollow(FOLLOW_23); |
| rule__TriggeredTransition__Group__10__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__11(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__10" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__10__Impl" |
| // InternalFSM.g:5512:1: rule__TriggeredTransition__Group__10__Impl : ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) ; |
| public final void rule__TriggeredTransition__Group__10__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5516:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) ) |
| // InternalFSM.g:5517:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) |
| { |
| // InternalFSM.g:5517:1: ( ( rule__TriggeredTransition__TriggersAssignment_10 ) ) |
| // InternalFSM.g:5518:1: ( rule__TriggeredTransition__TriggersAssignment_10 ) |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_10()); |
| // InternalFSM.g:5519:1: ( rule__TriggeredTransition__TriggersAssignment_10 ) |
| // InternalFSM.g:5519:2: rule__TriggeredTransition__TriggersAssignment_10 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__TriggersAssignment_10(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_10()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__10__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__11" |
| // InternalFSM.g:5529:1: rule__TriggeredTransition__Group__11 : rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 ; |
| public final void rule__TriggeredTransition__Group__11() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5533:1: ( rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 ) |
| // InternalFSM.g:5534:2: rule__TriggeredTransition__Group__11__Impl rule__TriggeredTransition__Group__12 |
| { |
| pushFollow(FOLLOW_23); |
| rule__TriggeredTransition__Group__11__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__12(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__11" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__11__Impl" |
| // InternalFSM.g:5541:1: rule__TriggeredTransition__Group__11__Impl : ( ( rule__TriggeredTransition__Group_11__0 )* ) ; |
| public final void rule__TriggeredTransition__Group__11__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5545:1: ( ( ( rule__TriggeredTransition__Group_11__0 )* ) ) |
| // InternalFSM.g:5546:1: ( ( rule__TriggeredTransition__Group_11__0 )* ) |
| { |
| // InternalFSM.g:5546:1: ( ( rule__TriggeredTransition__Group_11__0 )* ) |
| // InternalFSM.g:5547:1: ( rule__TriggeredTransition__Group_11__0 )* |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getGroup_11()); |
| // InternalFSM.g:5548:1: ( rule__TriggeredTransition__Group_11__0 )* |
| loop56: |
| do { |
| int alt56=2; |
| int LA56_0 = input.LA(1); |
| |
| if ( (LA56_0==47) ) { |
| alt56=1; |
| } |
| |
| |
| switch (alt56) { |
| case 1 : |
| // InternalFSM.g:5548:2: rule__TriggeredTransition__Group_11__0 |
| { |
| pushFollow(FOLLOW_24); |
| rule__TriggeredTransition__Group_11__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop56; |
| } |
| } while (true); |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getGroup_11()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__11__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__12" |
| // InternalFSM.g:5558:1: rule__TriggeredTransition__Group__12 : rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 ; |
| public final void rule__TriggeredTransition__Group__12() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5562:1: ( rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 ) |
| // InternalFSM.g:5563:2: rule__TriggeredTransition__Group__12__Impl rule__TriggeredTransition__Group__13 |
| { |
| pushFollow(FOLLOW_20); |
| rule__TriggeredTransition__Group__12__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__13(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__12" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__12__Impl" |
| // InternalFSM.g:5570:1: rule__TriggeredTransition__Group__12__Impl : ( '}' ) ; |
| public final void rule__TriggeredTransition__Group__12__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5574:1: ( ( '}' ) ) |
| // InternalFSM.g:5575:1: ( '}' ) |
| { |
| // InternalFSM.g:5575:1: ( '}' ) |
| // InternalFSM.g:5576:1: '}' |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_12()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_12()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__12__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__13" |
| // InternalFSM.g:5589:1: rule__TriggeredTransition__Group__13 : rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 ; |
| public final void rule__TriggeredTransition__Group__13() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5593:1: ( rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 ) |
| // InternalFSM.g:5594:2: rule__TriggeredTransition__Group__13__Impl rule__TriggeredTransition__Group__14 |
| { |
| pushFollow(FOLLOW_20); |
| rule__TriggeredTransition__Group__13__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__14(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__13" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__13__Impl" |
| // InternalFSM.g:5601:1: rule__TriggeredTransition__Group__13__Impl : ( ( rule__TriggeredTransition__Group_13__0 )? ) ; |
| public final void rule__TriggeredTransition__Group__13__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5605:1: ( ( ( rule__TriggeredTransition__Group_13__0 )? ) ) |
| // InternalFSM.g:5606:1: ( ( rule__TriggeredTransition__Group_13__0 )? ) |
| { |
| // InternalFSM.g:5606:1: ( ( rule__TriggeredTransition__Group_13__0 )? ) |
| // InternalFSM.g:5607:1: ( rule__TriggeredTransition__Group_13__0 )? |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getGroup_13()); |
| // InternalFSM.g:5608:1: ( rule__TriggeredTransition__Group_13__0 )? |
| int alt57=2; |
| int LA57_0 = input.LA(1); |
| |
| if ( (LA57_0==45) ) { |
| alt57=1; |
| } |
| switch (alt57) { |
| case 1 : |
| // InternalFSM.g:5608:2: rule__TriggeredTransition__Group_13__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group_13__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getGroup_13()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__13__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__14" |
| // InternalFSM.g:5618:1: rule__TriggeredTransition__Group__14 : rule__TriggeredTransition__Group__14__Impl ; |
| public final void rule__TriggeredTransition__Group__14() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5622:1: ( rule__TriggeredTransition__Group__14__Impl ) |
| // InternalFSM.g:5623:2: rule__TriggeredTransition__Group__14__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group__14__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__14" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group__14__Impl" |
| // InternalFSM.g:5629:1: rule__TriggeredTransition__Group__14__Impl : ( '}' ) ; |
| public final void rule__TriggeredTransition__Group__14__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5633:1: ( ( '}' ) ) |
| // InternalFSM.g:5634:1: ( '}' ) |
| { |
| // InternalFSM.g:5634:1: ( '}' ) |
| // InternalFSM.g:5635:1: '}' |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_14()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_14()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group__14__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group_11__0" |
| // InternalFSM.g:5678:1: rule__TriggeredTransition__Group_11__0 : rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 ; |
| public final void rule__TriggeredTransition__Group_11__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5682:1: ( rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 ) |
| // InternalFSM.g:5683:2: rule__TriggeredTransition__Group_11__0__Impl rule__TriggeredTransition__Group_11__1 |
| { |
| pushFollow(FOLLOW_22); |
| rule__TriggeredTransition__Group_11__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group_11__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group_11__0" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group_11__0__Impl" |
| // InternalFSM.g:5690:1: rule__TriggeredTransition__Group_11__0__Impl : ( 'or' ) ; |
| public final void rule__TriggeredTransition__Group_11__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5694:1: ( ( 'or' ) ) |
| // InternalFSM.g:5695:1: ( 'or' ) |
| { |
| // InternalFSM.g:5695:1: ( 'or' ) |
| // InternalFSM.g:5696:1: 'or' |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getOrKeyword_11_0()); |
| match(input,47,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getOrKeyword_11_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group_11__0__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group_11__1" |
| // InternalFSM.g:5709:1: rule__TriggeredTransition__Group_11__1 : rule__TriggeredTransition__Group_11__1__Impl ; |
| public final void rule__TriggeredTransition__Group_11__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5713:1: ( rule__TriggeredTransition__Group_11__1__Impl ) |
| // InternalFSM.g:5714:2: rule__TriggeredTransition__Group_11__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group_11__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group_11__1" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group_11__1__Impl" |
| // InternalFSM.g:5720:1: rule__TriggeredTransition__Group_11__1__Impl : ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) ; |
| public final void rule__TriggeredTransition__Group_11__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5724:1: ( ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) ) |
| // InternalFSM.g:5725:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) |
| { |
| // InternalFSM.g:5725:1: ( ( rule__TriggeredTransition__TriggersAssignment_11_1 ) ) |
| // InternalFSM.g:5726:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 ) |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_11_1()); |
| // InternalFSM.g:5727:1: ( rule__TriggeredTransition__TriggersAssignment_11_1 ) |
| // InternalFSM.g:5727:2: rule__TriggeredTransition__TriggersAssignment_11_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__TriggersAssignment_11_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_11_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group_11__1__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group_13__0" |
| // InternalFSM.g:5741:1: rule__TriggeredTransition__Group_13__0 : rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 ; |
| public final void rule__TriggeredTransition__Group_13__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5745:1: ( rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 ) |
| // InternalFSM.g:5746:2: rule__TriggeredTransition__Group_13__0__Impl rule__TriggeredTransition__Group_13__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__TriggeredTransition__Group_13__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group_13__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group_13__0" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group_13__0__Impl" |
| // InternalFSM.g:5753:1: rule__TriggeredTransition__Group_13__0__Impl : ( 'action' ) ; |
| public final void rule__TriggeredTransition__Group_13__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5757:1: ( ( 'action' ) ) |
| // InternalFSM.g:5758:1: ( 'action' ) |
| { |
| // InternalFSM.g:5758:1: ( 'action' ) |
| // InternalFSM.g:5759:1: 'action' |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getActionKeyword_13_0()); |
| match(input,45,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getActionKeyword_13_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group_13__0__Impl" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group_13__1" |
| // InternalFSM.g:5772:1: rule__TriggeredTransition__Group_13__1 : rule__TriggeredTransition__Group_13__1__Impl ; |
| public final void rule__TriggeredTransition__Group_13__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5776:1: ( rule__TriggeredTransition__Group_13__1__Impl ) |
| // InternalFSM.g:5777:2: rule__TriggeredTransition__Group_13__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__Group_13__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group_13__1" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__Group_13__1__Impl" |
| // InternalFSM.g:5783:1: rule__TriggeredTransition__Group_13__1__Impl : ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) ; |
| public final void rule__TriggeredTransition__Group_13__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5787:1: ( ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) ) |
| // InternalFSM.g:5788:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) |
| { |
| // InternalFSM.g:5788:1: ( ( rule__TriggeredTransition__ActionAssignment_13_1 ) ) |
| // InternalFSM.g:5789:1: ( rule__TriggeredTransition__ActionAssignment_13_1 ) |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getActionAssignment_13_1()); |
| // InternalFSM.g:5790:1: ( rule__TriggeredTransition__ActionAssignment_13_1 ) |
| // InternalFSM.g:5790:2: rule__TriggeredTransition__ActionAssignment_13_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TriggeredTransition__ActionAssignment_13_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getActionAssignment_13_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__Group_13__1__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__0" |
| // InternalFSM.g:5804:1: rule__GuardedTransition__Group__0 : rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 ; |
| public final void rule__GuardedTransition__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5808:1: ( rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 ) |
| // InternalFSM.g:5809:2: rule__GuardedTransition__Group__0__Impl rule__GuardedTransition__Group__1 |
| { |
| pushFollow(FOLLOW_16); |
| rule__GuardedTransition__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__0" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__0__Impl" |
| // InternalFSM.g:5816:1: rule__GuardedTransition__Group__0__Impl : ( 'Transition' ) ; |
| public final void rule__GuardedTransition__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5820:1: ( ( 'Transition' ) ) |
| // InternalFSM.g:5821:1: ( 'Transition' ) |
| { |
| // InternalFSM.g:5821:1: ( 'Transition' ) |
| // InternalFSM.g:5822:1: 'Transition' |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getTransitionKeyword_0()); |
| match(input,41,FOLLOW_2); |
| after(grammarAccess.getGuardedTransitionAccess().getTransitionKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__1" |
| // InternalFSM.g:5835:1: rule__GuardedTransition__Group__1 : rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 ; |
| public final void rule__GuardedTransition__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5839:1: ( rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 ) |
| // InternalFSM.g:5840:2: rule__GuardedTransition__Group__1__Impl rule__GuardedTransition__Group__2 |
| { |
| pushFollow(FOLLOW_16); |
| rule__GuardedTransition__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__1" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__1__Impl" |
| // InternalFSM.g:5847:1: rule__GuardedTransition__Group__1__Impl : ( ( rule__GuardedTransition__NameAssignment_1 )? ) ; |
| public final void rule__GuardedTransition__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5851:1: ( ( ( rule__GuardedTransition__NameAssignment_1 )? ) ) |
| // InternalFSM.g:5852:1: ( ( rule__GuardedTransition__NameAssignment_1 )? ) |
| { |
| // InternalFSM.g:5852:1: ( ( rule__GuardedTransition__NameAssignment_1 )? ) |
| // InternalFSM.g:5853:1: ( rule__GuardedTransition__NameAssignment_1 )? |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getNameAssignment_1()); |
| // InternalFSM.g:5854:1: ( rule__GuardedTransition__NameAssignment_1 )? |
| int alt58=2; |
| int LA58_0 = input.LA(1); |
| |
| if ( (LA58_0==RULE_ID) ) { |
| alt58=1; |
| } |
| switch (alt58) { |
| case 1 : |
| // InternalFSM.g:5854:2: rule__GuardedTransition__NameAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__NameAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getGuardedTransitionAccess().getNameAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__2" |
| // InternalFSM.g:5864:1: rule__GuardedTransition__Group__2 : rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 ; |
| public final void rule__GuardedTransition__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5868:1: ( rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 ) |
| // InternalFSM.g:5869:2: rule__GuardedTransition__Group__2__Impl rule__GuardedTransition__Group__3 |
| { |
| pushFollow(FOLLOW_19); |
| rule__GuardedTransition__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__2" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__2__Impl" |
| // InternalFSM.g:5876:1: rule__GuardedTransition__Group__2__Impl : ( ':' ) ; |
| public final void rule__GuardedTransition__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5880:1: ( ( ':' ) ) |
| // InternalFSM.g:5881:1: ( ':' ) |
| { |
| // InternalFSM.g:5881:1: ( ':' ) |
| // InternalFSM.g:5882:1: ':' |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getColonKeyword_2()); |
| match(input,42,FOLLOW_2); |
| after(grammarAccess.getGuardedTransitionAccess().getColonKeyword_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__3" |
| // InternalFSM.g:5895:1: rule__GuardedTransition__Group__3 : rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 ; |
| public final void rule__GuardedTransition__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5899:1: ( rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 ) |
| // InternalFSM.g:5900:2: rule__GuardedTransition__Group__3__Impl rule__GuardedTransition__Group__4 |
| { |
| pushFollow(FOLLOW_18); |
| rule__GuardedTransition__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__3" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__3__Impl" |
| // InternalFSM.g:5907:1: rule__GuardedTransition__Group__3__Impl : ( ( rule__GuardedTransition__FromAssignment_3 ) ) ; |
| public final void rule__GuardedTransition__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5911:1: ( ( ( rule__GuardedTransition__FromAssignment_3 ) ) ) |
| // InternalFSM.g:5912:1: ( ( rule__GuardedTransition__FromAssignment_3 ) ) |
| { |
| // InternalFSM.g:5912:1: ( ( rule__GuardedTransition__FromAssignment_3 ) ) |
| // InternalFSM.g:5913:1: ( rule__GuardedTransition__FromAssignment_3 ) |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getFromAssignment_3()); |
| // InternalFSM.g:5914:1: ( rule__GuardedTransition__FromAssignment_3 ) |
| // InternalFSM.g:5914:2: rule__GuardedTransition__FromAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__FromAssignment_3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getGuardedTransitionAccess().getFromAssignment_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__4" |
| // InternalFSM.g:5924:1: rule__GuardedTransition__Group__4 : rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 ; |
| public final void rule__GuardedTransition__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5928:1: ( rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 ) |
| // InternalFSM.g:5929:2: rule__GuardedTransition__Group__4__Impl rule__GuardedTransition__Group__5 |
| { |
| pushFollow(FOLLOW_19); |
| rule__GuardedTransition__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__4" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__4__Impl" |
| // InternalFSM.g:5936:1: rule__GuardedTransition__Group__4__Impl : ( '->' ) ; |
| public final void rule__GuardedTransition__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5940:1: ( ( '->' ) ) |
| // InternalFSM.g:5941:1: ( '->' ) |
| { |
| // InternalFSM.g:5941:1: ( '->' ) |
| // InternalFSM.g:5942:1: '->' |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); |
| match(input,44,FOLLOW_2); |
| after(grammarAccess.getGuardedTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__5" |
| // InternalFSM.g:5955:1: rule__GuardedTransition__Group__5 : rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 ; |
| public final void rule__GuardedTransition__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5959:1: ( rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 ) |
| // InternalFSM.g:5960:2: rule__GuardedTransition__Group__5__Impl rule__GuardedTransition__Group__6 |
| { |
| pushFollow(FOLLOW_10); |
| rule__GuardedTransition__Group__5__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__6(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__5" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__5__Impl" |
| // InternalFSM.g:5967:1: rule__GuardedTransition__Group__5__Impl : ( ( rule__GuardedTransition__ToAssignment_5 ) ) ; |
| public final void rule__GuardedTransition__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5971:1: ( ( ( rule__GuardedTransition__ToAssignment_5 ) ) ) |
| // InternalFSM.g:5972:1: ( ( rule__GuardedTransition__ToAssignment_5 ) ) |
| { |
| // InternalFSM.g:5972:1: ( ( rule__GuardedTransition__ToAssignment_5 ) ) |
| // InternalFSM.g:5973:1: ( rule__GuardedTransition__ToAssignment_5 ) |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getToAssignment_5()); |
| // InternalFSM.g:5974:1: ( rule__GuardedTransition__ToAssignment_5 ) |
| // InternalFSM.g:5974:2: rule__GuardedTransition__ToAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__ToAssignment_5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getGuardedTransitionAccess().getToAssignment_5()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__6" |
| // InternalFSM.g:5984:1: rule__GuardedTransition__Group__6 : rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 ; |
| public final void rule__GuardedTransition__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:5988:1: ( rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 ) |
| // InternalFSM.g:5989:2: rule__GuardedTransition__Group__6__Impl rule__GuardedTransition__Group__7 |
| { |
| pushFollow(FOLLOW_10); |
| rule__GuardedTransition__Group__6__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__7(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__6" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__6__Impl" |
| // InternalFSM.g:5996:1: rule__GuardedTransition__Group__6__Impl : ( ( rule__GuardedTransition__DocuAssignment_6 )? ) ; |
| public final void rule__GuardedTransition__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6000:1: ( ( ( rule__GuardedTransition__DocuAssignment_6 )? ) ) |
| // InternalFSM.g:6001:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? ) |
| { |
| // InternalFSM.g:6001:1: ( ( rule__GuardedTransition__DocuAssignment_6 )? ) |
| // InternalFSM.g:6002:1: ( rule__GuardedTransition__DocuAssignment_6 )? |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getDocuAssignment_6()); |
| // InternalFSM.g:6003:1: ( rule__GuardedTransition__DocuAssignment_6 )? |
| int alt59=2; |
| int LA59_0 = input.LA(1); |
| |
| if ( (LA59_0==65) ) { |
| alt59=1; |
| } |
| switch (alt59) { |
| case 1 : |
| // InternalFSM.g:6003:2: rule__GuardedTransition__DocuAssignment_6 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__DocuAssignment_6(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getGuardedTransitionAccess().getDocuAssignment_6()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__7" |
| // InternalFSM.g:6013:1: rule__GuardedTransition__Group__7 : rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 ; |
| public final void rule__GuardedTransition__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6017:1: ( rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 ) |
| // InternalFSM.g:6018:2: rule__GuardedTransition__Group__7__Impl rule__GuardedTransition__Group__8 |
| { |
| pushFollow(FOLLOW_25); |
| rule__GuardedTransition__Group__7__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__8(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__7" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__7__Impl" |
| // InternalFSM.g:6025:1: rule__GuardedTransition__Group__7__Impl : ( '{' ) ; |
| public final void rule__GuardedTransition__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6029:1: ( ( '{' ) ) |
| // InternalFSM.g:6030:1: ( '{' ) |
| { |
| // InternalFSM.g:6030:1: ( '{' ) |
| // InternalFSM.g:6031:1: '{' |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getLeftCurlyBracketKeyword_7()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getGuardedTransitionAccess().getLeftCurlyBracketKeyword_7()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__8" |
| // InternalFSM.g:6044:1: rule__GuardedTransition__Group__8 : rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 ; |
| public final void rule__GuardedTransition__Group__8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6048:1: ( rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 ) |
| // InternalFSM.g:6049:2: rule__GuardedTransition__Group__8__Impl rule__GuardedTransition__Group__9 |
| { |
| pushFollow(FOLLOW_7); |
| rule__GuardedTransition__Group__8__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__9(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__8" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__8__Impl" |
| // InternalFSM.g:6056:1: rule__GuardedTransition__Group__8__Impl : ( 'guard' ) ; |
| public final void rule__GuardedTransition__Group__8__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6060:1: ( ( 'guard' ) ) |
| // InternalFSM.g:6061:1: ( 'guard' ) |
| { |
| // InternalFSM.g:6061:1: ( 'guard' ) |
| // InternalFSM.g:6062:1: 'guard' |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getGuardKeyword_8()); |
| match(input,48,FOLLOW_2); |
| after(grammarAccess.getGuardedTransitionAccess().getGuardKeyword_8()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__8__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__9" |
| // InternalFSM.g:6075:1: rule__GuardedTransition__Group__9 : rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 ; |
| public final void rule__GuardedTransition__Group__9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6079:1: ( rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 ) |
| // InternalFSM.g:6080:2: rule__GuardedTransition__Group__9__Impl rule__GuardedTransition__Group__10 |
| { |
| pushFollow(FOLLOW_20); |
| rule__GuardedTransition__Group__9__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__10(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__9" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__9__Impl" |
| // InternalFSM.g:6087:1: rule__GuardedTransition__Group__9__Impl : ( ( rule__GuardedTransition__GuardAssignment_9 ) ) ; |
| public final void rule__GuardedTransition__Group__9__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6091:1: ( ( ( rule__GuardedTransition__GuardAssignment_9 ) ) ) |
| // InternalFSM.g:6092:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) ) |
| { |
| // InternalFSM.g:6092:1: ( ( rule__GuardedTransition__GuardAssignment_9 ) ) |
| // InternalFSM.g:6093:1: ( rule__GuardedTransition__GuardAssignment_9 ) |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getGuardAssignment_9()); |
| // InternalFSM.g:6094:1: ( rule__GuardedTransition__GuardAssignment_9 ) |
| // InternalFSM.g:6094:2: rule__GuardedTransition__GuardAssignment_9 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__GuardAssignment_9(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getGuardedTransitionAccess().getGuardAssignment_9()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__9__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__10" |
| // InternalFSM.g:6104:1: rule__GuardedTransition__Group__10 : rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 ; |
| public final void rule__GuardedTransition__Group__10() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6108:1: ( rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 ) |
| // InternalFSM.g:6109:2: rule__GuardedTransition__Group__10__Impl rule__GuardedTransition__Group__11 |
| { |
| pushFollow(FOLLOW_20); |
| rule__GuardedTransition__Group__10__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__11(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__10" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__10__Impl" |
| // InternalFSM.g:6116:1: rule__GuardedTransition__Group__10__Impl : ( ( rule__GuardedTransition__Group_10__0 )? ) ; |
| public final void rule__GuardedTransition__Group__10__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6120:1: ( ( ( rule__GuardedTransition__Group_10__0 )? ) ) |
| // InternalFSM.g:6121:1: ( ( rule__GuardedTransition__Group_10__0 )? ) |
| { |
| // InternalFSM.g:6121:1: ( ( rule__GuardedTransition__Group_10__0 )? ) |
| // InternalFSM.g:6122:1: ( rule__GuardedTransition__Group_10__0 )? |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getGroup_10()); |
| // InternalFSM.g:6123:1: ( rule__GuardedTransition__Group_10__0 )? |
| int alt60=2; |
| int LA60_0 = input.LA(1); |
| |
| if ( (LA60_0==45) ) { |
| alt60=1; |
| } |
| switch (alt60) { |
| case 1 : |
| // InternalFSM.g:6123:2: rule__GuardedTransition__Group_10__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group_10__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getGuardedTransitionAccess().getGroup_10()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__10__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__11" |
| // InternalFSM.g:6133:1: rule__GuardedTransition__Group__11 : rule__GuardedTransition__Group__11__Impl ; |
| public final void rule__GuardedTransition__Group__11() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6137:1: ( rule__GuardedTransition__Group__11__Impl ) |
| // InternalFSM.g:6138:2: rule__GuardedTransition__Group__11__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group__11__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__11" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group__11__Impl" |
| // InternalFSM.g:6144:1: rule__GuardedTransition__Group__11__Impl : ( '}' ) ; |
| public final void rule__GuardedTransition__Group__11__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6148:1: ( ( '}' ) ) |
| // InternalFSM.g:6149:1: ( '}' ) |
| { |
| // InternalFSM.g:6149:1: ( '}' ) |
| // InternalFSM.g:6150:1: '}' |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getRightCurlyBracketKeyword_11()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getGuardedTransitionAccess().getRightCurlyBracketKeyword_11()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group__11__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group_10__0" |
| // InternalFSM.g:6187:1: rule__GuardedTransition__Group_10__0 : rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 ; |
| public final void rule__GuardedTransition__Group_10__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6191:1: ( rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 ) |
| // InternalFSM.g:6192:2: rule__GuardedTransition__Group_10__0__Impl rule__GuardedTransition__Group_10__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__GuardedTransition__Group_10__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group_10__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group_10__0" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group_10__0__Impl" |
| // InternalFSM.g:6199:1: rule__GuardedTransition__Group_10__0__Impl : ( 'action' ) ; |
| public final void rule__GuardedTransition__Group_10__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6203:1: ( ( 'action' ) ) |
| // InternalFSM.g:6204:1: ( 'action' ) |
| { |
| // InternalFSM.g:6204:1: ( 'action' ) |
| // InternalFSM.g:6205:1: 'action' |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getActionKeyword_10_0()); |
| match(input,45,FOLLOW_2); |
| after(grammarAccess.getGuardedTransitionAccess().getActionKeyword_10_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group_10__0__Impl" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group_10__1" |
| // InternalFSM.g:6218:1: rule__GuardedTransition__Group_10__1 : rule__GuardedTransition__Group_10__1__Impl ; |
| public final void rule__GuardedTransition__Group_10__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6222:1: ( rule__GuardedTransition__Group_10__1__Impl ) |
| // InternalFSM.g:6223:2: rule__GuardedTransition__Group_10__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__Group_10__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group_10__1" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__Group_10__1__Impl" |
| // InternalFSM.g:6229:1: rule__GuardedTransition__Group_10__1__Impl : ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) ; |
| public final void rule__GuardedTransition__Group_10__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6233:1: ( ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) ) |
| // InternalFSM.g:6234:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) |
| { |
| // InternalFSM.g:6234:1: ( ( rule__GuardedTransition__ActionAssignment_10_1 ) ) |
| // InternalFSM.g:6235:1: ( rule__GuardedTransition__ActionAssignment_10_1 ) |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getActionAssignment_10_1()); |
| // InternalFSM.g:6236:1: ( rule__GuardedTransition__ActionAssignment_10_1 ) |
| // InternalFSM.g:6236:2: rule__GuardedTransition__ActionAssignment_10_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__GuardedTransition__ActionAssignment_10_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getGuardedTransitionAccess().getActionAssignment_10_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__Group_10__1__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__0" |
| // InternalFSM.g:6250:1: rule__CPBranchTransition__Group__0 : rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 ; |
| public final void rule__CPBranchTransition__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6254:1: ( rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 ) |
| // InternalFSM.g:6255:2: rule__CPBranchTransition__Group__0__Impl rule__CPBranchTransition__Group__1 |
| { |
| pushFollow(FOLLOW_16); |
| rule__CPBranchTransition__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__0" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__0__Impl" |
| // InternalFSM.g:6262:1: rule__CPBranchTransition__Group__0__Impl : ( 'Transition' ) ; |
| public final void rule__CPBranchTransition__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6266:1: ( ( 'Transition' ) ) |
| // InternalFSM.g:6267:1: ( 'Transition' ) |
| { |
| // InternalFSM.g:6267:1: ( 'Transition' ) |
| // InternalFSM.g:6268:1: 'Transition' |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getTransitionKeyword_0()); |
| match(input,41,FOLLOW_2); |
| after(grammarAccess.getCPBranchTransitionAccess().getTransitionKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__1" |
| // InternalFSM.g:6281:1: rule__CPBranchTransition__Group__1 : rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 ; |
| public final void rule__CPBranchTransition__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6285:1: ( rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 ) |
| // InternalFSM.g:6286:2: rule__CPBranchTransition__Group__1__Impl rule__CPBranchTransition__Group__2 |
| { |
| pushFollow(FOLLOW_16); |
| rule__CPBranchTransition__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__1" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__1__Impl" |
| // InternalFSM.g:6293:1: rule__CPBranchTransition__Group__1__Impl : ( ( rule__CPBranchTransition__NameAssignment_1 )? ) ; |
| public final void rule__CPBranchTransition__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6297:1: ( ( ( rule__CPBranchTransition__NameAssignment_1 )? ) ) |
| // InternalFSM.g:6298:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? ) |
| { |
| // InternalFSM.g:6298:1: ( ( rule__CPBranchTransition__NameAssignment_1 )? ) |
| // InternalFSM.g:6299:1: ( rule__CPBranchTransition__NameAssignment_1 )? |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getNameAssignment_1()); |
| // InternalFSM.g:6300:1: ( rule__CPBranchTransition__NameAssignment_1 )? |
| int alt61=2; |
| int LA61_0 = input.LA(1); |
| |
| if ( (LA61_0==RULE_ID) ) { |
| alt61=1; |
| } |
| switch (alt61) { |
| case 1 : |
| // InternalFSM.g:6300:2: rule__CPBranchTransition__NameAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__NameAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getNameAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__2" |
| // InternalFSM.g:6310:1: rule__CPBranchTransition__Group__2 : rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 ; |
| public final void rule__CPBranchTransition__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6314:1: ( rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 ) |
| // InternalFSM.g:6315:2: rule__CPBranchTransition__Group__2__Impl rule__CPBranchTransition__Group__3 |
| { |
| pushFollow(FOLLOW_19); |
| rule__CPBranchTransition__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__2" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__2__Impl" |
| // InternalFSM.g:6322:1: rule__CPBranchTransition__Group__2__Impl : ( ':' ) ; |
| public final void rule__CPBranchTransition__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6326:1: ( ( ':' ) ) |
| // InternalFSM.g:6327:1: ( ':' ) |
| { |
| // InternalFSM.g:6327:1: ( ':' ) |
| // InternalFSM.g:6328:1: ':' |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getColonKeyword_2()); |
| match(input,42,FOLLOW_2); |
| after(grammarAccess.getCPBranchTransitionAccess().getColonKeyword_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__3" |
| // InternalFSM.g:6341:1: rule__CPBranchTransition__Group__3 : rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 ; |
| public final void rule__CPBranchTransition__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6345:1: ( rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 ) |
| // InternalFSM.g:6346:2: rule__CPBranchTransition__Group__3__Impl rule__CPBranchTransition__Group__4 |
| { |
| pushFollow(FOLLOW_18); |
| rule__CPBranchTransition__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__3" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__3__Impl" |
| // InternalFSM.g:6353:1: rule__CPBranchTransition__Group__3__Impl : ( ( rule__CPBranchTransition__FromAssignment_3 ) ) ; |
| public final void rule__CPBranchTransition__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6357:1: ( ( ( rule__CPBranchTransition__FromAssignment_3 ) ) ) |
| // InternalFSM.g:6358:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) ) |
| { |
| // InternalFSM.g:6358:1: ( ( rule__CPBranchTransition__FromAssignment_3 ) ) |
| // InternalFSM.g:6359:1: ( rule__CPBranchTransition__FromAssignment_3 ) |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getFromAssignment_3()); |
| // InternalFSM.g:6360:1: ( rule__CPBranchTransition__FromAssignment_3 ) |
| // InternalFSM.g:6360:2: rule__CPBranchTransition__FromAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__FromAssignment_3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getFromAssignment_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__4" |
| // InternalFSM.g:6370:1: rule__CPBranchTransition__Group__4 : rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 ; |
| public final void rule__CPBranchTransition__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6374:1: ( rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 ) |
| // InternalFSM.g:6375:2: rule__CPBranchTransition__Group__4__Impl rule__CPBranchTransition__Group__5 |
| { |
| pushFollow(FOLLOW_19); |
| rule__CPBranchTransition__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__4" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__4__Impl" |
| // InternalFSM.g:6382:1: rule__CPBranchTransition__Group__4__Impl : ( '->' ) ; |
| public final void rule__CPBranchTransition__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6386:1: ( ( '->' ) ) |
| // InternalFSM.g:6387:1: ( '->' ) |
| { |
| // InternalFSM.g:6387:1: ( '->' ) |
| // InternalFSM.g:6388:1: '->' |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); |
| match(input,44,FOLLOW_2); |
| after(grammarAccess.getCPBranchTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__5" |
| // InternalFSM.g:6401:1: rule__CPBranchTransition__Group__5 : rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 ; |
| public final void rule__CPBranchTransition__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6405:1: ( rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 ) |
| // InternalFSM.g:6406:2: rule__CPBranchTransition__Group__5__Impl rule__CPBranchTransition__Group__6 |
| { |
| pushFollow(FOLLOW_10); |
| rule__CPBranchTransition__Group__5__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__6(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__5" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__5__Impl" |
| // InternalFSM.g:6413:1: rule__CPBranchTransition__Group__5__Impl : ( ( rule__CPBranchTransition__ToAssignment_5 ) ) ; |
| public final void rule__CPBranchTransition__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6417:1: ( ( ( rule__CPBranchTransition__ToAssignment_5 ) ) ) |
| // InternalFSM.g:6418:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) ) |
| { |
| // InternalFSM.g:6418:1: ( ( rule__CPBranchTransition__ToAssignment_5 ) ) |
| // InternalFSM.g:6419:1: ( rule__CPBranchTransition__ToAssignment_5 ) |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getToAssignment_5()); |
| // InternalFSM.g:6420:1: ( rule__CPBranchTransition__ToAssignment_5 ) |
| // InternalFSM.g:6420:2: rule__CPBranchTransition__ToAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__ToAssignment_5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getToAssignment_5()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__6" |
| // InternalFSM.g:6430:1: rule__CPBranchTransition__Group__6 : rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 ; |
| public final void rule__CPBranchTransition__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6434:1: ( rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 ) |
| // InternalFSM.g:6435:2: rule__CPBranchTransition__Group__6__Impl rule__CPBranchTransition__Group__7 |
| { |
| pushFollow(FOLLOW_10); |
| rule__CPBranchTransition__Group__6__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__7(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__6" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__6__Impl" |
| // InternalFSM.g:6442:1: rule__CPBranchTransition__Group__6__Impl : ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) ; |
| public final void rule__CPBranchTransition__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6446:1: ( ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) ) |
| // InternalFSM.g:6447:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) |
| { |
| // InternalFSM.g:6447:1: ( ( rule__CPBranchTransition__DocuAssignment_6 )? ) |
| // InternalFSM.g:6448:1: ( rule__CPBranchTransition__DocuAssignment_6 )? |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getDocuAssignment_6()); |
| // InternalFSM.g:6449:1: ( rule__CPBranchTransition__DocuAssignment_6 )? |
| int alt62=2; |
| int LA62_0 = input.LA(1); |
| |
| if ( (LA62_0==65) ) { |
| alt62=1; |
| } |
| switch (alt62) { |
| case 1 : |
| // InternalFSM.g:6449:2: rule__CPBranchTransition__DocuAssignment_6 |
| { |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__DocuAssignment_6(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getDocuAssignment_6()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__7" |
| // InternalFSM.g:6459:1: rule__CPBranchTransition__Group__7 : rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 ; |
| public final void rule__CPBranchTransition__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6463:1: ( rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 ) |
| // InternalFSM.g:6464:2: rule__CPBranchTransition__Group__7__Impl rule__CPBranchTransition__Group__8 |
| { |
| pushFollow(FOLLOW_26); |
| rule__CPBranchTransition__Group__7__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__8(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__7" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__7__Impl" |
| // InternalFSM.g:6471:1: rule__CPBranchTransition__Group__7__Impl : ( '{' ) ; |
| public final void rule__CPBranchTransition__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6475:1: ( ( '{' ) ) |
| // InternalFSM.g:6476:1: ( '{' ) |
| { |
| // InternalFSM.g:6476:1: ( '{' ) |
| // InternalFSM.g:6477:1: '{' |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getLeftCurlyBracketKeyword_7()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getCPBranchTransitionAccess().getLeftCurlyBracketKeyword_7()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__8" |
| // InternalFSM.g:6490:1: rule__CPBranchTransition__Group__8 : rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 ; |
| public final void rule__CPBranchTransition__Group__8() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6494:1: ( rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 ) |
| // InternalFSM.g:6495:2: rule__CPBranchTransition__Group__8__Impl rule__CPBranchTransition__Group__9 |
| { |
| pushFollow(FOLLOW_7); |
| rule__CPBranchTransition__Group__8__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__9(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__8" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__8__Impl" |
| // InternalFSM.g:6502:1: rule__CPBranchTransition__Group__8__Impl : ( 'cond' ) ; |
| public final void rule__CPBranchTransition__Group__8__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6506:1: ( ( 'cond' ) ) |
| // InternalFSM.g:6507:1: ( 'cond' ) |
| { |
| // InternalFSM.g:6507:1: ( 'cond' ) |
| // InternalFSM.g:6508:1: 'cond' |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getCondKeyword_8()); |
| match(input,49,FOLLOW_2); |
| after(grammarAccess.getCPBranchTransitionAccess().getCondKeyword_8()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__8__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__9" |
| // InternalFSM.g:6521:1: rule__CPBranchTransition__Group__9 : rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 ; |
| public final void rule__CPBranchTransition__Group__9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6525:1: ( rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 ) |
| // InternalFSM.g:6526:2: rule__CPBranchTransition__Group__9__Impl rule__CPBranchTransition__Group__10 |
| { |
| pushFollow(FOLLOW_20); |
| rule__CPBranchTransition__Group__9__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__10(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__9" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__9__Impl" |
| // InternalFSM.g:6533:1: rule__CPBranchTransition__Group__9__Impl : ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) ; |
| public final void rule__CPBranchTransition__Group__9__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6537:1: ( ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) ) |
| // InternalFSM.g:6538:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) |
| { |
| // InternalFSM.g:6538:1: ( ( rule__CPBranchTransition__ConditionAssignment_9 ) ) |
| // InternalFSM.g:6539:1: ( rule__CPBranchTransition__ConditionAssignment_9 ) |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getConditionAssignment_9()); |
| // InternalFSM.g:6540:1: ( rule__CPBranchTransition__ConditionAssignment_9 ) |
| // InternalFSM.g:6540:2: rule__CPBranchTransition__ConditionAssignment_9 |
| { |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__ConditionAssignment_9(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getConditionAssignment_9()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__9__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__10" |
| // InternalFSM.g:6550:1: rule__CPBranchTransition__Group__10 : rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 ; |
| public final void rule__CPBranchTransition__Group__10() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6554:1: ( rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 ) |
| // InternalFSM.g:6555:2: rule__CPBranchTransition__Group__10__Impl rule__CPBranchTransition__Group__11 |
| { |
| pushFollow(FOLLOW_20); |
| rule__CPBranchTransition__Group__10__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__11(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__10" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__10__Impl" |
| // InternalFSM.g:6562:1: rule__CPBranchTransition__Group__10__Impl : ( ( rule__CPBranchTransition__Group_10__0 )? ) ; |
| public final void rule__CPBranchTransition__Group__10__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6566:1: ( ( ( rule__CPBranchTransition__Group_10__0 )? ) ) |
| // InternalFSM.g:6567:1: ( ( rule__CPBranchTransition__Group_10__0 )? ) |
| { |
| // InternalFSM.g:6567:1: ( ( rule__CPBranchTransition__Group_10__0 )? ) |
| // InternalFSM.g:6568:1: ( rule__CPBranchTransition__Group_10__0 )? |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getGroup_10()); |
| // InternalFSM.g:6569:1: ( rule__CPBranchTransition__Group_10__0 )? |
| int alt63=2; |
| int LA63_0 = input.LA(1); |
| |
| if ( (LA63_0==45) ) { |
| alt63=1; |
| } |
| switch (alt63) { |
| case 1 : |
| // InternalFSM.g:6569:2: rule__CPBranchTransition__Group_10__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group_10__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getGroup_10()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__10__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__11" |
| // InternalFSM.g:6579:1: rule__CPBranchTransition__Group__11 : rule__CPBranchTransition__Group__11__Impl ; |
| public final void rule__CPBranchTransition__Group__11() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6583:1: ( rule__CPBranchTransition__Group__11__Impl ) |
| // InternalFSM.g:6584:2: rule__CPBranchTransition__Group__11__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group__11__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__11" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group__11__Impl" |
| // InternalFSM.g:6590:1: rule__CPBranchTransition__Group__11__Impl : ( '}' ) ; |
| public final void rule__CPBranchTransition__Group__11__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6594:1: ( ( '}' ) ) |
| // InternalFSM.g:6595:1: ( '}' ) |
| { |
| // InternalFSM.g:6595:1: ( '}' ) |
| // InternalFSM.g:6596:1: '}' |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getRightCurlyBracketKeyword_11()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getCPBranchTransitionAccess().getRightCurlyBracketKeyword_11()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group__11__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group_10__0" |
| // InternalFSM.g:6633:1: rule__CPBranchTransition__Group_10__0 : rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 ; |
| public final void rule__CPBranchTransition__Group_10__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6637:1: ( rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 ) |
| // InternalFSM.g:6638:2: rule__CPBranchTransition__Group_10__0__Impl rule__CPBranchTransition__Group_10__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__CPBranchTransition__Group_10__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group_10__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group_10__0" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group_10__0__Impl" |
| // InternalFSM.g:6645:1: rule__CPBranchTransition__Group_10__0__Impl : ( 'action' ) ; |
| public final void rule__CPBranchTransition__Group_10__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6649:1: ( ( 'action' ) ) |
| // InternalFSM.g:6650:1: ( 'action' ) |
| { |
| // InternalFSM.g:6650:1: ( 'action' ) |
| // InternalFSM.g:6651:1: 'action' |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getActionKeyword_10_0()); |
| match(input,45,FOLLOW_2); |
| after(grammarAccess.getCPBranchTransitionAccess().getActionKeyword_10_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group_10__0__Impl" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group_10__1" |
| // InternalFSM.g:6664:1: rule__CPBranchTransition__Group_10__1 : rule__CPBranchTransition__Group_10__1__Impl ; |
| public final void rule__CPBranchTransition__Group_10__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6668:1: ( rule__CPBranchTransition__Group_10__1__Impl ) |
| // InternalFSM.g:6669:2: rule__CPBranchTransition__Group_10__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__Group_10__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group_10__1" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__Group_10__1__Impl" |
| // InternalFSM.g:6675:1: rule__CPBranchTransition__Group_10__1__Impl : ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) ; |
| public final void rule__CPBranchTransition__Group_10__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6679:1: ( ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) ) |
| // InternalFSM.g:6680:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) |
| { |
| // InternalFSM.g:6680:1: ( ( rule__CPBranchTransition__ActionAssignment_10_1 ) ) |
| // InternalFSM.g:6681:1: ( rule__CPBranchTransition__ActionAssignment_10_1 ) |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getActionAssignment_10_1()); |
| // InternalFSM.g:6682:1: ( rule__CPBranchTransition__ActionAssignment_10_1 ) |
| // InternalFSM.g:6682:2: rule__CPBranchTransition__ActionAssignment_10_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__CPBranchTransition__ActionAssignment_10_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getActionAssignment_10_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__Group_10__1__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__0" |
| // InternalFSM.g:6696:1: rule__RefinedTransition__Group__0 : rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 ; |
| public final void rule__RefinedTransition__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6700:1: ( rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 ) |
| // InternalFSM.g:6701:2: rule__RefinedTransition__Group__0__Impl rule__RefinedTransition__Group__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__RefinedTransition__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__0" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__0__Impl" |
| // InternalFSM.g:6708:1: rule__RefinedTransition__Group__0__Impl : ( 'RefinedTransition' ) ; |
| public final void rule__RefinedTransition__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6712:1: ( ( 'RefinedTransition' ) ) |
| // InternalFSM.g:6713:1: ( 'RefinedTransition' ) |
| { |
| // InternalFSM.g:6713:1: ( 'RefinedTransition' ) |
| // InternalFSM.g:6714:1: 'RefinedTransition' |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getRefinedTransitionKeyword_0()); |
| match(input,50,FOLLOW_2); |
| after(grammarAccess.getRefinedTransitionAccess().getRefinedTransitionKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__1" |
| // InternalFSM.g:6727:1: rule__RefinedTransition__Group__1 : rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 ; |
| public final void rule__RefinedTransition__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6731:1: ( rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 ) |
| // InternalFSM.g:6732:2: rule__RefinedTransition__Group__1__Impl rule__RefinedTransition__Group__2 |
| { |
| pushFollow(FOLLOW_10); |
| rule__RefinedTransition__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__1" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__1__Impl" |
| // InternalFSM.g:6739:1: rule__RefinedTransition__Group__1__Impl : ( ( rule__RefinedTransition__TargetAssignment_1 ) ) ; |
| public final void rule__RefinedTransition__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6743:1: ( ( ( rule__RefinedTransition__TargetAssignment_1 ) ) ) |
| // InternalFSM.g:6744:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) ) |
| { |
| // InternalFSM.g:6744:1: ( ( rule__RefinedTransition__TargetAssignment_1 ) ) |
| // InternalFSM.g:6745:1: ( rule__RefinedTransition__TargetAssignment_1 ) |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getTargetAssignment_1()); |
| // InternalFSM.g:6746:1: ( rule__RefinedTransition__TargetAssignment_1 ) |
| // InternalFSM.g:6746:2: rule__RefinedTransition__TargetAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__TargetAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRefinedTransitionAccess().getTargetAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__2" |
| // InternalFSM.g:6756:1: rule__RefinedTransition__Group__2 : rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 ; |
| public final void rule__RefinedTransition__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6760:1: ( rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 ) |
| // InternalFSM.g:6761:2: rule__RefinedTransition__Group__2__Impl rule__RefinedTransition__Group__3 |
| { |
| pushFollow(FOLLOW_10); |
| rule__RefinedTransition__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__2" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__2__Impl" |
| // InternalFSM.g:6768:1: rule__RefinedTransition__Group__2__Impl : ( ( rule__RefinedTransition__DocuAssignment_2 )? ) ; |
| public final void rule__RefinedTransition__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6772:1: ( ( ( rule__RefinedTransition__DocuAssignment_2 )? ) ) |
| // InternalFSM.g:6773:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? ) |
| { |
| // InternalFSM.g:6773:1: ( ( rule__RefinedTransition__DocuAssignment_2 )? ) |
| // InternalFSM.g:6774:1: ( rule__RefinedTransition__DocuAssignment_2 )? |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getDocuAssignment_2()); |
| // InternalFSM.g:6775:1: ( rule__RefinedTransition__DocuAssignment_2 )? |
| int alt64=2; |
| int LA64_0 = input.LA(1); |
| |
| if ( (LA64_0==65) ) { |
| alt64=1; |
| } |
| switch (alt64) { |
| case 1 : |
| // InternalFSM.g:6775:2: rule__RefinedTransition__DocuAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__DocuAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getRefinedTransitionAccess().getDocuAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__3" |
| // InternalFSM.g:6785:1: rule__RefinedTransition__Group__3 : rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 ; |
| public final void rule__RefinedTransition__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6789:1: ( rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 ) |
| // InternalFSM.g:6790:2: rule__RefinedTransition__Group__3__Impl rule__RefinedTransition__Group__4 |
| { |
| pushFollow(FOLLOW_27); |
| rule__RefinedTransition__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__3" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__3__Impl" |
| // InternalFSM.g:6797:1: rule__RefinedTransition__Group__3__Impl : ( '{' ) ; |
| public final void rule__RefinedTransition__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6801:1: ( ( '{' ) ) |
| // InternalFSM.g:6802:1: ( '{' ) |
| { |
| // InternalFSM.g:6802:1: ( '{' ) |
| // InternalFSM.g:6803:1: '{' |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getLeftCurlyBracketKeyword_3()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getRefinedTransitionAccess().getLeftCurlyBracketKeyword_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__4" |
| // InternalFSM.g:6816:1: rule__RefinedTransition__Group__4 : rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 ; |
| public final void rule__RefinedTransition__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6820:1: ( rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 ) |
| // InternalFSM.g:6821:2: rule__RefinedTransition__Group__4__Impl rule__RefinedTransition__Group__5 |
| { |
| pushFollow(FOLLOW_7); |
| rule__RefinedTransition__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__Group__5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__4" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__4__Impl" |
| // InternalFSM.g:6828:1: rule__RefinedTransition__Group__4__Impl : ( 'action' ) ; |
| public final void rule__RefinedTransition__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6832:1: ( ( 'action' ) ) |
| // InternalFSM.g:6833:1: ( 'action' ) |
| { |
| // InternalFSM.g:6833:1: ( 'action' ) |
| // InternalFSM.g:6834:1: 'action' |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getActionKeyword_4()); |
| match(input,45,FOLLOW_2); |
| after(grammarAccess.getRefinedTransitionAccess().getActionKeyword_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__5" |
| // InternalFSM.g:6847:1: rule__RefinedTransition__Group__5 : rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 ; |
| public final void rule__RefinedTransition__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6851:1: ( rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 ) |
| // InternalFSM.g:6852:2: rule__RefinedTransition__Group__5__Impl rule__RefinedTransition__Group__6 |
| { |
| pushFollow(FOLLOW_28); |
| rule__RefinedTransition__Group__5__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__Group__6(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__5" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__5__Impl" |
| // InternalFSM.g:6859:1: rule__RefinedTransition__Group__5__Impl : ( ( rule__RefinedTransition__ActionAssignment_5 ) ) ; |
| public final void rule__RefinedTransition__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6863:1: ( ( ( rule__RefinedTransition__ActionAssignment_5 ) ) ) |
| // InternalFSM.g:6864:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) ) |
| { |
| // InternalFSM.g:6864:1: ( ( rule__RefinedTransition__ActionAssignment_5 ) ) |
| // InternalFSM.g:6865:1: ( rule__RefinedTransition__ActionAssignment_5 ) |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getActionAssignment_5()); |
| // InternalFSM.g:6866:1: ( rule__RefinedTransition__ActionAssignment_5 ) |
| // InternalFSM.g:6866:2: rule__RefinedTransition__ActionAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__ActionAssignment_5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRefinedTransitionAccess().getActionAssignment_5()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__6" |
| // InternalFSM.g:6876:1: rule__RefinedTransition__Group__6 : rule__RefinedTransition__Group__6__Impl ; |
| public final void rule__RefinedTransition__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6880:1: ( rule__RefinedTransition__Group__6__Impl ) |
| // InternalFSM.g:6881:2: rule__RefinedTransition__Group__6__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__RefinedTransition__Group__6__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__6" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__Group__6__Impl" |
| // InternalFSM.g:6887:1: rule__RefinedTransition__Group__6__Impl : ( '}' ) ; |
| public final void rule__RefinedTransition__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6891:1: ( ( '}' ) ) |
| // InternalFSM.g:6892:1: ( '}' ) |
| { |
| // InternalFSM.g:6892:1: ( '}' ) |
| // InternalFSM.g:6893:1: '}' |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getRightCurlyBracketKeyword_6()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getRefinedTransitionAccess().getRightCurlyBracketKeyword_6()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__TrPointTerminal__Group__0" |
| // InternalFSM.g:6920:1: rule__TrPointTerminal__Group__0 : rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 ; |
| public final void rule__TrPointTerminal__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6924:1: ( rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 ) |
| // InternalFSM.g:6925:2: rule__TrPointTerminal__Group__0__Impl rule__TrPointTerminal__Group__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__TrPointTerminal__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__TrPointTerminal__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TrPointTerminal__Group__0" |
| |
| |
| // $ANTLR start "rule__TrPointTerminal__Group__0__Impl" |
| // InternalFSM.g:6932:1: rule__TrPointTerminal__Group__0__Impl : ( 'my' ) ; |
| public final void rule__TrPointTerminal__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6936:1: ( ( 'my' ) ) |
| // InternalFSM.g:6937:1: ( 'my' ) |
| { |
| // InternalFSM.g:6937:1: ( 'my' ) |
| // InternalFSM.g:6938:1: 'my' |
| { |
| before(grammarAccess.getTrPointTerminalAccess().getMyKeyword_0()); |
| match(input,51,FOLLOW_2); |
| after(grammarAccess.getTrPointTerminalAccess().getMyKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TrPointTerminal__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__TrPointTerminal__Group__1" |
| // InternalFSM.g:6951:1: rule__TrPointTerminal__Group__1 : rule__TrPointTerminal__Group__1__Impl ; |
| public final void rule__TrPointTerminal__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6955:1: ( rule__TrPointTerminal__Group__1__Impl ) |
| // InternalFSM.g:6956:2: rule__TrPointTerminal__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__TrPointTerminal__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TrPointTerminal__Group__1" |
| |
| |
| // $ANTLR start "rule__TrPointTerminal__Group__1__Impl" |
| // InternalFSM.g:6962:1: rule__TrPointTerminal__Group__1__Impl : ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) ; |
| public final void rule__TrPointTerminal__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6966:1: ( ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) ) |
| // InternalFSM.g:6967:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) |
| { |
| // InternalFSM.g:6967:1: ( ( rule__TrPointTerminal__TrPointAssignment_1 ) ) |
| // InternalFSM.g:6968:1: ( rule__TrPointTerminal__TrPointAssignment_1 ) |
| { |
| before(grammarAccess.getTrPointTerminalAccess().getTrPointAssignment_1()); |
| // InternalFSM.g:6969:1: ( rule__TrPointTerminal__TrPointAssignment_1 ) |
| // InternalFSM.g:6969:2: rule__TrPointTerminal__TrPointAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__TrPointTerminal__TrPointAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTrPointTerminalAccess().getTrPointAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TrPointTerminal__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__SubStateTrPointTerminal__Group__0" |
| // InternalFSM.g:6983:1: rule__SubStateTrPointTerminal__Group__0 : rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 ; |
| public final void rule__SubStateTrPointTerminal__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6987:1: ( rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 ) |
| // InternalFSM.g:6988:2: rule__SubStateTrPointTerminal__Group__0__Impl rule__SubStateTrPointTerminal__Group__1 |
| { |
| pushFollow(FOLLOW_29); |
| rule__SubStateTrPointTerminal__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SubStateTrPointTerminal__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SubStateTrPointTerminal__Group__0" |
| |
| |
| // $ANTLR start "rule__SubStateTrPointTerminal__Group__0__Impl" |
| // InternalFSM.g:6995:1: rule__SubStateTrPointTerminal__Group__0__Impl : ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) ; |
| public final void rule__SubStateTrPointTerminal__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:6999:1: ( ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) ) |
| // InternalFSM.g:7000:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) |
| { |
| // InternalFSM.g:7000:1: ( ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) ) |
| // InternalFSM.g:7001:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) |
| { |
| before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointAssignment_0()); |
| // InternalFSM.g:7002:1: ( rule__SubStateTrPointTerminal__TrPointAssignment_0 ) |
| // InternalFSM.g:7002:2: rule__SubStateTrPointTerminal__TrPointAssignment_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SubStateTrPointTerminal__TrPointAssignment_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointAssignment_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SubStateTrPointTerminal__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__SubStateTrPointTerminal__Group__1" |
| // InternalFSM.g:7012:1: rule__SubStateTrPointTerminal__Group__1 : rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 ; |
| public final void rule__SubStateTrPointTerminal__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7016:1: ( rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 ) |
| // InternalFSM.g:7017:2: rule__SubStateTrPointTerminal__Group__1__Impl rule__SubStateTrPointTerminal__Group__2 |
| { |
| pushFollow(FOLLOW_5); |
| rule__SubStateTrPointTerminal__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SubStateTrPointTerminal__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SubStateTrPointTerminal__Group__1" |
| |
| |
| // $ANTLR start "rule__SubStateTrPointTerminal__Group__1__Impl" |
| // InternalFSM.g:7024:1: rule__SubStateTrPointTerminal__Group__1__Impl : ( 'of' ) ; |
| public final void rule__SubStateTrPointTerminal__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7028:1: ( ( 'of' ) ) |
| // InternalFSM.g:7029:1: ( 'of' ) |
| { |
| // InternalFSM.g:7029:1: ( 'of' ) |
| // InternalFSM.g:7030:1: 'of' |
| { |
| before(grammarAccess.getSubStateTrPointTerminalAccess().getOfKeyword_1()); |
| match(input,52,FOLLOW_2); |
| after(grammarAccess.getSubStateTrPointTerminalAccess().getOfKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SubStateTrPointTerminal__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__SubStateTrPointTerminal__Group__2" |
| // InternalFSM.g:7043:1: rule__SubStateTrPointTerminal__Group__2 : rule__SubStateTrPointTerminal__Group__2__Impl ; |
| public final void rule__SubStateTrPointTerminal__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7047:1: ( rule__SubStateTrPointTerminal__Group__2__Impl ) |
| // InternalFSM.g:7048:2: rule__SubStateTrPointTerminal__Group__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__SubStateTrPointTerminal__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SubStateTrPointTerminal__Group__2" |
| |
| |
| // $ANTLR start "rule__SubStateTrPointTerminal__Group__2__Impl" |
| // InternalFSM.g:7054:1: rule__SubStateTrPointTerminal__Group__2__Impl : ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) ; |
| public final void rule__SubStateTrPointTerminal__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7058:1: ( ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) ) |
| // InternalFSM.g:7059:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) |
| { |
| // InternalFSM.g:7059:1: ( ( rule__SubStateTrPointTerminal__StateAssignment_2 ) ) |
| // InternalFSM.g:7060:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 ) |
| { |
| before(grammarAccess.getSubStateTrPointTerminalAccess().getStateAssignment_2()); |
| // InternalFSM.g:7061:1: ( rule__SubStateTrPointTerminal__StateAssignment_2 ) |
| // InternalFSM.g:7061:2: rule__SubStateTrPointTerminal__StateAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SubStateTrPointTerminal__StateAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSubStateTrPointTerminalAccess().getStateAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SubStateTrPointTerminal__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__ChoicepointTerminal__Group__0" |
| // InternalFSM.g:7077:1: rule__ChoicepointTerminal__Group__0 : rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 ; |
| public final void rule__ChoicepointTerminal__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7081:1: ( rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 ) |
| // InternalFSM.g:7082:2: rule__ChoicepointTerminal__Group__0__Impl rule__ChoicepointTerminal__Group__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__ChoicepointTerminal__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ChoicepointTerminal__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicepointTerminal__Group__0" |
| |
| |
| // $ANTLR start "rule__ChoicepointTerminal__Group__0__Impl" |
| // InternalFSM.g:7089:1: rule__ChoicepointTerminal__Group__0__Impl : ( 'cp' ) ; |
| public final void rule__ChoicepointTerminal__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7093:1: ( ( 'cp' ) ) |
| // InternalFSM.g:7094:1: ( 'cp' ) |
| { |
| // InternalFSM.g:7094:1: ( 'cp' ) |
| // InternalFSM.g:7095:1: 'cp' |
| { |
| before(grammarAccess.getChoicepointTerminalAccess().getCpKeyword_0()); |
| match(input,53,FOLLOW_2); |
| after(grammarAccess.getChoicepointTerminalAccess().getCpKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicepointTerminal__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ChoicepointTerminal__Group__1" |
| // InternalFSM.g:7108:1: rule__ChoicepointTerminal__Group__1 : rule__ChoicepointTerminal__Group__1__Impl ; |
| public final void rule__ChoicepointTerminal__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7112:1: ( rule__ChoicepointTerminal__Group__1__Impl ) |
| // InternalFSM.g:7113:2: rule__ChoicepointTerminal__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ChoicepointTerminal__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicepointTerminal__Group__1" |
| |
| |
| // $ANTLR start "rule__ChoicepointTerminal__Group__1__Impl" |
| // InternalFSM.g:7119:1: rule__ChoicepointTerminal__Group__1__Impl : ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) ; |
| public final void rule__ChoicepointTerminal__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7123:1: ( ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) ) |
| // InternalFSM.g:7124:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) |
| { |
| // InternalFSM.g:7124:1: ( ( rule__ChoicepointTerminal__CpAssignment_1 ) ) |
| // InternalFSM.g:7125:1: ( rule__ChoicepointTerminal__CpAssignment_1 ) |
| { |
| before(grammarAccess.getChoicepointTerminalAccess().getCpAssignment_1()); |
| // InternalFSM.g:7126:1: ( rule__ChoicepointTerminal__CpAssignment_1 ) |
| // InternalFSM.g:7126:2: rule__ChoicepointTerminal__CpAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ChoicepointTerminal__CpAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getChoicepointTerminalAccess().getCpAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicepointTerminal__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Trigger__Group__0" |
| // InternalFSM.g:7140:1: rule__Trigger__Group__0 : rule__Trigger__Group__0__Impl rule__Trigger__Group__1 ; |
| public final void rule__Trigger__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7144:1: ( rule__Trigger__Group__0__Impl rule__Trigger__Group__1 ) |
| // InternalFSM.g:7145:2: rule__Trigger__Group__0__Impl rule__Trigger__Group__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__Trigger__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Trigger__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group__0" |
| |
| |
| // $ANTLR start "rule__Trigger__Group__0__Impl" |
| // InternalFSM.g:7152:1: rule__Trigger__Group__0__Impl : ( '<' ) ; |
| public final void rule__Trigger__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7156:1: ( ( '<' ) ) |
| // InternalFSM.g:7157:1: ( '<' ) |
| { |
| // InternalFSM.g:7157:1: ( '<' ) |
| // InternalFSM.g:7158:1: '<' |
| { |
| before(grammarAccess.getTriggerAccess().getLessThanSignKeyword_0()); |
| match(input,54,FOLLOW_2); |
| after(grammarAccess.getTriggerAccess().getLessThanSignKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Trigger__Group__1" |
| // InternalFSM.g:7171:1: rule__Trigger__Group__1 : rule__Trigger__Group__1__Impl rule__Trigger__Group__2 ; |
| public final void rule__Trigger__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7175:1: ( rule__Trigger__Group__1__Impl rule__Trigger__Group__2 ) |
| // InternalFSM.g:7176:2: rule__Trigger__Group__1__Impl rule__Trigger__Group__2 |
| { |
| pushFollow(FOLLOW_30); |
| rule__Trigger__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Trigger__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group__1" |
| |
| |
| // $ANTLR start "rule__Trigger__Group__1__Impl" |
| // InternalFSM.g:7183:1: rule__Trigger__Group__1__Impl : ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) ; |
| public final void rule__Trigger__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7187:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) ) |
| // InternalFSM.g:7188:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) |
| { |
| // InternalFSM.g:7188:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_1 ) ) |
| // InternalFSM.g:7189:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 ) |
| { |
| before(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_1()); |
| // InternalFSM.g:7190:1: ( rule__Trigger__MsgFromIfPairsAssignment_1 ) |
| // InternalFSM.g:7190:2: rule__Trigger__MsgFromIfPairsAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Trigger__MsgFromIfPairsAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Trigger__Group__2" |
| // InternalFSM.g:7200:1: rule__Trigger__Group__2 : rule__Trigger__Group__2__Impl rule__Trigger__Group__3 ; |
| public final void rule__Trigger__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7204:1: ( rule__Trigger__Group__2__Impl rule__Trigger__Group__3 ) |
| // InternalFSM.g:7205:2: rule__Trigger__Group__2__Impl rule__Trigger__Group__3 |
| { |
| pushFollow(FOLLOW_30); |
| rule__Trigger__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Trigger__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group__2" |
| |
| |
| // $ANTLR start "rule__Trigger__Group__2__Impl" |
| // InternalFSM.g:7212:1: rule__Trigger__Group__2__Impl : ( ( rule__Trigger__Group_2__0 )* ) ; |
| public final void rule__Trigger__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7216:1: ( ( ( rule__Trigger__Group_2__0 )* ) ) |
| // InternalFSM.g:7217:1: ( ( rule__Trigger__Group_2__0 )* ) |
| { |
| // InternalFSM.g:7217:1: ( ( rule__Trigger__Group_2__0 )* ) |
| // InternalFSM.g:7218:1: ( rule__Trigger__Group_2__0 )* |
| { |
| before(grammarAccess.getTriggerAccess().getGroup_2()); |
| // InternalFSM.g:7219:1: ( rule__Trigger__Group_2__0 )* |
| loop65: |
| do { |
| int alt65=2; |
| int LA65_0 = input.LA(1); |
| |
| if ( (LA65_0==56) ) { |
| alt65=1; |
| } |
| |
| |
| switch (alt65) { |
| case 1 : |
| // InternalFSM.g:7219:2: rule__Trigger__Group_2__0 |
| { |
| pushFollow(FOLLOW_31); |
| rule__Trigger__Group_2__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop65; |
| } |
| } while (true); |
| |
| after(grammarAccess.getTriggerAccess().getGroup_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Trigger__Group__3" |
| // InternalFSM.g:7229:1: rule__Trigger__Group__3 : rule__Trigger__Group__3__Impl rule__Trigger__Group__4 ; |
| public final void rule__Trigger__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7233:1: ( rule__Trigger__Group__3__Impl rule__Trigger__Group__4 ) |
| // InternalFSM.g:7234:2: rule__Trigger__Group__3__Impl rule__Trigger__Group__4 |
| { |
| pushFollow(FOLLOW_30); |
| rule__Trigger__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Trigger__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group__3" |
| |
| |
| // $ANTLR start "rule__Trigger__Group__3__Impl" |
| // InternalFSM.g:7241:1: rule__Trigger__Group__3__Impl : ( ( rule__Trigger__GuardAssignment_3 )? ) ; |
| public final void rule__Trigger__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7245:1: ( ( ( rule__Trigger__GuardAssignment_3 )? ) ) |
| // InternalFSM.g:7246:1: ( ( rule__Trigger__GuardAssignment_3 )? ) |
| { |
| // InternalFSM.g:7246:1: ( ( rule__Trigger__GuardAssignment_3 )? ) |
| // InternalFSM.g:7247:1: ( rule__Trigger__GuardAssignment_3 )? |
| { |
| before(grammarAccess.getTriggerAccess().getGuardAssignment_3()); |
| // InternalFSM.g:7248:1: ( rule__Trigger__GuardAssignment_3 )? |
| int alt66=2; |
| int LA66_0 = input.LA(1); |
| |
| if ( (LA66_0==48) ) { |
| alt66=1; |
| } |
| switch (alt66) { |
| case 1 : |
| // InternalFSM.g:7248:2: rule__Trigger__GuardAssignment_3 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Trigger__GuardAssignment_3(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getTriggerAccess().getGuardAssignment_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__Trigger__Group__4" |
| // InternalFSM.g:7258:1: rule__Trigger__Group__4 : rule__Trigger__Group__4__Impl ; |
| public final void rule__Trigger__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7262:1: ( rule__Trigger__Group__4__Impl ) |
| // InternalFSM.g:7263:2: rule__Trigger__Group__4__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__Trigger__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group__4" |
| |
| |
| // $ANTLR start "rule__Trigger__Group__4__Impl" |
| // InternalFSM.g:7269:1: rule__Trigger__Group__4__Impl : ( '>' ) ; |
| public final void rule__Trigger__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7273:1: ( ( '>' ) ) |
| // InternalFSM.g:7274:1: ( '>' ) |
| { |
| // InternalFSM.g:7274:1: ( '>' ) |
| // InternalFSM.g:7275:1: '>' |
| { |
| before(grammarAccess.getTriggerAccess().getGreaterThanSignKeyword_4()); |
| match(input,55,FOLLOW_2); |
| after(grammarAccess.getTriggerAccess().getGreaterThanSignKeyword_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__Trigger__Group_2__0" |
| // InternalFSM.g:7298:1: rule__Trigger__Group_2__0 : rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 ; |
| public final void rule__Trigger__Group_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7302:1: ( rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 ) |
| // InternalFSM.g:7303:2: rule__Trigger__Group_2__0__Impl rule__Trigger__Group_2__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__Trigger__Group_2__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Trigger__Group_2__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group_2__0" |
| |
| |
| // $ANTLR start "rule__Trigger__Group_2__0__Impl" |
| // InternalFSM.g:7310:1: rule__Trigger__Group_2__0__Impl : ( '|' ) ; |
| public final void rule__Trigger__Group_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7314:1: ( ( '|' ) ) |
| // InternalFSM.g:7315:1: ( '|' ) |
| { |
| // InternalFSM.g:7315:1: ( '|' ) |
| // InternalFSM.g:7316:1: '|' |
| { |
| before(grammarAccess.getTriggerAccess().getVerticalLineKeyword_2_0()); |
| match(input,56,FOLLOW_2); |
| after(grammarAccess.getTriggerAccess().getVerticalLineKeyword_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__Trigger__Group_2__1" |
| // InternalFSM.g:7329:1: rule__Trigger__Group_2__1 : rule__Trigger__Group_2__1__Impl ; |
| public final void rule__Trigger__Group_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7333:1: ( rule__Trigger__Group_2__1__Impl ) |
| // InternalFSM.g:7334:2: rule__Trigger__Group_2__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__Trigger__Group_2__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group_2__1" |
| |
| |
| // $ANTLR start "rule__Trigger__Group_2__1__Impl" |
| // InternalFSM.g:7340:1: rule__Trigger__Group_2__1__Impl : ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) ; |
| public final void rule__Trigger__Group_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7344:1: ( ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) ) |
| // InternalFSM.g:7345:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) |
| { |
| // InternalFSM.g:7345:1: ( ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) ) |
| // InternalFSM.g:7346:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) |
| { |
| before(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_2_1()); |
| // InternalFSM.g:7347:1: ( rule__Trigger__MsgFromIfPairsAssignment_2_1 ) |
| // InternalFSM.g:7347:2: rule__Trigger__MsgFromIfPairsAssignment_2_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Trigger__MsgFromIfPairsAssignment_2_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_2_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__Group_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__MessageFromIf__Group__0" |
| // InternalFSM.g:7361:1: rule__MessageFromIf__Group__0 : rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 ; |
| public final void rule__MessageFromIf__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7365:1: ( rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 ) |
| // InternalFSM.g:7366:2: rule__MessageFromIf__Group__0__Impl rule__MessageFromIf__Group__1 |
| { |
| pushFollow(FOLLOW_32); |
| rule__MessageFromIf__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__MessageFromIf__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MessageFromIf__Group__0" |
| |
| |
| // $ANTLR start "rule__MessageFromIf__Group__0__Impl" |
| // InternalFSM.g:7373:1: rule__MessageFromIf__Group__0__Impl : ( ( rule__MessageFromIf__MessageAssignment_0 ) ) ; |
| public final void rule__MessageFromIf__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7377:1: ( ( ( rule__MessageFromIf__MessageAssignment_0 ) ) ) |
| // InternalFSM.g:7378:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) ) |
| { |
| // InternalFSM.g:7378:1: ( ( rule__MessageFromIf__MessageAssignment_0 ) ) |
| // InternalFSM.g:7379:1: ( rule__MessageFromIf__MessageAssignment_0 ) |
| { |
| before(grammarAccess.getMessageFromIfAccess().getMessageAssignment_0()); |
| // InternalFSM.g:7380:1: ( rule__MessageFromIf__MessageAssignment_0 ) |
| // InternalFSM.g:7380:2: rule__MessageFromIf__MessageAssignment_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__MessageFromIf__MessageAssignment_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getMessageFromIfAccess().getMessageAssignment_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MessageFromIf__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__MessageFromIf__Group__1" |
| // InternalFSM.g:7390:1: rule__MessageFromIf__Group__1 : rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 ; |
| public final void rule__MessageFromIf__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7394:1: ( rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 ) |
| // InternalFSM.g:7395:2: rule__MessageFromIf__Group__1__Impl rule__MessageFromIf__Group__2 |
| { |
| pushFollow(FOLLOW_5); |
| rule__MessageFromIf__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__MessageFromIf__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MessageFromIf__Group__1" |
| |
| |
| // $ANTLR start "rule__MessageFromIf__Group__1__Impl" |
| // InternalFSM.g:7402:1: rule__MessageFromIf__Group__1__Impl : ( ':' ) ; |
| public final void rule__MessageFromIf__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7406:1: ( ( ':' ) ) |
| // InternalFSM.g:7407:1: ( ':' ) |
| { |
| // InternalFSM.g:7407:1: ( ':' ) |
| // InternalFSM.g:7408:1: ':' |
| { |
| before(grammarAccess.getMessageFromIfAccess().getColonKeyword_1()); |
| match(input,42,FOLLOW_2); |
| after(grammarAccess.getMessageFromIfAccess().getColonKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MessageFromIf__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__MessageFromIf__Group__2" |
| // InternalFSM.g:7421:1: rule__MessageFromIf__Group__2 : rule__MessageFromIf__Group__2__Impl ; |
| public final void rule__MessageFromIf__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7425:1: ( rule__MessageFromIf__Group__2__Impl ) |
| // InternalFSM.g:7426:2: rule__MessageFromIf__Group__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__MessageFromIf__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MessageFromIf__Group__2" |
| |
| |
| // $ANTLR start "rule__MessageFromIf__Group__2__Impl" |
| // InternalFSM.g:7432:1: rule__MessageFromIf__Group__2__Impl : ( ( rule__MessageFromIf__FromAssignment_2 ) ) ; |
| public final void rule__MessageFromIf__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7436:1: ( ( ( rule__MessageFromIf__FromAssignment_2 ) ) ) |
| // InternalFSM.g:7437:1: ( ( rule__MessageFromIf__FromAssignment_2 ) ) |
| { |
| // InternalFSM.g:7437:1: ( ( rule__MessageFromIf__FromAssignment_2 ) ) |
| // InternalFSM.g:7438:1: ( rule__MessageFromIf__FromAssignment_2 ) |
| { |
| before(grammarAccess.getMessageFromIfAccess().getFromAssignment_2()); |
| // InternalFSM.g:7439:1: ( rule__MessageFromIf__FromAssignment_2 ) |
| // InternalFSM.g:7439:2: rule__MessageFromIf__FromAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__MessageFromIf__FromAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getMessageFromIfAccess().getFromAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MessageFromIf__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Guard__Group__0" |
| // InternalFSM.g:7455:1: rule__Guard__Group__0 : rule__Guard__Group__0__Impl rule__Guard__Group__1 ; |
| public final void rule__Guard__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7459:1: ( rule__Guard__Group__0__Impl rule__Guard__Group__1 ) |
| // InternalFSM.g:7460:2: rule__Guard__Group__0__Impl rule__Guard__Group__1 |
| { |
| pushFollow(FOLLOW_7); |
| rule__Guard__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Guard__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Guard__Group__0" |
| |
| |
| // $ANTLR start "rule__Guard__Group__0__Impl" |
| // InternalFSM.g:7467:1: rule__Guard__Group__0__Impl : ( 'guard' ) ; |
| public final void rule__Guard__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7471:1: ( ( 'guard' ) ) |
| // InternalFSM.g:7472:1: ( 'guard' ) |
| { |
| // InternalFSM.g:7472:1: ( 'guard' ) |
| // InternalFSM.g:7473:1: 'guard' |
| { |
| before(grammarAccess.getGuardAccess().getGuardKeyword_0()); |
| match(input,48,FOLLOW_2); |
| after(grammarAccess.getGuardAccess().getGuardKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Guard__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Guard__Group__1" |
| // InternalFSM.g:7486:1: rule__Guard__Group__1 : rule__Guard__Group__1__Impl ; |
| public final void rule__Guard__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7490:1: ( rule__Guard__Group__1__Impl ) |
| // InternalFSM.g:7491:2: rule__Guard__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__Guard__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Guard__Group__1" |
| |
| |
| // $ANTLR start "rule__Guard__Group__1__Impl" |
| // InternalFSM.g:7497:1: rule__Guard__Group__1__Impl : ( ( rule__Guard__GuardAssignment_1 ) ) ; |
| public final void rule__Guard__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7501:1: ( ( ( rule__Guard__GuardAssignment_1 ) ) ) |
| // InternalFSM.g:7502:1: ( ( rule__Guard__GuardAssignment_1 ) ) |
| { |
| // InternalFSM.g:7502:1: ( ( rule__Guard__GuardAssignment_1 ) ) |
| // InternalFSM.g:7503:1: ( rule__Guard__GuardAssignment_1 ) |
| { |
| before(grammarAccess.getGuardAccess().getGuardAssignment_1()); |
| // InternalFSM.g:7504:1: ( rule__Guard__GuardAssignment_1 ) |
| // InternalFSM.g:7504:2: rule__Guard__GuardAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Guard__GuardAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getGuardAccess().getGuardAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Guard__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group__0" |
| // InternalFSM.g:7519:1: rule__InSemanticsRule__Group__0 : rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 ; |
| public final void rule__InSemanticsRule__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7523:1: ( rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 ) |
| // InternalFSM.g:7524:2: rule__InSemanticsRule__Group__0__Impl rule__InSemanticsRule__Group__1 |
| { |
| pushFollow(FOLLOW_32); |
| rule__InSemanticsRule__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group__0" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group__0__Impl" |
| // InternalFSM.g:7531:1: rule__InSemanticsRule__Group__0__Impl : ( 'in' ) ; |
| public final void rule__InSemanticsRule__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7535:1: ( ( 'in' ) ) |
| // InternalFSM.g:7536:1: ( 'in' ) |
| { |
| // InternalFSM.g:7536:1: ( 'in' ) |
| // InternalFSM.g:7537:1: 'in' |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getInKeyword_0()); |
| match(input,57,FOLLOW_2); |
| after(grammarAccess.getInSemanticsRuleAccess().getInKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group__1" |
| // InternalFSM.g:7550:1: rule__InSemanticsRule__Group__1 : rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 ; |
| public final void rule__InSemanticsRule__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7554:1: ( rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 ) |
| // InternalFSM.g:7555:2: rule__InSemanticsRule__Group__1__Impl rule__InSemanticsRule__Group__2 |
| { |
| pushFollow(FOLLOW_5); |
| rule__InSemanticsRule__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group__1" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group__1__Impl" |
| // InternalFSM.g:7562:1: rule__InSemanticsRule__Group__1__Impl : ( ':' ) ; |
| public final void rule__InSemanticsRule__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7566:1: ( ( ':' ) ) |
| // InternalFSM.g:7567:1: ( ':' ) |
| { |
| // InternalFSM.g:7567:1: ( ':' ) |
| // InternalFSM.g:7568:1: ':' |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getColonKeyword_1()); |
| match(input,42,FOLLOW_2); |
| after(grammarAccess.getInSemanticsRuleAccess().getColonKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group__2" |
| // InternalFSM.g:7581:1: rule__InSemanticsRule__Group__2 : rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 ; |
| public final void rule__InSemanticsRule__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7585:1: ( rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 ) |
| // InternalFSM.g:7586:2: rule__InSemanticsRule__Group__2__Impl rule__InSemanticsRule__Group__3 |
| { |
| pushFollow(FOLLOW_18); |
| rule__InSemanticsRule__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group__2" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group__2__Impl" |
| // InternalFSM.g:7593:1: rule__InSemanticsRule__Group__2__Impl : ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) ; |
| public final void rule__InSemanticsRule__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7597:1: ( ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) ) |
| // InternalFSM.g:7598:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) |
| { |
| // InternalFSM.g:7598:1: ( ( rule__InSemanticsRule__MsgAssignment_2 ) ) |
| // InternalFSM.g:7599:1: ( rule__InSemanticsRule__MsgAssignment_2 ) |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getMsgAssignment_2()); |
| // InternalFSM.g:7600:1: ( rule__InSemanticsRule__MsgAssignment_2 ) |
| // InternalFSM.g:7600:2: rule__InSemanticsRule__MsgAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__MsgAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getMsgAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group__3" |
| // InternalFSM.g:7610:1: rule__InSemanticsRule__Group__3 : rule__InSemanticsRule__Group__3__Impl ; |
| public final void rule__InSemanticsRule__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7614:1: ( rule__InSemanticsRule__Group__3__Impl ) |
| // InternalFSM.g:7615:2: rule__InSemanticsRule__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group__3" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group__3__Impl" |
| // InternalFSM.g:7621:1: rule__InSemanticsRule__Group__3__Impl : ( ( rule__InSemanticsRule__Group_3__0 )? ) ; |
| public final void rule__InSemanticsRule__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7625:1: ( ( ( rule__InSemanticsRule__Group_3__0 )? ) ) |
| // InternalFSM.g:7626:1: ( ( rule__InSemanticsRule__Group_3__0 )? ) |
| { |
| // InternalFSM.g:7626:1: ( ( rule__InSemanticsRule__Group_3__0 )? ) |
| // InternalFSM.g:7627:1: ( rule__InSemanticsRule__Group_3__0 )? |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getGroup_3()); |
| // InternalFSM.g:7628:1: ( rule__InSemanticsRule__Group_3__0 )? |
| int alt67=2; |
| int LA67_0 = input.LA(1); |
| |
| if ( (LA67_0==44) ) { |
| alt67=1; |
| } |
| switch (alt67) { |
| case 1 : |
| // InternalFSM.g:7628:2: rule__InSemanticsRule__Group_3__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group_3__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getGroup_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3__0" |
| // InternalFSM.g:7646:1: rule__InSemanticsRule__Group_3__0 : rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 ; |
| public final void rule__InSemanticsRule__Group_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7650:1: ( rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 ) |
| // InternalFSM.g:7651:2: rule__InSemanticsRule__Group_3__0__Impl rule__InSemanticsRule__Group_3__1 |
| { |
| pushFollow(FOLLOW_33); |
| rule__InSemanticsRule__Group_3__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group_3__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3__0" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3__0__Impl" |
| // InternalFSM.g:7658:1: rule__InSemanticsRule__Group_3__0__Impl : ( '->' ) ; |
| public final void rule__InSemanticsRule__Group_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7662:1: ( ( '->' ) ) |
| // InternalFSM.g:7663:1: ( '->' ) |
| { |
| // InternalFSM.g:7663:1: ( '->' ) |
| // InternalFSM.g:7664:1: '->' |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); |
| match(input,44,FOLLOW_2); |
| after(grammarAccess.getInSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3__1" |
| // InternalFSM.g:7677:1: rule__InSemanticsRule__Group_3__1 : rule__InSemanticsRule__Group_3__1__Impl ; |
| public final void rule__InSemanticsRule__Group_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7681:1: ( rule__InSemanticsRule__Group_3__1__Impl ) |
| // InternalFSM.g:7682:2: rule__InSemanticsRule__Group_3__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group_3__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3__1" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3__1__Impl" |
| // InternalFSM.g:7688:1: rule__InSemanticsRule__Group_3__1__Impl : ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) ; |
| public final void rule__InSemanticsRule__Group_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7692:1: ( ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) ) |
| // InternalFSM.g:7693:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) |
| { |
| // InternalFSM.g:7693:1: ( ( rule__InSemanticsRule__Alternatives_3_1 ) ) |
| // InternalFSM.g:7694:1: ( rule__InSemanticsRule__Alternatives_3_1 ) |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getAlternatives_3_1()); |
| // InternalFSM.g:7695:1: ( rule__InSemanticsRule__Alternatives_3_1 ) |
| // InternalFSM.g:7695:2: rule__InSemanticsRule__Alternatives_3_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Alternatives_3_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getAlternatives_3_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__0" |
| // InternalFSM.g:7709:1: rule__InSemanticsRule__Group_3_1_1__0 : rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 ; |
| public final void rule__InSemanticsRule__Group_3_1_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7713:1: ( rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 ) |
| // InternalFSM.g:7714:2: rule__InSemanticsRule__Group_3_1_1__0__Impl rule__InSemanticsRule__Group_3_1_1__1 |
| { |
| pushFollow(FOLLOW_34); |
| rule__InSemanticsRule__Group_3_1_1__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group_3_1_1__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1__0" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__0__Impl" |
| // InternalFSM.g:7721:1: rule__InSemanticsRule__Group_3_1_1__0__Impl : ( '(' ) ; |
| public final void rule__InSemanticsRule__Group_3_1_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7725:1: ( ( '(' ) ) |
| // InternalFSM.g:7726:1: ( '(' ) |
| { |
| // InternalFSM.g:7726:1: ( '(' ) |
| // InternalFSM.g:7727:1: '(' |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); |
| match(input,58,FOLLOW_2); |
| after(grammarAccess.getInSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__1" |
| // InternalFSM.g:7740:1: rule__InSemanticsRule__Group_3_1_1__1 : rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 ; |
| public final void rule__InSemanticsRule__Group_3_1_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7744:1: ( rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 ) |
| // InternalFSM.g:7745:2: rule__InSemanticsRule__Group_3_1_1__1__Impl rule__InSemanticsRule__Group_3_1_1__2 |
| { |
| pushFollow(FOLLOW_35); |
| rule__InSemanticsRule__Group_3_1_1__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group_3_1_1__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1__1" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__1__Impl" |
| // InternalFSM.g:7752:1: rule__InSemanticsRule__Group_3_1_1__1__Impl : ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ; |
| public final void rule__InSemanticsRule__Group_3_1_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7756:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ) |
| // InternalFSM.g:7757:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) |
| { |
| // InternalFSM.g:7757:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) |
| // InternalFSM.g:7758:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); |
| // InternalFSM.g:7759:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 ) |
| // InternalFSM.g:7759:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__2" |
| // InternalFSM.g:7769:1: rule__InSemanticsRule__Group_3_1_1__2 : rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 ; |
| public final void rule__InSemanticsRule__Group_3_1_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7773:1: ( rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 ) |
| // InternalFSM.g:7774:2: rule__InSemanticsRule__Group_3_1_1__2__Impl rule__InSemanticsRule__Group_3_1_1__3 |
| { |
| pushFollow(FOLLOW_36); |
| rule__InSemanticsRule__Group_3_1_1__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group_3_1_1__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1__2" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__2__Impl" |
| // InternalFSM.g:7781:1: rule__InSemanticsRule__Group_3_1_1__2__Impl : ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) ; |
| public final void rule__InSemanticsRule__Group_3_1_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7785:1: ( ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) ) |
| // InternalFSM.g:7786:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) |
| { |
| // InternalFSM.g:7786:1: ( ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) ) |
| // InternalFSM.g:7787:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) |
| { |
| // InternalFSM.g:7787:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 ) ) |
| // InternalFSM.g:7788:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 ) |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); |
| // InternalFSM.g:7789:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 ) |
| // InternalFSM.g:7789:2: rule__InSemanticsRule__Group_3_1_1_2__0 |
| { |
| pushFollow(FOLLOW_37); |
| rule__InSemanticsRule__Group_3_1_1_2__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); |
| |
| } |
| |
| // InternalFSM.g:7792:1: ( ( rule__InSemanticsRule__Group_3_1_1_2__0 )* ) |
| // InternalFSM.g:7793:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )* |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); |
| // InternalFSM.g:7794:1: ( rule__InSemanticsRule__Group_3_1_1_2__0 )* |
| loop68: |
| do { |
| int alt68=2; |
| int LA68_0 = input.LA(1); |
| |
| if ( (LA68_0==60) ) { |
| alt68=1; |
| } |
| |
| |
| switch (alt68) { |
| case 1 : |
| // InternalFSM.g:7794:2: rule__InSemanticsRule__Group_3_1_1_2__0 |
| { |
| pushFollow(FOLLOW_37); |
| rule__InSemanticsRule__Group_3_1_1_2__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop68; |
| } |
| } while (true); |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__3" |
| // InternalFSM.g:7805:1: rule__InSemanticsRule__Group_3_1_1__3 : rule__InSemanticsRule__Group_3_1_1__3__Impl ; |
| public final void rule__InSemanticsRule__Group_3_1_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7809:1: ( rule__InSemanticsRule__Group_3_1_1__3__Impl ) |
| // InternalFSM.g:7810:2: rule__InSemanticsRule__Group_3_1_1__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group_3_1_1__3__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1__3" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1__3__Impl" |
| // InternalFSM.g:7816:1: rule__InSemanticsRule__Group_3_1_1__3__Impl : ( ')' ) ; |
| public final void rule__InSemanticsRule__Group_3_1_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7820:1: ( ( ')' ) ) |
| // InternalFSM.g:7821:1: ( ')' ) |
| { |
| // InternalFSM.g:7821:1: ( ')' ) |
| // InternalFSM.g:7822:1: ')' |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); |
| match(input,59,FOLLOW_2); |
| after(grammarAccess.getInSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__0" |
| // InternalFSM.g:7843:1: rule__InSemanticsRule__Group_3_1_1_2__0 : rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 ; |
| public final void rule__InSemanticsRule__Group_3_1_1_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7847:1: ( rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 ) |
| // InternalFSM.g:7848:2: rule__InSemanticsRule__Group_3_1_1_2__0__Impl rule__InSemanticsRule__Group_3_1_1_2__1 |
| { |
| pushFollow(FOLLOW_34); |
| rule__InSemanticsRule__Group_3_1_1_2__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group_3_1_1_2__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1_2__0" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__0__Impl" |
| // InternalFSM.g:7855:1: rule__InSemanticsRule__Group_3_1_1_2__0__Impl : ( ',' ) ; |
| public final void rule__InSemanticsRule__Group_3_1_1_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7859:1: ( ( ',' ) ) |
| // InternalFSM.g:7860:1: ( ',' ) |
| { |
| // InternalFSM.g:7860:1: ( ',' ) |
| // InternalFSM.g:7861:1: ',' |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); |
| match(input,60,FOLLOW_2); |
| after(grammarAccess.getInSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__1" |
| // InternalFSM.g:7874:1: rule__InSemanticsRule__Group_3_1_1_2__1 : rule__InSemanticsRule__Group_3_1_1_2__1__Impl ; |
| public final void rule__InSemanticsRule__Group_3_1_1_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7878:1: ( rule__InSemanticsRule__Group_3_1_1_2__1__Impl ) |
| // InternalFSM.g:7879:2: rule__InSemanticsRule__Group_3_1_1_2__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__Group_3_1_1_2__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1_2__1" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__Group_3_1_1_2__1__Impl" |
| // InternalFSM.g:7885:1: rule__InSemanticsRule__Group_3_1_1_2__1__Impl : ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ; |
| public final void rule__InSemanticsRule__Group_3_1_1_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7889:1: ( ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ) |
| // InternalFSM.g:7890:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) |
| { |
| // InternalFSM.g:7890:1: ( ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) |
| // InternalFSM.g:7891:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); |
| // InternalFSM.g:7892:1: ( rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) |
| // InternalFSM.g:7892:2: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__Group_3_1_1_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group__0" |
| // InternalFSM.g:7906:1: rule__OutSemanticsRule__Group__0 : rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 ; |
| public final void rule__OutSemanticsRule__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7910:1: ( rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 ) |
| // InternalFSM.g:7911:2: rule__OutSemanticsRule__Group__0__Impl rule__OutSemanticsRule__Group__1 |
| { |
| pushFollow(FOLLOW_32); |
| rule__OutSemanticsRule__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group__0" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group__0__Impl" |
| // InternalFSM.g:7918:1: rule__OutSemanticsRule__Group__0__Impl : ( 'out' ) ; |
| public final void rule__OutSemanticsRule__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7922:1: ( ( 'out' ) ) |
| // InternalFSM.g:7923:1: ( 'out' ) |
| { |
| // InternalFSM.g:7923:1: ( 'out' ) |
| // InternalFSM.g:7924:1: 'out' |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getOutKeyword_0()); |
| match(input,61,FOLLOW_2); |
| after(grammarAccess.getOutSemanticsRuleAccess().getOutKeyword_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group__1" |
| // InternalFSM.g:7937:1: rule__OutSemanticsRule__Group__1 : rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 ; |
| public final void rule__OutSemanticsRule__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7941:1: ( rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 ) |
| // InternalFSM.g:7942:2: rule__OutSemanticsRule__Group__1__Impl rule__OutSemanticsRule__Group__2 |
| { |
| pushFollow(FOLLOW_5); |
| rule__OutSemanticsRule__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group__1" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group__1__Impl" |
| // InternalFSM.g:7949:1: rule__OutSemanticsRule__Group__1__Impl : ( ':' ) ; |
| public final void rule__OutSemanticsRule__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7953:1: ( ( ':' ) ) |
| // InternalFSM.g:7954:1: ( ':' ) |
| { |
| // InternalFSM.g:7954:1: ( ':' ) |
| // InternalFSM.g:7955:1: ':' |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getColonKeyword_1()); |
| match(input,42,FOLLOW_2); |
| after(grammarAccess.getOutSemanticsRuleAccess().getColonKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group__2" |
| // InternalFSM.g:7968:1: rule__OutSemanticsRule__Group__2 : rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 ; |
| public final void rule__OutSemanticsRule__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7972:1: ( rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 ) |
| // InternalFSM.g:7973:2: rule__OutSemanticsRule__Group__2__Impl rule__OutSemanticsRule__Group__3 |
| { |
| pushFollow(FOLLOW_18); |
| rule__OutSemanticsRule__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group__2" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group__2__Impl" |
| // InternalFSM.g:7980:1: rule__OutSemanticsRule__Group__2__Impl : ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) ; |
| public final void rule__OutSemanticsRule__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:7984:1: ( ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) ) |
| // InternalFSM.g:7985:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) |
| { |
| // InternalFSM.g:7985:1: ( ( rule__OutSemanticsRule__MsgAssignment_2 ) ) |
| // InternalFSM.g:7986:1: ( rule__OutSemanticsRule__MsgAssignment_2 ) |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getMsgAssignment_2()); |
| // InternalFSM.g:7987:1: ( rule__OutSemanticsRule__MsgAssignment_2 ) |
| // InternalFSM.g:7987:2: rule__OutSemanticsRule__MsgAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__MsgAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getMsgAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group__3" |
| // InternalFSM.g:7997:1: rule__OutSemanticsRule__Group__3 : rule__OutSemanticsRule__Group__3__Impl ; |
| public final void rule__OutSemanticsRule__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8001:1: ( rule__OutSemanticsRule__Group__3__Impl ) |
| // InternalFSM.g:8002:2: rule__OutSemanticsRule__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group__3" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group__3__Impl" |
| // InternalFSM.g:8008:1: rule__OutSemanticsRule__Group__3__Impl : ( ( rule__OutSemanticsRule__Group_3__0 )? ) ; |
| public final void rule__OutSemanticsRule__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8012:1: ( ( ( rule__OutSemanticsRule__Group_3__0 )? ) ) |
| // InternalFSM.g:8013:1: ( ( rule__OutSemanticsRule__Group_3__0 )? ) |
| { |
| // InternalFSM.g:8013:1: ( ( rule__OutSemanticsRule__Group_3__0 )? ) |
| // InternalFSM.g:8014:1: ( rule__OutSemanticsRule__Group_3__0 )? |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3()); |
| // InternalFSM.g:8015:1: ( rule__OutSemanticsRule__Group_3__0 )? |
| int alt69=2; |
| int LA69_0 = input.LA(1); |
| |
| if ( (LA69_0==44) ) { |
| alt69=1; |
| } |
| switch (alt69) { |
| case 1 : |
| // InternalFSM.g:8015:2: rule__OutSemanticsRule__Group_3__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group_3__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getGroup_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3__0" |
| // InternalFSM.g:8033:1: rule__OutSemanticsRule__Group_3__0 : rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 ; |
| public final void rule__OutSemanticsRule__Group_3__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8037:1: ( rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 ) |
| // InternalFSM.g:8038:2: rule__OutSemanticsRule__Group_3__0__Impl rule__OutSemanticsRule__Group_3__1 |
| { |
| pushFollow(FOLLOW_33); |
| rule__OutSemanticsRule__Group_3__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group_3__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3__0" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3__0__Impl" |
| // InternalFSM.g:8045:1: rule__OutSemanticsRule__Group_3__0__Impl : ( '->' ) ; |
| public final void rule__OutSemanticsRule__Group_3__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8049:1: ( ( '->' ) ) |
| // InternalFSM.g:8050:1: ( '->' ) |
| { |
| // InternalFSM.g:8050:1: ( '->' ) |
| // InternalFSM.g:8051:1: '->' |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); |
| match(input,44,FOLLOW_2); |
| after(grammarAccess.getOutSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3__0__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3__1" |
| // InternalFSM.g:8064:1: rule__OutSemanticsRule__Group_3__1 : rule__OutSemanticsRule__Group_3__1__Impl ; |
| public final void rule__OutSemanticsRule__Group_3__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8068:1: ( rule__OutSemanticsRule__Group_3__1__Impl ) |
| // InternalFSM.g:8069:2: rule__OutSemanticsRule__Group_3__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group_3__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3__1" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3__1__Impl" |
| // InternalFSM.g:8075:1: rule__OutSemanticsRule__Group_3__1__Impl : ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) ; |
| public final void rule__OutSemanticsRule__Group_3__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8079:1: ( ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) ) |
| // InternalFSM.g:8080:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) |
| { |
| // InternalFSM.g:8080:1: ( ( rule__OutSemanticsRule__Alternatives_3_1 ) ) |
| // InternalFSM.g:8081:1: ( rule__OutSemanticsRule__Alternatives_3_1 ) |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getAlternatives_3_1()); |
| // InternalFSM.g:8082:1: ( rule__OutSemanticsRule__Alternatives_3_1 ) |
| // InternalFSM.g:8082:2: rule__OutSemanticsRule__Alternatives_3_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Alternatives_3_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getAlternatives_3_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3__1__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__0" |
| // InternalFSM.g:8096:1: rule__OutSemanticsRule__Group_3_1_1__0 : rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 ; |
| public final void rule__OutSemanticsRule__Group_3_1_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8100:1: ( rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 ) |
| // InternalFSM.g:8101:2: rule__OutSemanticsRule__Group_3_1_1__0__Impl rule__OutSemanticsRule__Group_3_1_1__1 |
| { |
| pushFollow(FOLLOW_34); |
| rule__OutSemanticsRule__Group_3_1_1__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group_3_1_1__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1__0" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__0__Impl" |
| // InternalFSM.g:8108:1: rule__OutSemanticsRule__Group_3_1_1__0__Impl : ( '(' ) ; |
| public final void rule__OutSemanticsRule__Group_3_1_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8112:1: ( ( '(' ) ) |
| // InternalFSM.g:8113:1: ( '(' ) |
| { |
| // InternalFSM.g:8113:1: ( '(' ) |
| // InternalFSM.g:8114:1: '(' |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); |
| match(input,58,FOLLOW_2); |
| after(grammarAccess.getOutSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__1" |
| // InternalFSM.g:8127:1: rule__OutSemanticsRule__Group_3_1_1__1 : rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 ; |
| public final void rule__OutSemanticsRule__Group_3_1_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8131:1: ( rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 ) |
| // InternalFSM.g:8132:2: rule__OutSemanticsRule__Group_3_1_1__1__Impl rule__OutSemanticsRule__Group_3_1_1__2 |
| { |
| pushFollow(FOLLOW_35); |
| rule__OutSemanticsRule__Group_3_1_1__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group_3_1_1__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1__1" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__1__Impl" |
| // InternalFSM.g:8139:1: rule__OutSemanticsRule__Group_3_1_1__1__Impl : ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ; |
| public final void rule__OutSemanticsRule__Group_3_1_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8143:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) ) |
| // InternalFSM.g:8144:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) |
| { |
| // InternalFSM.g:8144:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) ) |
| // InternalFSM.g:8145:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); |
| // InternalFSM.g:8146:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 ) |
| // InternalFSM.g:8146:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__2" |
| // InternalFSM.g:8156:1: rule__OutSemanticsRule__Group_3_1_1__2 : rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 ; |
| public final void rule__OutSemanticsRule__Group_3_1_1__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8160:1: ( rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 ) |
| // InternalFSM.g:8161:2: rule__OutSemanticsRule__Group_3_1_1__2__Impl rule__OutSemanticsRule__Group_3_1_1__3 |
| { |
| pushFollow(FOLLOW_36); |
| rule__OutSemanticsRule__Group_3_1_1__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group_3_1_1__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1__2" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__2__Impl" |
| // InternalFSM.g:8168:1: rule__OutSemanticsRule__Group_3_1_1__2__Impl : ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) ; |
| public final void rule__OutSemanticsRule__Group_3_1_1__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8172:1: ( ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) ) |
| // InternalFSM.g:8173:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) |
| { |
| // InternalFSM.g:8173:1: ( ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) ) |
| // InternalFSM.g:8174:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) |
| { |
| // InternalFSM.g:8174:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) ) |
| // InternalFSM.g:8175:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); |
| // InternalFSM.g:8176:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 ) |
| // InternalFSM.g:8176:2: rule__OutSemanticsRule__Group_3_1_1_2__0 |
| { |
| pushFollow(FOLLOW_37); |
| rule__OutSemanticsRule__Group_3_1_1_2__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); |
| |
| } |
| |
| // InternalFSM.g:8179:1: ( ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* ) |
| // InternalFSM.g:8180:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); |
| // InternalFSM.g:8181:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0 )* |
| loop70: |
| do { |
| int alt70=2; |
| int LA70_0 = input.LA(1); |
| |
| if ( (LA70_0==60) ) { |
| alt70=1; |
| } |
| |
| |
| switch (alt70) { |
| case 1 : |
| // InternalFSM.g:8181:2: rule__OutSemanticsRule__Group_3_1_1_2__0 |
| { |
| pushFollow(FOLLOW_37); |
| rule__OutSemanticsRule__Group_3_1_1_2__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop70; |
| } |
| } while (true); |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1__2__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__3" |
| // InternalFSM.g:8192:1: rule__OutSemanticsRule__Group_3_1_1__3 : rule__OutSemanticsRule__Group_3_1_1__3__Impl ; |
| public final void rule__OutSemanticsRule__Group_3_1_1__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8196:1: ( rule__OutSemanticsRule__Group_3_1_1__3__Impl ) |
| // InternalFSM.g:8197:2: rule__OutSemanticsRule__Group_3_1_1__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group_3_1_1__3__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1__3" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1__3__Impl" |
| // InternalFSM.g:8203:1: rule__OutSemanticsRule__Group_3_1_1__3__Impl : ( ')' ) ; |
| public final void rule__OutSemanticsRule__Group_3_1_1__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8207:1: ( ( ')' ) ) |
| // InternalFSM.g:8208:1: ( ')' ) |
| { |
| // InternalFSM.g:8208:1: ( ')' ) |
| // InternalFSM.g:8209:1: ')' |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); |
| match(input,59,FOLLOW_2); |
| after(grammarAccess.getOutSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1__3__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__0" |
| // InternalFSM.g:8230:1: rule__OutSemanticsRule__Group_3_1_1_2__0 : rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 ; |
| public final void rule__OutSemanticsRule__Group_3_1_1_2__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8234:1: ( rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 ) |
| // InternalFSM.g:8235:2: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl rule__OutSemanticsRule__Group_3_1_1_2__1 |
| { |
| pushFollow(FOLLOW_34); |
| rule__OutSemanticsRule__Group_3_1_1_2__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group_3_1_1_2__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1_2__0" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__0__Impl" |
| // InternalFSM.g:8242:1: rule__OutSemanticsRule__Group_3_1_1_2__0__Impl : ( ',' ) ; |
| public final void rule__OutSemanticsRule__Group_3_1_1_2__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8246:1: ( ( ',' ) ) |
| // InternalFSM.g:8247:1: ( ',' ) |
| { |
| // InternalFSM.g:8247:1: ( ',' ) |
| // InternalFSM.g:8248:1: ',' |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); |
| match(input,60,FOLLOW_2); |
| after(grammarAccess.getOutSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1_2__0__Impl" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__1" |
| // InternalFSM.g:8261:1: rule__OutSemanticsRule__Group_3_1_1_2__1 : rule__OutSemanticsRule__Group_3_1_1_2__1__Impl ; |
| public final void rule__OutSemanticsRule__Group_3_1_1_2__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8265:1: ( rule__OutSemanticsRule__Group_3_1_1_2__1__Impl ) |
| // InternalFSM.g:8266:2: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__Group_3_1_1_2__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1_2__1" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__Group_3_1_1_2__1__Impl" |
| // InternalFSM.g:8272:1: rule__OutSemanticsRule__Group_3_1_1_2__1__Impl : ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ; |
| public final void rule__OutSemanticsRule__Group_3_1_1_2__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8276:1: ( ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) ) |
| // InternalFSM.g:8277:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) |
| { |
| // InternalFSM.g:8277:1: ( ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) ) |
| // InternalFSM.g:8278:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); |
| // InternalFSM.g:8279:1: ( rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 ) |
| // InternalFSM.g:8279:2: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__Group_3_1_1_2__1__Impl" |
| |
| |
| // $ANTLR start "rule__KeyValue__Group__0" |
| // InternalFSM.g:8296:1: rule__KeyValue__Group__0 : rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 ; |
| public final void rule__KeyValue__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8300:1: ( rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 ) |
| // InternalFSM.g:8301:2: rule__KeyValue__Group__0__Impl rule__KeyValue__Group__1 |
| { |
| pushFollow(FOLLOW_38); |
| rule__KeyValue__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__KeyValue__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__KeyValue__Group__0" |
| |
| |
| // $ANTLR start "rule__KeyValue__Group__0__Impl" |
| // InternalFSM.g:8308:1: rule__KeyValue__Group__0__Impl : ( ( rule__KeyValue__KeyAssignment_0 ) ) ; |
| public final void rule__KeyValue__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8312:1: ( ( ( rule__KeyValue__KeyAssignment_0 ) ) ) |
| // InternalFSM.g:8313:1: ( ( rule__KeyValue__KeyAssignment_0 ) ) |
| { |
| // InternalFSM.g:8313:1: ( ( rule__KeyValue__KeyAssignment_0 ) ) |
| // InternalFSM.g:8314:1: ( rule__KeyValue__KeyAssignment_0 ) |
| { |
| before(grammarAccess.getKeyValueAccess().getKeyAssignment_0()); |
| // InternalFSM.g:8315:1: ( rule__KeyValue__KeyAssignment_0 ) |
| // InternalFSM.g:8315:2: rule__KeyValue__KeyAssignment_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__KeyValue__KeyAssignment_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getKeyValueAccess().getKeyAssignment_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__KeyValue__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__KeyValue__Group__1" |
| // InternalFSM.g:8325:1: rule__KeyValue__Group__1 : rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 ; |
| public final void rule__KeyValue__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8329:1: ( rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 ) |
| // InternalFSM.g:8330:2: rule__KeyValue__Group__1__Impl rule__KeyValue__Group__2 |
| { |
| pushFollow(FOLLOW_39); |
| rule__KeyValue__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__KeyValue__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__KeyValue__Group__1" |
| |
| |
| // $ANTLR start "rule__KeyValue__Group__1__Impl" |
| // InternalFSM.g:8337:1: rule__KeyValue__Group__1__Impl : ( '=' ) ; |
| public final void rule__KeyValue__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8341:1: ( ( '=' ) ) |
| // InternalFSM.g:8342:1: ( '=' ) |
| { |
| // InternalFSM.g:8342:1: ( '=' ) |
| // InternalFSM.g:8343:1: '=' |
| { |
| before(grammarAccess.getKeyValueAccess().getEqualsSignKeyword_1()); |
| match(input,62,FOLLOW_2); |
| after(grammarAccess.getKeyValueAccess().getEqualsSignKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__KeyValue__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__KeyValue__Group__2" |
| // InternalFSM.g:8356:1: rule__KeyValue__Group__2 : rule__KeyValue__Group__2__Impl ; |
| public final void rule__KeyValue__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8360:1: ( rule__KeyValue__Group__2__Impl ) |
| // InternalFSM.g:8361:2: rule__KeyValue__Group__2__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__KeyValue__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__KeyValue__Group__2" |
| |
| |
| // $ANTLR start "rule__KeyValue__Group__2__Impl" |
| // InternalFSM.g:8367:1: rule__KeyValue__Group__2__Impl : ( ( rule__KeyValue__ValueAssignment_2 ) ) ; |
| public final void rule__KeyValue__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8371:1: ( ( ( rule__KeyValue__ValueAssignment_2 ) ) ) |
| // InternalFSM.g:8372:1: ( ( rule__KeyValue__ValueAssignment_2 ) ) |
| { |
| // InternalFSM.g:8372:1: ( ( rule__KeyValue__ValueAssignment_2 ) ) |
| // InternalFSM.g:8373:1: ( rule__KeyValue__ValueAssignment_2 ) |
| { |
| before(grammarAccess.getKeyValueAccess().getValueAssignment_2()); |
| // InternalFSM.g:8374:1: ( rule__KeyValue__ValueAssignment_2 ) |
| // InternalFSM.g:8374:2: rule__KeyValue__ValueAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__KeyValue__ValueAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getKeyValueAccess().getValueAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__KeyValue__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Group__0" |
| // InternalFSM.g:8393:1: rule__SimpleAnnotationAttribute__Group__0 : rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 ; |
| public final void rule__SimpleAnnotationAttribute__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8397:1: ( rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 ) |
| // InternalFSM.g:8398:2: rule__SimpleAnnotationAttribute__Group__0__Impl rule__SimpleAnnotationAttribute__Group__1 |
| { |
| pushFollow(FOLLOW_40); |
| rule__SimpleAnnotationAttribute__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleAnnotationAttribute__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Group__0" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Group__0__Impl" |
| // InternalFSM.g:8405:1: rule__SimpleAnnotationAttribute__Group__0__Impl : ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) ; |
| public final void rule__SimpleAnnotationAttribute__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8409:1: ( ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) ) |
| // InternalFSM.g:8410:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) |
| { |
| // InternalFSM.g:8410:1: ( ( rule__SimpleAnnotationAttribute__Alternatives_0 ) ) |
| // InternalFSM.g:8411:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 ) |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getAlternatives_0()); |
| // InternalFSM.g:8412:1: ( rule__SimpleAnnotationAttribute__Alternatives_0 ) |
| // InternalFSM.g:8412:2: rule__SimpleAnnotationAttribute__Alternatives_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleAnnotationAttribute__Alternatives_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getAlternatives_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Group__1" |
| // InternalFSM.g:8422:1: rule__SimpleAnnotationAttribute__Group__1 : rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 ; |
| public final void rule__SimpleAnnotationAttribute__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8426:1: ( rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 ) |
| // InternalFSM.g:8427:2: rule__SimpleAnnotationAttribute__Group__1__Impl rule__SimpleAnnotationAttribute__Group__2 |
| { |
| pushFollow(FOLLOW_5); |
| rule__SimpleAnnotationAttribute__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleAnnotationAttribute__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Group__1" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Group__1__Impl" |
| // InternalFSM.g:8434:1: rule__SimpleAnnotationAttribute__Group__1__Impl : ( 'attribute' ) ; |
| public final void rule__SimpleAnnotationAttribute__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8438:1: ( ( 'attribute' ) ) |
| // InternalFSM.g:8439:1: ( 'attribute' ) |
| { |
| // InternalFSM.g:8439:1: ( 'attribute' ) |
| // InternalFSM.g:8440:1: 'attribute' |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getAttributeKeyword_1()); |
| match(input,63,FOLLOW_2); |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getAttributeKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Group__2" |
| // InternalFSM.g:8453:1: rule__SimpleAnnotationAttribute__Group__2 : rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 ; |
| public final void rule__SimpleAnnotationAttribute__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8457:1: ( rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 ) |
| // InternalFSM.g:8458:2: rule__SimpleAnnotationAttribute__Group__2__Impl rule__SimpleAnnotationAttribute__Group__3 |
| { |
| pushFollow(FOLLOW_32); |
| rule__SimpleAnnotationAttribute__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleAnnotationAttribute__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Group__2" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Group__2__Impl" |
| // InternalFSM.g:8465:1: rule__SimpleAnnotationAttribute__Group__2__Impl : ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) ; |
| public final void rule__SimpleAnnotationAttribute__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8469:1: ( ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) ) |
| // InternalFSM.g:8470:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) |
| { |
| // InternalFSM.g:8470:1: ( ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) ) |
| // InternalFSM.g:8471:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getNameAssignment_2()); |
| // InternalFSM.g:8472:1: ( rule__SimpleAnnotationAttribute__NameAssignment_2 ) |
| // InternalFSM.g:8472:2: rule__SimpleAnnotationAttribute__NameAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleAnnotationAttribute__NameAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getNameAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Group__3" |
| // InternalFSM.g:8482:1: rule__SimpleAnnotationAttribute__Group__3 : rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 ; |
| public final void rule__SimpleAnnotationAttribute__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8486:1: ( rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 ) |
| // InternalFSM.g:8487:2: rule__SimpleAnnotationAttribute__Group__3__Impl rule__SimpleAnnotationAttribute__Group__4 |
| { |
| pushFollow(FOLLOW_41); |
| rule__SimpleAnnotationAttribute__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__SimpleAnnotationAttribute__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Group__3" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Group__3__Impl" |
| // InternalFSM.g:8494:1: rule__SimpleAnnotationAttribute__Group__3__Impl : ( ':' ) ; |
| public final void rule__SimpleAnnotationAttribute__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8498:1: ( ( ':' ) ) |
| // InternalFSM.g:8499:1: ( ':' ) |
| { |
| // InternalFSM.g:8499:1: ( ':' ) |
| // InternalFSM.g:8500:1: ':' |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getColonKeyword_3()); |
| match(input,42,FOLLOW_2); |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getColonKeyword_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Group__4" |
| // InternalFSM.g:8513:1: rule__SimpleAnnotationAttribute__Group__4 : rule__SimpleAnnotationAttribute__Group__4__Impl ; |
| public final void rule__SimpleAnnotationAttribute__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8517:1: ( rule__SimpleAnnotationAttribute__Group__4__Impl ) |
| // InternalFSM.g:8518:2: rule__SimpleAnnotationAttribute__Group__4__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleAnnotationAttribute__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Group__4" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__Group__4__Impl" |
| // InternalFSM.g:8524:1: rule__SimpleAnnotationAttribute__Group__4__Impl : ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) ; |
| public final void rule__SimpleAnnotationAttribute__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8528:1: ( ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) ) |
| // InternalFSM.g:8529:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) |
| { |
| // InternalFSM.g:8529:1: ( ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) ) |
| // InternalFSM.g:8530:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeAssignment_4()); |
| // InternalFSM.g:8531:1: ( rule__SimpleAnnotationAttribute__TypeAssignment_4 ) |
| // InternalFSM.g:8531:2: rule__SimpleAnnotationAttribute__TypeAssignment_4 |
| { |
| pushFollow(FOLLOW_2); |
| rule__SimpleAnnotationAttribute__TypeAssignment_4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeAssignment_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__0" |
| // InternalFSM.g:8551:1: rule__EnumAnnotationAttribute__Group__0 : rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 ; |
| public final void rule__EnumAnnotationAttribute__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8555:1: ( rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 ) |
| // InternalFSM.g:8556:2: rule__EnumAnnotationAttribute__Group__0__Impl rule__EnumAnnotationAttribute__Group__1 |
| { |
| pushFollow(FOLLOW_40); |
| rule__EnumAnnotationAttribute__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__0" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__0__Impl" |
| // InternalFSM.g:8563:1: rule__EnumAnnotationAttribute__Group__0__Impl : ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) ; |
| public final void rule__EnumAnnotationAttribute__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8567:1: ( ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) ) |
| // InternalFSM.g:8568:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) |
| { |
| // InternalFSM.g:8568:1: ( ( rule__EnumAnnotationAttribute__Alternatives_0 ) ) |
| // InternalFSM.g:8569:1: ( rule__EnumAnnotationAttribute__Alternatives_0 ) |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getAlternatives_0()); |
| // InternalFSM.g:8570:1: ( rule__EnumAnnotationAttribute__Alternatives_0 ) |
| // InternalFSM.g:8570:2: rule__EnumAnnotationAttribute__Alternatives_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Alternatives_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getAlternatives_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__1" |
| // InternalFSM.g:8580:1: rule__EnumAnnotationAttribute__Group__1 : rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 ; |
| public final void rule__EnumAnnotationAttribute__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8584:1: ( rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 ) |
| // InternalFSM.g:8585:2: rule__EnumAnnotationAttribute__Group__1__Impl rule__EnumAnnotationAttribute__Group__2 |
| { |
| pushFollow(FOLLOW_5); |
| rule__EnumAnnotationAttribute__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__1" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__1__Impl" |
| // InternalFSM.g:8592:1: rule__EnumAnnotationAttribute__Group__1__Impl : ( 'attribute' ) ; |
| public final void rule__EnumAnnotationAttribute__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8596:1: ( ( 'attribute' ) ) |
| // InternalFSM.g:8597:1: ( 'attribute' ) |
| { |
| // InternalFSM.g:8597:1: ( 'attribute' ) |
| // InternalFSM.g:8598:1: 'attribute' |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getAttributeKeyword_1()); |
| match(input,63,FOLLOW_2); |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getAttributeKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__2" |
| // InternalFSM.g:8611:1: rule__EnumAnnotationAttribute__Group__2 : rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 ; |
| public final void rule__EnumAnnotationAttribute__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8615:1: ( rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 ) |
| // InternalFSM.g:8616:2: rule__EnumAnnotationAttribute__Group__2__Impl rule__EnumAnnotationAttribute__Group__3 |
| { |
| pushFollow(FOLLOW_32); |
| rule__EnumAnnotationAttribute__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__2" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__2__Impl" |
| // InternalFSM.g:8623:1: rule__EnumAnnotationAttribute__Group__2__Impl : ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) ; |
| public final void rule__EnumAnnotationAttribute__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8627:1: ( ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) ) |
| // InternalFSM.g:8628:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) |
| { |
| // InternalFSM.g:8628:1: ( ( rule__EnumAnnotationAttribute__NameAssignment_2 ) ) |
| // InternalFSM.g:8629:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 ) |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getNameAssignment_2()); |
| // InternalFSM.g:8630:1: ( rule__EnumAnnotationAttribute__NameAssignment_2 ) |
| // InternalFSM.g:8630:2: rule__EnumAnnotationAttribute__NameAssignment_2 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__NameAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getNameAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__3" |
| // InternalFSM.g:8640:1: rule__EnumAnnotationAttribute__Group__3 : rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 ; |
| public final void rule__EnumAnnotationAttribute__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8644:1: ( rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 ) |
| // InternalFSM.g:8645:2: rule__EnumAnnotationAttribute__Group__3__Impl rule__EnumAnnotationAttribute__Group__4 |
| { |
| pushFollow(FOLLOW_7); |
| rule__EnumAnnotationAttribute__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__3" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__3__Impl" |
| // InternalFSM.g:8652:1: rule__EnumAnnotationAttribute__Group__3__Impl : ( ':' ) ; |
| public final void rule__EnumAnnotationAttribute__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8656:1: ( ( ':' ) ) |
| // InternalFSM.g:8657:1: ( ':' ) |
| { |
| // InternalFSM.g:8657:1: ( ':' ) |
| // InternalFSM.g:8658:1: ':' |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getColonKeyword_3()); |
| match(input,42,FOLLOW_2); |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getColonKeyword_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__4" |
| // InternalFSM.g:8671:1: rule__EnumAnnotationAttribute__Group__4 : rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 ; |
| public final void rule__EnumAnnotationAttribute__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8675:1: ( rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 ) |
| // InternalFSM.g:8676:2: rule__EnumAnnotationAttribute__Group__4__Impl rule__EnumAnnotationAttribute__Group__5 |
| { |
| pushFollow(FOLLOW_42); |
| rule__EnumAnnotationAttribute__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group__5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__4" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__4__Impl" |
| // InternalFSM.g:8683:1: rule__EnumAnnotationAttribute__Group__4__Impl : ( '{' ) ; |
| public final void rule__EnumAnnotationAttribute__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8687:1: ( ( '{' ) ) |
| // InternalFSM.g:8688:1: ( '{' ) |
| { |
| // InternalFSM.g:8688:1: ( '{' ) |
| // InternalFSM.g:8689:1: '{' |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getLeftCurlyBracketKeyword_4()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getLeftCurlyBracketKeyword_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__5" |
| // InternalFSM.g:8702:1: rule__EnumAnnotationAttribute__Group__5 : rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 ; |
| public final void rule__EnumAnnotationAttribute__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8706:1: ( rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 ) |
| // InternalFSM.g:8707:2: rule__EnumAnnotationAttribute__Group__5__Impl rule__EnumAnnotationAttribute__Group__6 |
| { |
| pushFollow(FOLLOW_43); |
| rule__EnumAnnotationAttribute__Group__5__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group__6(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__5" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__5__Impl" |
| // InternalFSM.g:8714:1: rule__EnumAnnotationAttribute__Group__5__Impl : ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) ; |
| public final void rule__EnumAnnotationAttribute__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8718:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) ) |
| // InternalFSM.g:8719:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) |
| { |
| // InternalFSM.g:8719:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) ) |
| // InternalFSM.g:8720:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_5()); |
| // InternalFSM.g:8721:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_5 ) |
| // InternalFSM.g:8721:2: rule__EnumAnnotationAttribute__ValuesAssignment_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__ValuesAssignment_5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_5()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__6" |
| // InternalFSM.g:8731:1: rule__EnumAnnotationAttribute__Group__6 : rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 ; |
| public final void rule__EnumAnnotationAttribute__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8735:1: ( rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 ) |
| // InternalFSM.g:8736:2: rule__EnumAnnotationAttribute__Group__6__Impl rule__EnumAnnotationAttribute__Group__7 |
| { |
| pushFollow(FOLLOW_43); |
| rule__EnumAnnotationAttribute__Group__6__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group__7(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__6" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__6__Impl" |
| // InternalFSM.g:8743:1: rule__EnumAnnotationAttribute__Group__6__Impl : ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) ; |
| public final void rule__EnumAnnotationAttribute__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8747:1: ( ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) ) |
| // InternalFSM.g:8748:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) |
| { |
| // InternalFSM.g:8748:1: ( ( rule__EnumAnnotationAttribute__Group_6__0 )* ) |
| // InternalFSM.g:8749:1: ( rule__EnumAnnotationAttribute__Group_6__0 )* |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getGroup_6()); |
| // InternalFSM.g:8750:1: ( rule__EnumAnnotationAttribute__Group_6__0 )* |
| loop71: |
| do { |
| int alt71=2; |
| int LA71_0 = input.LA(1); |
| |
| if ( (LA71_0==60) ) { |
| alt71=1; |
| } |
| |
| |
| switch (alt71) { |
| case 1 : |
| // InternalFSM.g:8750:2: rule__EnumAnnotationAttribute__Group_6__0 |
| { |
| pushFollow(FOLLOW_37); |
| rule__EnumAnnotationAttribute__Group_6__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop71; |
| } |
| } while (true); |
| |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getGroup_6()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__7" |
| // InternalFSM.g:8760:1: rule__EnumAnnotationAttribute__Group__7 : rule__EnumAnnotationAttribute__Group__7__Impl ; |
| public final void rule__EnumAnnotationAttribute__Group__7() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8764:1: ( rule__EnumAnnotationAttribute__Group__7__Impl ) |
| // InternalFSM.g:8765:2: rule__EnumAnnotationAttribute__Group__7__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group__7__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__7" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group__7__Impl" |
| // InternalFSM.g:8771:1: rule__EnumAnnotationAttribute__Group__7__Impl : ( '}' ) ; |
| public final void rule__EnumAnnotationAttribute__Group__7__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8775:1: ( ( '}' ) ) |
| // InternalFSM.g:8776:1: ( '}' ) |
| { |
| // InternalFSM.g:8776:1: ( '}' ) |
| // InternalFSM.g:8777:1: '}' |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getRightCurlyBracketKeyword_7()); |
| match(input,29,FOLLOW_2); |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getRightCurlyBracketKeyword_7()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group__7__Impl" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__0" |
| // InternalFSM.g:8806:1: rule__EnumAnnotationAttribute__Group_6__0 : rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 ; |
| public final void rule__EnumAnnotationAttribute__Group_6__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8810:1: ( rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 ) |
| // InternalFSM.g:8811:2: rule__EnumAnnotationAttribute__Group_6__0__Impl rule__EnumAnnotationAttribute__Group_6__1 |
| { |
| pushFollow(FOLLOW_42); |
| rule__EnumAnnotationAttribute__Group_6__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group_6__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group_6__0" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__0__Impl" |
| // InternalFSM.g:8818:1: rule__EnumAnnotationAttribute__Group_6__0__Impl : ( ',' ) ; |
| public final void rule__EnumAnnotationAttribute__Group_6__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8822:1: ( ( ',' ) ) |
| // InternalFSM.g:8823:1: ( ',' ) |
| { |
| // InternalFSM.g:8823:1: ( ',' ) |
| // InternalFSM.g:8824:1: ',' |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getCommaKeyword_6_0()); |
| match(input,60,FOLLOW_2); |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getCommaKeyword_6_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group_6__0__Impl" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__1" |
| // InternalFSM.g:8837:1: rule__EnumAnnotationAttribute__Group_6__1 : rule__EnumAnnotationAttribute__Group_6__1__Impl ; |
| public final void rule__EnumAnnotationAttribute__Group_6__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8841:1: ( rule__EnumAnnotationAttribute__Group_6__1__Impl ) |
| // InternalFSM.g:8842:2: rule__EnumAnnotationAttribute__Group_6__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__Group_6__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group_6__1" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__Group_6__1__Impl" |
| // InternalFSM.g:8848:1: rule__EnumAnnotationAttribute__Group_6__1__Impl : ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) ; |
| public final void rule__EnumAnnotationAttribute__Group_6__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8852:1: ( ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) ) |
| // InternalFSM.g:8853:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) |
| { |
| // InternalFSM.g:8853:1: ( ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) ) |
| // InternalFSM.g:8854:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_6_1()); |
| // InternalFSM.g:8855:1: ( rule__EnumAnnotationAttribute__ValuesAssignment_6_1 ) |
| // InternalFSM.g:8855:2: rule__EnumAnnotationAttribute__ValuesAssignment_6_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__EnumAnnotationAttribute__ValuesAssignment_6_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_6_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__Group_6__1__Impl" |
| |
| |
| // $ANTLR start "rule__ImportedFQN__Group__0" |
| // InternalFSM.g:8871:1: rule__ImportedFQN__Group__0 : rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 ; |
| public final void rule__ImportedFQN__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8875:1: ( rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 ) |
| // InternalFSM.g:8876:2: rule__ImportedFQN__Group__0__Impl rule__ImportedFQN__Group__1 |
| { |
| pushFollow(FOLLOW_44); |
| rule__ImportedFQN__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__ImportedFQN__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ImportedFQN__Group__0" |
| |
| |
| // $ANTLR start "rule__ImportedFQN__Group__0__Impl" |
| // InternalFSM.g:8883:1: rule__ImportedFQN__Group__0__Impl : ( ruleFQN ) ; |
| public final void rule__ImportedFQN__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8887:1: ( ( ruleFQN ) ) |
| // InternalFSM.g:8888:1: ( ruleFQN ) |
| { |
| // InternalFSM.g:8888:1: ( ruleFQN ) |
| // InternalFSM.g:8889:1: ruleFQN |
| { |
| before(grammarAccess.getImportedFQNAccess().getFQNParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleFQN(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getImportedFQNAccess().getFQNParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ImportedFQN__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__ImportedFQN__Group__1" |
| // InternalFSM.g:8900:1: rule__ImportedFQN__Group__1 : rule__ImportedFQN__Group__1__Impl ; |
| public final void rule__ImportedFQN__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8904:1: ( rule__ImportedFQN__Group__1__Impl ) |
| // InternalFSM.g:8905:2: rule__ImportedFQN__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ImportedFQN__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ImportedFQN__Group__1" |
| |
| |
| // $ANTLR start "rule__ImportedFQN__Group__1__Impl" |
| // InternalFSM.g:8911:1: rule__ImportedFQN__Group__1__Impl : ( ( '.*' )? ) ; |
| public final void rule__ImportedFQN__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8915:1: ( ( ( '.*' )? ) ) |
| // InternalFSM.g:8916:1: ( ( '.*' )? ) |
| { |
| // InternalFSM.g:8916:1: ( ( '.*' )? ) |
| // InternalFSM.g:8917:1: ( '.*' )? |
| { |
| before(grammarAccess.getImportedFQNAccess().getFullStopAsteriskKeyword_1()); |
| // InternalFSM.g:8918:1: ( '.*' )? |
| int alt72=2; |
| int LA72_0 = input.LA(1); |
| |
| if ( (LA72_0==64) ) { |
| alt72=1; |
| } |
| switch (alt72) { |
| case 1 : |
| // InternalFSM.g:8919:2: '.*' |
| { |
| match(input,64,FOLLOW_2); |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getImportedFQNAccess().getFullStopAsteriskKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ImportedFQN__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Documentation__Group__0" |
| // InternalFSM.g:8934:1: rule__Documentation__Group__0 : rule__Documentation__Group__0__Impl rule__Documentation__Group__1 ; |
| public final void rule__Documentation__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8938:1: ( rule__Documentation__Group__0__Impl rule__Documentation__Group__1 ) |
| // InternalFSM.g:8939:2: rule__Documentation__Group__0__Impl rule__Documentation__Group__1 |
| { |
| pushFollow(FOLLOW_15); |
| rule__Documentation__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Documentation__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Documentation__Group__0" |
| |
| |
| // $ANTLR start "rule__Documentation__Group__0__Impl" |
| // InternalFSM.g:8946:1: rule__Documentation__Group__0__Impl : ( () ) ; |
| public final void rule__Documentation__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8950:1: ( ( () ) ) |
| // InternalFSM.g:8951:1: ( () ) |
| { |
| // InternalFSM.g:8951:1: ( () ) |
| // InternalFSM.g:8952:1: () |
| { |
| before(grammarAccess.getDocumentationAccess().getDocumentationAction_0()); |
| // InternalFSM.g:8953:1: () |
| // InternalFSM.g:8955:1: |
| { |
| } |
| |
| after(grammarAccess.getDocumentationAccess().getDocumentationAction_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Documentation__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Documentation__Group__1" |
| // InternalFSM.g:8965:1: rule__Documentation__Group__1 : rule__Documentation__Group__1__Impl rule__Documentation__Group__2 ; |
| public final void rule__Documentation__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8969:1: ( rule__Documentation__Group__1__Impl rule__Documentation__Group__2 ) |
| // InternalFSM.g:8970:2: rule__Documentation__Group__1__Impl rule__Documentation__Group__2 |
| { |
| pushFollow(FOLLOW_45); |
| rule__Documentation__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Documentation__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Documentation__Group__1" |
| |
| |
| // $ANTLR start "rule__Documentation__Group__1__Impl" |
| // InternalFSM.g:8977:1: rule__Documentation__Group__1__Impl : ( '[' ) ; |
| public final void rule__Documentation__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:8981:1: ( ( '[' ) ) |
| // InternalFSM.g:8982:1: ( '[' ) |
| { |
| // InternalFSM.g:8982:1: ( '[' ) |
| // InternalFSM.g:8983:1: '[' |
| { |
| before(grammarAccess.getDocumentationAccess().getLeftSquareBracketKeyword_1()); |
| match(input,65,FOLLOW_2); |
| after(grammarAccess.getDocumentationAccess().getLeftSquareBracketKeyword_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Documentation__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Documentation__Group__2" |
| // InternalFSM.g:8996:1: rule__Documentation__Group__2 : rule__Documentation__Group__2__Impl rule__Documentation__Group__3 ; |
| public final void rule__Documentation__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9000:1: ( rule__Documentation__Group__2__Impl rule__Documentation__Group__3 ) |
| // InternalFSM.g:9001:2: rule__Documentation__Group__2__Impl rule__Documentation__Group__3 |
| { |
| pushFollow(FOLLOW_45); |
| rule__Documentation__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Documentation__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Documentation__Group__2" |
| |
| |
| // $ANTLR start "rule__Documentation__Group__2__Impl" |
| // InternalFSM.g:9008:1: rule__Documentation__Group__2__Impl : ( ( rule__Documentation__LinesAssignment_2 )* ) ; |
| public final void rule__Documentation__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9012:1: ( ( ( rule__Documentation__LinesAssignment_2 )* ) ) |
| // InternalFSM.g:9013:1: ( ( rule__Documentation__LinesAssignment_2 )* ) |
| { |
| // InternalFSM.g:9013:1: ( ( rule__Documentation__LinesAssignment_2 )* ) |
| // InternalFSM.g:9014:1: ( rule__Documentation__LinesAssignment_2 )* |
| { |
| before(grammarAccess.getDocumentationAccess().getLinesAssignment_2()); |
| // InternalFSM.g:9015:1: ( rule__Documentation__LinesAssignment_2 )* |
| loop73: |
| do { |
| int alt73=2; |
| int LA73_0 = input.LA(1); |
| |
| if ( (LA73_0==RULE_STRING) ) { |
| alt73=1; |
| } |
| |
| |
| switch (alt73) { |
| case 1 : |
| // InternalFSM.g:9015:2: rule__Documentation__LinesAssignment_2 |
| { |
| pushFollow(FOLLOW_13); |
| rule__Documentation__LinesAssignment_2(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop73; |
| } |
| } while (true); |
| |
| after(grammarAccess.getDocumentationAccess().getLinesAssignment_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Documentation__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Documentation__Group__3" |
| // InternalFSM.g:9025:1: rule__Documentation__Group__3 : rule__Documentation__Group__3__Impl ; |
| public final void rule__Documentation__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9029:1: ( rule__Documentation__Group__3__Impl ) |
| // InternalFSM.g:9030:2: rule__Documentation__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__Documentation__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Documentation__Group__3" |
| |
| |
| // $ANTLR start "rule__Documentation__Group__3__Impl" |
| // InternalFSM.g:9036:1: rule__Documentation__Group__3__Impl : ( ']' ) ; |
| public final void rule__Documentation__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9040:1: ( ( ']' ) ) |
| // InternalFSM.g:9041:1: ( ']' ) |
| { |
| // InternalFSM.g:9041:1: ( ']' ) |
| // InternalFSM.g:9042:1: ']' |
| { |
| before(grammarAccess.getDocumentationAccess().getRightSquareBracketKeyword_3()); |
| match(input,66,FOLLOW_2); |
| after(grammarAccess.getDocumentationAccess().getRightSquareBracketKeyword_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Documentation__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__BooleanLiteral__Group__0" |
| // InternalFSM.g:9069:1: rule__BooleanLiteral__Group__0 : rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ; |
| public final void rule__BooleanLiteral__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9073:1: ( rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 ) |
| // InternalFSM.g:9074:2: rule__BooleanLiteral__Group__0__Impl rule__BooleanLiteral__Group__1 |
| { |
| pushFollow(FOLLOW_46); |
| rule__BooleanLiteral__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__BooleanLiteral__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__BooleanLiteral__Group__0" |
| |
| |
| // $ANTLR start "rule__BooleanLiteral__Group__0__Impl" |
| // InternalFSM.g:9081:1: rule__BooleanLiteral__Group__0__Impl : ( () ) ; |
| public final void rule__BooleanLiteral__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9085:1: ( ( () ) ) |
| // InternalFSM.g:9086:1: ( () ) |
| { |
| // InternalFSM.g:9086:1: ( () ) |
| // InternalFSM.g:9087:1: () |
| { |
| before(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); |
| // InternalFSM.g:9088:1: () |
| // InternalFSM.g:9090:1: |
| { |
| } |
| |
| after(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__BooleanLiteral__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__BooleanLiteral__Group__1" |
| // InternalFSM.g:9100:1: rule__BooleanLiteral__Group__1 : rule__BooleanLiteral__Group__1__Impl ; |
| public final void rule__BooleanLiteral__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9104:1: ( rule__BooleanLiteral__Group__1__Impl ) |
| // InternalFSM.g:9105:2: rule__BooleanLiteral__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__BooleanLiteral__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__BooleanLiteral__Group__1" |
| |
| |
| // $ANTLR start "rule__BooleanLiteral__Group__1__Impl" |
| // InternalFSM.g:9111:1: rule__BooleanLiteral__Group__1__Impl : ( ( rule__BooleanLiteral__Alternatives_1 ) ) ; |
| public final void rule__BooleanLiteral__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9115:1: ( ( ( rule__BooleanLiteral__Alternatives_1 ) ) ) |
| // InternalFSM.g:9116:1: ( ( rule__BooleanLiteral__Alternatives_1 ) ) |
| { |
| // InternalFSM.g:9116:1: ( ( rule__BooleanLiteral__Alternatives_1 ) ) |
| // InternalFSM.g:9117:1: ( rule__BooleanLiteral__Alternatives_1 ) |
| { |
| before(grammarAccess.getBooleanLiteralAccess().getAlternatives_1()); |
| // InternalFSM.g:9118:1: ( rule__BooleanLiteral__Alternatives_1 ) |
| // InternalFSM.g:9118:2: rule__BooleanLiteral__Alternatives_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__BooleanLiteral__Alternatives_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getBooleanLiteralAccess().getAlternatives_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__BooleanLiteral__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__RealLiteral__Group__0" |
| // InternalFSM.g:9132:1: rule__RealLiteral__Group__0 : rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 ; |
| public final void rule__RealLiteral__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9136:1: ( rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 ) |
| // InternalFSM.g:9137:2: rule__RealLiteral__Group__0__Impl rule__RealLiteral__Group__1 |
| { |
| pushFollow(FOLLOW_47); |
| rule__RealLiteral__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__RealLiteral__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RealLiteral__Group__0" |
| |
| |
| // $ANTLR start "rule__RealLiteral__Group__0__Impl" |
| // InternalFSM.g:9144:1: rule__RealLiteral__Group__0__Impl : ( () ) ; |
| public final void rule__RealLiteral__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9148:1: ( ( () ) ) |
| // InternalFSM.g:9149:1: ( () ) |
| { |
| // InternalFSM.g:9149:1: ( () ) |
| // InternalFSM.g:9150:1: () |
| { |
| before(grammarAccess.getRealLiteralAccess().getRealLiteralAction_0()); |
| // InternalFSM.g:9151:1: () |
| // InternalFSM.g:9153:1: |
| { |
| } |
| |
| after(grammarAccess.getRealLiteralAccess().getRealLiteralAction_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RealLiteral__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__RealLiteral__Group__1" |
| // InternalFSM.g:9163:1: rule__RealLiteral__Group__1 : rule__RealLiteral__Group__1__Impl ; |
| public final void rule__RealLiteral__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9167:1: ( rule__RealLiteral__Group__1__Impl ) |
| // InternalFSM.g:9168:2: rule__RealLiteral__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__RealLiteral__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RealLiteral__Group__1" |
| |
| |
| // $ANTLR start "rule__RealLiteral__Group__1__Impl" |
| // InternalFSM.g:9174:1: rule__RealLiteral__Group__1__Impl : ( ( rule__RealLiteral__ValueAssignment_1 ) ) ; |
| public final void rule__RealLiteral__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9178:1: ( ( ( rule__RealLiteral__ValueAssignment_1 ) ) ) |
| // InternalFSM.g:9179:1: ( ( rule__RealLiteral__ValueAssignment_1 ) ) |
| { |
| // InternalFSM.g:9179:1: ( ( rule__RealLiteral__ValueAssignment_1 ) ) |
| // InternalFSM.g:9180:1: ( rule__RealLiteral__ValueAssignment_1 ) |
| { |
| before(grammarAccess.getRealLiteralAccess().getValueAssignment_1()); |
| // InternalFSM.g:9181:1: ( rule__RealLiteral__ValueAssignment_1 ) |
| // InternalFSM.g:9181:2: rule__RealLiteral__ValueAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__RealLiteral__ValueAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getRealLiteralAccess().getValueAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RealLiteral__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__IntLiteral__Group__0" |
| // InternalFSM.g:9195:1: rule__IntLiteral__Group__0 : rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 ; |
| public final void rule__IntLiteral__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9199:1: ( rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 ) |
| // InternalFSM.g:9200:2: rule__IntLiteral__Group__0__Impl rule__IntLiteral__Group__1 |
| { |
| pushFollow(FOLLOW_47); |
| rule__IntLiteral__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__IntLiteral__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IntLiteral__Group__0" |
| |
| |
| // $ANTLR start "rule__IntLiteral__Group__0__Impl" |
| // InternalFSM.g:9207:1: rule__IntLiteral__Group__0__Impl : ( () ) ; |
| public final void rule__IntLiteral__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9211:1: ( ( () ) ) |
| // InternalFSM.g:9212:1: ( () ) |
| { |
| // InternalFSM.g:9212:1: ( () ) |
| // InternalFSM.g:9213:1: () |
| { |
| before(grammarAccess.getIntLiteralAccess().getIntLiteralAction_0()); |
| // InternalFSM.g:9214:1: () |
| // InternalFSM.g:9216:1: |
| { |
| } |
| |
| after(grammarAccess.getIntLiteralAccess().getIntLiteralAction_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IntLiteral__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__IntLiteral__Group__1" |
| // InternalFSM.g:9226:1: rule__IntLiteral__Group__1 : rule__IntLiteral__Group__1__Impl ; |
| public final void rule__IntLiteral__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9230:1: ( rule__IntLiteral__Group__1__Impl ) |
| // InternalFSM.g:9231:2: rule__IntLiteral__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__IntLiteral__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IntLiteral__Group__1" |
| |
| |
| // $ANTLR start "rule__IntLiteral__Group__1__Impl" |
| // InternalFSM.g:9237:1: rule__IntLiteral__Group__1__Impl : ( ( rule__IntLiteral__ValueAssignment_1 ) ) ; |
| public final void rule__IntLiteral__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9241:1: ( ( ( rule__IntLiteral__ValueAssignment_1 ) ) ) |
| // InternalFSM.g:9242:1: ( ( rule__IntLiteral__ValueAssignment_1 ) ) |
| { |
| // InternalFSM.g:9242:1: ( ( rule__IntLiteral__ValueAssignment_1 ) ) |
| // InternalFSM.g:9243:1: ( rule__IntLiteral__ValueAssignment_1 ) |
| { |
| before(grammarAccess.getIntLiteralAccess().getValueAssignment_1()); |
| // InternalFSM.g:9244:1: ( rule__IntLiteral__ValueAssignment_1 ) |
| // InternalFSM.g:9244:2: rule__IntLiteral__ValueAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__IntLiteral__ValueAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getIntLiteralAccess().getValueAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IntLiteral__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__StringLiteral__Group__0" |
| // InternalFSM.g:9258:1: rule__StringLiteral__Group__0 : rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 ; |
| public final void rule__StringLiteral__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9262:1: ( rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 ) |
| // InternalFSM.g:9263:2: rule__StringLiteral__Group__0__Impl rule__StringLiteral__Group__1 |
| { |
| pushFollow(FOLLOW_39); |
| rule__StringLiteral__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__StringLiteral__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringLiteral__Group__0" |
| |
| |
| // $ANTLR start "rule__StringLiteral__Group__0__Impl" |
| // InternalFSM.g:9270:1: rule__StringLiteral__Group__0__Impl : ( () ) ; |
| public final void rule__StringLiteral__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9274:1: ( ( () ) ) |
| // InternalFSM.g:9275:1: ( () ) |
| { |
| // InternalFSM.g:9275:1: ( () ) |
| // InternalFSM.g:9276:1: () |
| { |
| before(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0()); |
| // InternalFSM.g:9277:1: () |
| // InternalFSM.g:9279:1: |
| { |
| } |
| |
| after(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringLiteral__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__StringLiteral__Group__1" |
| // InternalFSM.g:9289:1: rule__StringLiteral__Group__1 : rule__StringLiteral__Group__1__Impl ; |
| public final void rule__StringLiteral__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9293:1: ( rule__StringLiteral__Group__1__Impl ) |
| // InternalFSM.g:9294:2: rule__StringLiteral__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__StringLiteral__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringLiteral__Group__1" |
| |
| |
| // $ANTLR start "rule__StringLiteral__Group__1__Impl" |
| // InternalFSM.g:9300:1: rule__StringLiteral__Group__1__Impl : ( ( rule__StringLiteral__ValueAssignment_1 ) ) ; |
| public final void rule__StringLiteral__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9304:1: ( ( ( rule__StringLiteral__ValueAssignment_1 ) ) ) |
| // InternalFSM.g:9305:1: ( ( rule__StringLiteral__ValueAssignment_1 ) ) |
| { |
| // InternalFSM.g:9305:1: ( ( rule__StringLiteral__ValueAssignment_1 ) ) |
| // InternalFSM.g:9306:1: ( rule__StringLiteral__ValueAssignment_1 ) |
| { |
| before(grammarAccess.getStringLiteralAccess().getValueAssignment_1()); |
| // InternalFSM.g:9307:1: ( rule__StringLiteral__ValueAssignment_1 ) |
| // InternalFSM.g:9307:2: rule__StringLiteral__ValueAssignment_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__StringLiteral__ValueAssignment_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getStringLiteralAccess().getValueAssignment_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringLiteral__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Integer__Group_0__0" |
| // InternalFSM.g:9321:1: rule__Integer__Group_0__0 : rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 ; |
| public final void rule__Integer__Group_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9325:1: ( rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 ) |
| // InternalFSM.g:9326:2: rule__Integer__Group_0__0__Impl rule__Integer__Group_0__1 |
| { |
| pushFollow(FOLLOW_48); |
| rule__Integer__Group_0__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Integer__Group_0__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Integer__Group_0__0" |
| |
| |
| // $ANTLR start "rule__Integer__Group_0__0__Impl" |
| // InternalFSM.g:9333:1: rule__Integer__Group_0__0__Impl : ( ( rule__Integer__Alternatives_0_0 )? ) ; |
| public final void rule__Integer__Group_0__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9337:1: ( ( ( rule__Integer__Alternatives_0_0 )? ) ) |
| // InternalFSM.g:9338:1: ( ( rule__Integer__Alternatives_0_0 )? ) |
| { |
| // InternalFSM.g:9338:1: ( ( rule__Integer__Alternatives_0_0 )? ) |
| // InternalFSM.g:9339:1: ( rule__Integer__Alternatives_0_0 )? |
| { |
| before(grammarAccess.getIntegerAccess().getAlternatives_0_0()); |
| // InternalFSM.g:9340:1: ( rule__Integer__Alternatives_0_0 )? |
| int alt74=2; |
| int LA74_0 = input.LA(1); |
| |
| if ( ((LA74_0>=14 && LA74_0<=15)) ) { |
| alt74=1; |
| } |
| switch (alt74) { |
| case 1 : |
| // InternalFSM.g:9340:2: rule__Integer__Alternatives_0_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Integer__Alternatives_0_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getIntegerAccess().getAlternatives_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Integer__Group_0__0__Impl" |
| |
| |
| // $ANTLR start "rule__Integer__Group_0__1" |
| // InternalFSM.g:9350:1: rule__Integer__Group_0__1 : rule__Integer__Group_0__1__Impl ; |
| public final void rule__Integer__Group_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9354:1: ( rule__Integer__Group_0__1__Impl ) |
| // InternalFSM.g:9355:2: rule__Integer__Group_0__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__Integer__Group_0__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Integer__Group_0__1" |
| |
| |
| // $ANTLR start "rule__Integer__Group_0__1__Impl" |
| // InternalFSM.g:9361:1: rule__Integer__Group_0__1__Impl : ( RULE_INT ) ; |
| public final void rule__Integer__Group_0__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9365:1: ( ( RULE_INT ) ) |
| // InternalFSM.g:9366:1: ( RULE_INT ) |
| { |
| // InternalFSM.g:9366:1: ( RULE_INT ) |
| // InternalFSM.g:9367:1: RULE_INT |
| { |
| before(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_0_1()); |
| match(input,RULE_INT,FOLLOW_2); |
| after(grammarAccess.getIntegerAccess().getINTTerminalRuleCall_0_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Integer__Group_0__1__Impl" |
| |
| |
| // $ANTLR start "rule__Decimal__Group__0" |
| // InternalFSM.g:9382:1: rule__Decimal__Group__0 : rule__Decimal__Group__0__Impl rule__Decimal__Group__1 ; |
| public final void rule__Decimal__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9386:1: ( rule__Decimal__Group__0__Impl rule__Decimal__Group__1 ) |
| // InternalFSM.g:9387:2: rule__Decimal__Group__0__Impl rule__Decimal__Group__1 |
| { |
| pushFollow(FOLLOW_48); |
| rule__Decimal__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Decimal__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Decimal__Group__0" |
| |
| |
| // $ANTLR start "rule__Decimal__Group__0__Impl" |
| // InternalFSM.g:9394:1: rule__Decimal__Group__0__Impl : ( ( rule__Decimal__Alternatives_0 )? ) ; |
| public final void rule__Decimal__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9398:1: ( ( ( rule__Decimal__Alternatives_0 )? ) ) |
| // InternalFSM.g:9399:1: ( ( rule__Decimal__Alternatives_0 )? ) |
| { |
| // InternalFSM.g:9399:1: ( ( rule__Decimal__Alternatives_0 )? ) |
| // InternalFSM.g:9400:1: ( rule__Decimal__Alternatives_0 )? |
| { |
| before(grammarAccess.getDecimalAccess().getAlternatives_0()); |
| // InternalFSM.g:9401:1: ( rule__Decimal__Alternatives_0 )? |
| int alt75=2; |
| int LA75_0 = input.LA(1); |
| |
| if ( ((LA75_0>=14 && LA75_0<=15)) ) { |
| alt75=1; |
| } |
| switch (alt75) { |
| case 1 : |
| // InternalFSM.g:9401:2: rule__Decimal__Alternatives_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__Decimal__Alternatives_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getDecimalAccess().getAlternatives_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Decimal__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__Decimal__Group__1" |
| // InternalFSM.g:9411:1: rule__Decimal__Group__1 : rule__Decimal__Group__1__Impl rule__Decimal__Group__2 ; |
| public final void rule__Decimal__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9415:1: ( rule__Decimal__Group__1__Impl rule__Decimal__Group__2 ) |
| // InternalFSM.g:9416:2: rule__Decimal__Group__1__Impl rule__Decimal__Group__2 |
| { |
| pushFollow(FOLLOW_49); |
| rule__Decimal__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Decimal__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Decimal__Group__1" |
| |
| |
| // $ANTLR start "rule__Decimal__Group__1__Impl" |
| // InternalFSM.g:9423:1: rule__Decimal__Group__1__Impl : ( RULE_INT ) ; |
| public final void rule__Decimal__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9427:1: ( ( RULE_INT ) ) |
| // InternalFSM.g:9428:1: ( RULE_INT ) |
| { |
| // InternalFSM.g:9428:1: ( RULE_INT ) |
| // InternalFSM.g:9429:1: RULE_INT |
| { |
| before(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_1()); |
| match(input,RULE_INT,FOLLOW_2); |
| after(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Decimal__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__Decimal__Group__2" |
| // InternalFSM.g:9440:1: rule__Decimal__Group__2 : rule__Decimal__Group__2__Impl rule__Decimal__Group__3 ; |
| public final void rule__Decimal__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9444:1: ( rule__Decimal__Group__2__Impl rule__Decimal__Group__3 ) |
| // InternalFSM.g:9445:2: rule__Decimal__Group__2__Impl rule__Decimal__Group__3 |
| { |
| pushFollow(FOLLOW_50); |
| rule__Decimal__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__Decimal__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Decimal__Group__2" |
| |
| |
| // $ANTLR start "rule__Decimal__Group__2__Impl" |
| // InternalFSM.g:9452:1: rule__Decimal__Group__2__Impl : ( '.' ) ; |
| public final void rule__Decimal__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9456:1: ( ( '.' ) ) |
| // InternalFSM.g:9457:1: ( '.' ) |
| { |
| // InternalFSM.g:9457:1: ( '.' ) |
| // InternalFSM.g:9458:1: '.' |
| { |
| before(grammarAccess.getDecimalAccess().getFullStopKeyword_2()); |
| match(input,67,FOLLOW_2); |
| after(grammarAccess.getDecimalAccess().getFullStopKeyword_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Decimal__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__Decimal__Group__3" |
| // InternalFSM.g:9471:1: rule__Decimal__Group__3 : rule__Decimal__Group__3__Impl ; |
| public final void rule__Decimal__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9475:1: ( rule__Decimal__Group__3__Impl ) |
| // InternalFSM.g:9476:2: rule__Decimal__Group__3__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__Decimal__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Decimal__Group__3" |
| |
| |
| // $ANTLR start "rule__Decimal__Group__3__Impl" |
| // InternalFSM.g:9482:1: rule__Decimal__Group__3__Impl : ( RULE_INT ) ; |
| public final void rule__Decimal__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9486:1: ( ( RULE_INT ) ) |
| // InternalFSM.g:9487:1: ( RULE_INT ) |
| { |
| // InternalFSM.g:9487:1: ( RULE_INT ) |
| // InternalFSM.g:9488:1: RULE_INT |
| { |
| before(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_3()); |
| match(input,RULE_INT,FOLLOW_2); |
| after(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Decimal__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__0" |
| // InternalFSM.g:9507:1: rule__DecimalExp__Group__0 : rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 ; |
| public final void rule__DecimalExp__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9511:1: ( rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 ) |
| // InternalFSM.g:9512:2: rule__DecimalExp__Group__0__Impl rule__DecimalExp__Group__1 |
| { |
| pushFollow(FOLLOW_47); |
| rule__DecimalExp__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__0" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__0__Impl" |
| // InternalFSM.g:9519:1: rule__DecimalExp__Group__0__Impl : ( ( rule__DecimalExp__Alternatives_0 )? ) ; |
| public final void rule__DecimalExp__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9523:1: ( ( ( rule__DecimalExp__Alternatives_0 )? ) ) |
| // InternalFSM.g:9524:1: ( ( rule__DecimalExp__Alternatives_0 )? ) |
| { |
| // InternalFSM.g:9524:1: ( ( rule__DecimalExp__Alternatives_0 )? ) |
| // InternalFSM.g:9525:1: ( rule__DecimalExp__Alternatives_0 )? |
| { |
| before(grammarAccess.getDecimalExpAccess().getAlternatives_0()); |
| // InternalFSM.g:9526:1: ( rule__DecimalExp__Alternatives_0 )? |
| int alt76=2; |
| int LA76_0 = input.LA(1); |
| |
| if ( ((LA76_0>=14 && LA76_0<=15)) ) { |
| alt76=1; |
| } |
| switch (alt76) { |
| case 1 : |
| // InternalFSM.g:9526:2: rule__DecimalExp__Alternatives_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Alternatives_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getDecimalExpAccess().getAlternatives_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__1" |
| // InternalFSM.g:9536:1: rule__DecimalExp__Group__1 : rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 ; |
| public final void rule__DecimalExp__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9540:1: ( rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 ) |
| // InternalFSM.g:9541:2: rule__DecimalExp__Group__1__Impl rule__DecimalExp__Group__2 |
| { |
| pushFollow(FOLLOW_49); |
| rule__DecimalExp__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Group__2(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__1" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__1__Impl" |
| // InternalFSM.g:9548:1: rule__DecimalExp__Group__1__Impl : ( RULE_INT ) ; |
| public final void rule__DecimalExp__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9552:1: ( ( RULE_INT ) ) |
| // InternalFSM.g:9553:1: ( RULE_INT ) |
| { |
| // InternalFSM.g:9553:1: ( RULE_INT ) |
| // InternalFSM.g:9554:1: RULE_INT |
| { |
| before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_1()); |
| match(input,RULE_INT,FOLLOW_2); |
| after(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__2" |
| // InternalFSM.g:9565:1: rule__DecimalExp__Group__2 : rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 ; |
| public final void rule__DecimalExp__Group__2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9569:1: ( rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 ) |
| // InternalFSM.g:9570:2: rule__DecimalExp__Group__2__Impl rule__DecimalExp__Group__3 |
| { |
| pushFollow(FOLLOW_50); |
| rule__DecimalExp__Group__2__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Group__3(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__2" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__2__Impl" |
| // InternalFSM.g:9577:1: rule__DecimalExp__Group__2__Impl : ( '.' ) ; |
| public final void rule__DecimalExp__Group__2__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9581:1: ( ( '.' ) ) |
| // InternalFSM.g:9582:1: ( '.' ) |
| { |
| // InternalFSM.g:9582:1: ( '.' ) |
| // InternalFSM.g:9583:1: '.' |
| { |
| before(grammarAccess.getDecimalExpAccess().getFullStopKeyword_2()); |
| match(input,67,FOLLOW_2); |
| after(grammarAccess.getDecimalExpAccess().getFullStopKeyword_2()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__2__Impl" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__3" |
| // InternalFSM.g:9596:1: rule__DecimalExp__Group__3 : rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 ; |
| public final void rule__DecimalExp__Group__3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9600:1: ( rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 ) |
| // InternalFSM.g:9601:2: rule__DecimalExp__Group__3__Impl rule__DecimalExp__Group__4 |
| { |
| pushFollow(FOLLOW_51); |
| rule__DecimalExp__Group__3__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Group__4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__3" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__3__Impl" |
| // InternalFSM.g:9608:1: rule__DecimalExp__Group__3__Impl : ( RULE_INT ) ; |
| public final void rule__DecimalExp__Group__3__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9612:1: ( ( RULE_INT ) ) |
| // InternalFSM.g:9613:1: ( RULE_INT ) |
| { |
| // InternalFSM.g:9613:1: ( RULE_INT ) |
| // InternalFSM.g:9614:1: RULE_INT |
| { |
| before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_3()); |
| match(input,RULE_INT,FOLLOW_2); |
| after(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_3()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__3__Impl" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__4" |
| // InternalFSM.g:9625:1: rule__DecimalExp__Group__4 : rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 ; |
| public final void rule__DecimalExp__Group__4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9629:1: ( rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 ) |
| // InternalFSM.g:9630:2: rule__DecimalExp__Group__4__Impl rule__DecimalExp__Group__5 |
| { |
| pushFollow(FOLLOW_48); |
| rule__DecimalExp__Group__4__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Group__5(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__4" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__4__Impl" |
| // InternalFSM.g:9637:1: rule__DecimalExp__Group__4__Impl : ( ( rule__DecimalExp__Alternatives_4 ) ) ; |
| public final void rule__DecimalExp__Group__4__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9641:1: ( ( ( rule__DecimalExp__Alternatives_4 ) ) ) |
| // InternalFSM.g:9642:1: ( ( rule__DecimalExp__Alternatives_4 ) ) |
| { |
| // InternalFSM.g:9642:1: ( ( rule__DecimalExp__Alternatives_4 ) ) |
| // InternalFSM.g:9643:1: ( rule__DecimalExp__Alternatives_4 ) |
| { |
| before(grammarAccess.getDecimalExpAccess().getAlternatives_4()); |
| // InternalFSM.g:9644:1: ( rule__DecimalExp__Alternatives_4 ) |
| // InternalFSM.g:9644:2: rule__DecimalExp__Alternatives_4 |
| { |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Alternatives_4(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getDecimalExpAccess().getAlternatives_4()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__4__Impl" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__5" |
| // InternalFSM.g:9654:1: rule__DecimalExp__Group__5 : rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 ; |
| public final void rule__DecimalExp__Group__5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9658:1: ( rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 ) |
| // InternalFSM.g:9659:2: rule__DecimalExp__Group__5__Impl rule__DecimalExp__Group__6 |
| { |
| pushFollow(FOLLOW_48); |
| rule__DecimalExp__Group__5__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Group__6(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__5" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__5__Impl" |
| // InternalFSM.g:9666:1: rule__DecimalExp__Group__5__Impl : ( ( rule__DecimalExp__Alternatives_5 )? ) ; |
| public final void rule__DecimalExp__Group__5__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9670:1: ( ( ( rule__DecimalExp__Alternatives_5 )? ) ) |
| // InternalFSM.g:9671:1: ( ( rule__DecimalExp__Alternatives_5 )? ) |
| { |
| // InternalFSM.g:9671:1: ( ( rule__DecimalExp__Alternatives_5 )? ) |
| // InternalFSM.g:9672:1: ( rule__DecimalExp__Alternatives_5 )? |
| { |
| before(grammarAccess.getDecimalExpAccess().getAlternatives_5()); |
| // InternalFSM.g:9673:1: ( rule__DecimalExp__Alternatives_5 )? |
| int alt77=2; |
| int LA77_0 = input.LA(1); |
| |
| if ( ((LA77_0>=14 && LA77_0<=15)) ) { |
| alt77=1; |
| } |
| switch (alt77) { |
| case 1 : |
| // InternalFSM.g:9673:2: rule__DecimalExp__Alternatives_5 |
| { |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Alternatives_5(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| after(grammarAccess.getDecimalExpAccess().getAlternatives_5()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__5__Impl" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__6" |
| // InternalFSM.g:9683:1: rule__DecimalExp__Group__6 : rule__DecimalExp__Group__6__Impl ; |
| public final void rule__DecimalExp__Group__6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9687:1: ( rule__DecimalExp__Group__6__Impl ) |
| // InternalFSM.g:9688:2: rule__DecimalExp__Group__6__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__DecimalExp__Group__6__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__6" |
| |
| |
| // $ANTLR start "rule__DecimalExp__Group__6__Impl" |
| // InternalFSM.g:9694:1: rule__DecimalExp__Group__6__Impl : ( RULE_INT ) ; |
| public final void rule__DecimalExp__Group__6__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9698:1: ( ( RULE_INT ) ) |
| // InternalFSM.g:9699:1: ( RULE_INT ) |
| { |
| // InternalFSM.g:9699:1: ( RULE_INT ) |
| // InternalFSM.g:9700:1: RULE_INT |
| { |
| before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_6()); |
| match(input,RULE_INT,FOLLOW_2); |
| after(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_6()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DecimalExp__Group__6__Impl" |
| |
| |
| // $ANTLR start "rule__FQN__Group__0" |
| // InternalFSM.g:9725:1: rule__FQN__Group__0 : rule__FQN__Group__0__Impl rule__FQN__Group__1 ; |
| public final void rule__FQN__Group__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9729:1: ( rule__FQN__Group__0__Impl rule__FQN__Group__1 ) |
| // InternalFSM.g:9730:2: rule__FQN__Group__0__Impl rule__FQN__Group__1 |
| { |
| pushFollow(FOLLOW_49); |
| rule__FQN__Group__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__FQN__Group__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__FQN__Group__0" |
| |
| |
| // $ANTLR start "rule__FQN__Group__0__Impl" |
| // InternalFSM.g:9737:1: rule__FQN__Group__0__Impl : ( RULE_ID ) ; |
| public final void rule__FQN__Group__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9741:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:9742:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:9742:1: ( RULE_ID ) |
| // InternalFSM.g:9743:1: RULE_ID |
| { |
| before(grammarAccess.getFQNAccess().getIDTerminalRuleCall_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getFQNAccess().getIDTerminalRuleCall_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__FQN__Group__0__Impl" |
| |
| |
| // $ANTLR start "rule__FQN__Group__1" |
| // InternalFSM.g:9754:1: rule__FQN__Group__1 : rule__FQN__Group__1__Impl ; |
| public final void rule__FQN__Group__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9758:1: ( rule__FQN__Group__1__Impl ) |
| // InternalFSM.g:9759:2: rule__FQN__Group__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__FQN__Group__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__FQN__Group__1" |
| |
| |
| // $ANTLR start "rule__FQN__Group__1__Impl" |
| // InternalFSM.g:9765:1: rule__FQN__Group__1__Impl : ( ( rule__FQN__Group_1__0 )* ) ; |
| public final void rule__FQN__Group__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9769:1: ( ( ( rule__FQN__Group_1__0 )* ) ) |
| // InternalFSM.g:9770:1: ( ( rule__FQN__Group_1__0 )* ) |
| { |
| // InternalFSM.g:9770:1: ( ( rule__FQN__Group_1__0 )* ) |
| // InternalFSM.g:9771:1: ( rule__FQN__Group_1__0 )* |
| { |
| before(grammarAccess.getFQNAccess().getGroup_1()); |
| // InternalFSM.g:9772:1: ( rule__FQN__Group_1__0 )* |
| loop78: |
| do { |
| int alt78=2; |
| int LA78_0 = input.LA(1); |
| |
| if ( (LA78_0==67) ) { |
| alt78=1; |
| } |
| |
| |
| switch (alt78) { |
| case 1 : |
| // InternalFSM.g:9772:2: rule__FQN__Group_1__0 |
| { |
| pushFollow(FOLLOW_52); |
| rule__FQN__Group_1__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| default : |
| break loop78; |
| } |
| } while (true); |
| |
| after(grammarAccess.getFQNAccess().getGroup_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__FQN__Group__1__Impl" |
| |
| |
| // $ANTLR start "rule__FQN__Group_1__0" |
| // InternalFSM.g:9786:1: rule__FQN__Group_1__0 : rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 ; |
| public final void rule__FQN__Group_1__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9790:1: ( rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 ) |
| // InternalFSM.g:9791:2: rule__FQN__Group_1__0__Impl rule__FQN__Group_1__1 |
| { |
| pushFollow(FOLLOW_5); |
| rule__FQN__Group_1__0__Impl(); |
| |
| state._fsp--; |
| |
| pushFollow(FOLLOW_2); |
| rule__FQN__Group_1__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__FQN__Group_1__0" |
| |
| |
| // $ANTLR start "rule__FQN__Group_1__0__Impl" |
| // InternalFSM.g:9798:1: rule__FQN__Group_1__0__Impl : ( '.' ) ; |
| public final void rule__FQN__Group_1__0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9802:1: ( ( '.' ) ) |
| // InternalFSM.g:9803:1: ( '.' ) |
| { |
| // InternalFSM.g:9803:1: ( '.' ) |
| // InternalFSM.g:9804:1: '.' |
| { |
| before(grammarAccess.getFQNAccess().getFullStopKeyword_1_0()); |
| match(input,67,FOLLOW_2); |
| after(grammarAccess.getFQNAccess().getFullStopKeyword_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__FQN__Group_1__0__Impl" |
| |
| |
| // $ANTLR start "rule__FQN__Group_1__1" |
| // InternalFSM.g:9817:1: rule__FQN__Group_1__1 : rule__FQN__Group_1__1__Impl ; |
| public final void rule__FQN__Group_1__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9821:1: ( rule__FQN__Group_1__1__Impl ) |
| // InternalFSM.g:9822:2: rule__FQN__Group_1__1__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__FQN__Group_1__1__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__FQN__Group_1__1" |
| |
| |
| // $ANTLR start "rule__FQN__Group_1__1__Impl" |
| // InternalFSM.g:9828:1: rule__FQN__Group_1__1__Impl : ( RULE_ID ) ; |
| public final void rule__FQN__Group_1__1__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9832:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:9833:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:9833:1: ( RULE_ID ) |
| // InternalFSM.g:9834:1: RULE_ID |
| { |
| before(grammarAccess.getFQNAccess().getIDTerminalRuleCall_1_1()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getFQNAccess().getIDTerminalRuleCall_1_1()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__FQN__Group_1__1__Impl" |
| |
| |
| // $ANTLR start "rule__ModelComponent__UnorderedGroup_0" |
| // InternalFSM.g:9850:1: rule__ModelComponent__UnorderedGroup_0 : ( rule__ModelComponent__UnorderedGroup_0__0 )? ; |
| public final void rule__ModelComponent__UnorderedGroup_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| getUnorderedGroupHelper().enter(grammarAccess.getModelComponentAccess().getUnorderedGroup_0()); |
| |
| try { |
| // InternalFSM.g:9855:1: ( ( rule__ModelComponent__UnorderedGroup_0__0 )? ) |
| // InternalFSM.g:9856:2: ( rule__ModelComponent__UnorderedGroup_0__0 )? |
| { |
| // InternalFSM.g:9856:2: ( rule__ModelComponent__UnorderedGroup_0__0 )? |
| int alt79=2; |
| int LA79_0 = input.LA(1); |
| |
| if ( LA79_0 == 68 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) { |
| alt79=1; |
| } |
| else if ( LA79_0 >= 18 && LA79_0 <= 21 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) { |
| alt79=1; |
| } |
| switch (alt79) { |
| case 1 : |
| // InternalFSM.g:9856:2: rule__ModelComponent__UnorderedGroup_0__0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__UnorderedGroup_0__0(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| getUnorderedGroupHelper().leave(grammarAccess.getModelComponentAccess().getUnorderedGroup_0()); |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__UnorderedGroup_0" |
| |
| |
| // $ANTLR start "rule__ModelComponent__UnorderedGroup_0__Impl" |
| // InternalFSM.g:9866:1: rule__ModelComponent__UnorderedGroup_0__Impl : ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) ) ; |
| public final void rule__ModelComponent__UnorderedGroup_0__Impl() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| boolean selected = false; |
| |
| try { |
| // InternalFSM.g:9871:1: ( ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) ) ) |
| // InternalFSM.g:9872:3: ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) ) |
| { |
| // InternalFSM.g:9872:3: ( ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) ) |
| int alt80=2; |
| int LA80_0 = input.LA(1); |
| |
| if ( LA80_0 == 68 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) { |
| alt80=1; |
| } |
| else if ( LA80_0 >= 18 && LA80_0 <= 21 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) { |
| alt80=2; |
| } |
| else { |
| NoViableAltException nvae = |
| new NoViableAltException("", 80, 0, input); |
| |
| throw nvae; |
| } |
| switch (alt80) { |
| case 1 : |
| // InternalFSM.g:9874:4: ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) |
| { |
| // InternalFSM.g:9874:4: ({...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) ) |
| // InternalFSM.g:9875:5: {...}? => ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) |
| { |
| if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) { |
| throw new FailedPredicateException(input, "rule__ModelComponent__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0)"); |
| } |
| // InternalFSM.g:9875:111: ( ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) ) |
| // InternalFSM.g:9876:6: ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) |
| { |
| |
| getUnorderedGroupHelper().select(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0); |
| |
| |
| selected = true; |
| |
| // InternalFSM.g:9882:6: ( ( rule__ModelComponent__AbstractAssignment_0_0 ) ) |
| // InternalFSM.g:9884:7: ( rule__ModelComponent__AbstractAssignment_0_0 ) |
| { |
| before(grammarAccess.getModelComponentAccess().getAbstractAssignment_0_0()); |
| // InternalFSM.g:9885:7: ( rule__ModelComponent__AbstractAssignment_0_0 ) |
| // InternalFSM.g:9885:8: rule__ModelComponent__AbstractAssignment_0_0 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__AbstractAssignment_0_0(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getModelComponentAccess().getAbstractAssignment_0_0()); |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| break; |
| case 2 : |
| // InternalFSM.g:9891:4: ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) |
| { |
| // InternalFSM.g:9891:4: ({...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) ) |
| // InternalFSM.g:9892:5: {...}? => ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) |
| { |
| if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) { |
| throw new FailedPredicateException(input, "rule__ModelComponent__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1)"); |
| } |
| // InternalFSM.g:9892:111: ( ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) ) |
| // InternalFSM.g:9893:6: ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) |
| { |
| |
| getUnorderedGroupHelper().select(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1); |
| |
| |
| selected = true; |
| |
| // InternalFSM.g:9899:6: ( ( rule__ModelComponent__CommTypeAssignment_0_1 ) ) |
| // InternalFSM.g:9901:7: ( rule__ModelComponent__CommTypeAssignment_0_1 ) |
| { |
| before(grammarAccess.getModelComponentAccess().getCommTypeAssignment_0_1()); |
| // InternalFSM.g:9902:7: ( rule__ModelComponent__CommTypeAssignment_0_1 ) |
| // InternalFSM.g:9902:8: rule__ModelComponent__CommTypeAssignment_0_1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__CommTypeAssignment_0_1(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| after(grammarAccess.getModelComponentAccess().getCommTypeAssignment_0_1()); |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| if (selected) |
| getUnorderedGroupHelper().returnFromSelection(grammarAccess.getModelComponentAccess().getUnorderedGroup_0()); |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__UnorderedGroup_0__Impl" |
| |
| |
| // $ANTLR start "rule__ModelComponent__UnorderedGroup_0__0" |
| // InternalFSM.g:9917:1: rule__ModelComponent__UnorderedGroup_0__0 : rule__ModelComponent__UnorderedGroup_0__Impl ( rule__ModelComponent__UnorderedGroup_0__1 )? ; |
| public final void rule__ModelComponent__UnorderedGroup_0__0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9921:1: ( rule__ModelComponent__UnorderedGroup_0__Impl ( rule__ModelComponent__UnorderedGroup_0__1 )? ) |
| // InternalFSM.g:9922:2: rule__ModelComponent__UnorderedGroup_0__Impl ( rule__ModelComponent__UnorderedGroup_0__1 )? |
| { |
| pushFollow(FOLLOW_3); |
| rule__ModelComponent__UnorderedGroup_0__Impl(); |
| |
| state._fsp--; |
| |
| // InternalFSM.g:9923:2: ( rule__ModelComponent__UnorderedGroup_0__1 )? |
| int alt81=2; |
| int LA81_0 = input.LA(1); |
| |
| if ( LA81_0 == 68 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 0) ) { |
| alt81=1; |
| } |
| else if ( LA81_0 >= 18 && LA81_0 <= 21 && getUnorderedGroupHelper().canSelect(grammarAccess.getModelComponentAccess().getUnorderedGroup_0(), 1) ) { |
| alt81=1; |
| } |
| switch (alt81) { |
| case 1 : |
| // InternalFSM.g:9923:2: rule__ModelComponent__UnorderedGroup_0__1 |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__UnorderedGroup_0__1(); |
| |
| state._fsp--; |
| |
| |
| } |
| break; |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__UnorderedGroup_0__0" |
| |
| |
| // $ANTLR start "rule__ModelComponent__UnorderedGroup_0__1" |
| // InternalFSM.g:9930:1: rule__ModelComponent__UnorderedGroup_0__1 : rule__ModelComponent__UnorderedGroup_0__Impl ; |
| public final void rule__ModelComponent__UnorderedGroup_0__1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9934:1: ( rule__ModelComponent__UnorderedGroup_0__Impl ) |
| // InternalFSM.g:9935:2: rule__ModelComponent__UnorderedGroup_0__Impl |
| { |
| pushFollow(FOLLOW_2); |
| rule__ModelComponent__UnorderedGroup_0__Impl(); |
| |
| state._fsp--; |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__UnorderedGroup_0__1" |
| |
| |
| // $ANTLR start "rule__FSMModel__ComponentsAssignment" |
| // InternalFSM.g:9946:1: rule__FSMModel__ComponentsAssignment : ( ruleModelComponent ) ; |
| public final void rule__FSMModel__ComponentsAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9950:1: ( ( ruleModelComponent ) ) |
| // InternalFSM.g:9951:1: ( ruleModelComponent ) |
| { |
| // InternalFSM.g:9951:1: ( ruleModelComponent ) |
| // InternalFSM.g:9952:1: ruleModelComponent |
| { |
| before(grammarAccess.getFSMModelAccess().getComponentsModelComponentParserRuleCall_0()); |
| pushFollow(FOLLOW_2); |
| ruleModelComponent(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getFSMModelAccess().getComponentsModelComponentParserRuleCall_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__FSMModel__ComponentsAssignment" |
| |
| |
| // $ANTLR start "rule__ModelComponent__AbstractAssignment_0_0" |
| // InternalFSM.g:9961:1: rule__ModelComponent__AbstractAssignment_0_0 : ( ( 'abstract' ) ) ; |
| public final void rule__ModelComponent__AbstractAssignment_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9965:1: ( ( ( 'abstract' ) ) ) |
| // InternalFSM.g:9966:1: ( ( 'abstract' ) ) |
| { |
| // InternalFSM.g:9966:1: ( ( 'abstract' ) ) |
| // InternalFSM.g:9967:1: ( 'abstract' ) |
| { |
| before(grammarAccess.getModelComponentAccess().getAbstractAbstractKeyword_0_0_0()); |
| // InternalFSM.g:9968:1: ( 'abstract' ) |
| // InternalFSM.g:9969:1: 'abstract' |
| { |
| before(grammarAccess.getModelComponentAccess().getAbstractAbstractKeyword_0_0_0()); |
| match(input,68,FOLLOW_2); |
| after(grammarAccess.getModelComponentAccess().getAbstractAbstractKeyword_0_0_0()); |
| |
| } |
| |
| after(grammarAccess.getModelComponentAccess().getAbstractAbstractKeyword_0_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__AbstractAssignment_0_0" |
| |
| |
| // $ANTLR start "rule__ModelComponent__CommTypeAssignment_0_1" |
| // InternalFSM.g:9984:1: rule__ModelComponent__CommTypeAssignment_0_1 : ( ruleComponentCommunicationType ) ; |
| public final void rule__ModelComponent__CommTypeAssignment_0_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:9988:1: ( ( ruleComponentCommunicationType ) ) |
| // InternalFSM.g:9989:1: ( ruleComponentCommunicationType ) |
| { |
| // InternalFSM.g:9989:1: ( ruleComponentCommunicationType ) |
| // InternalFSM.g:9990:1: ruleComponentCommunicationType |
| { |
| before(grammarAccess.getModelComponentAccess().getCommTypeComponentCommunicationTypeEnumRuleCall_0_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleComponentCommunicationType(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getModelComponentAccess().getCommTypeComponentCommunicationTypeEnumRuleCall_0_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__CommTypeAssignment_0_1" |
| |
| |
| // $ANTLR start "rule__ModelComponent__ComponentNameAssignment_2" |
| // InternalFSM.g:9999:1: rule__ModelComponent__ComponentNameAssignment_2 : ( RULE_ID ) ; |
| public final void rule__ModelComponent__ComponentNameAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10003:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10004:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10004:1: ( RULE_ID ) |
| // InternalFSM.g:10005:1: RULE_ID |
| { |
| before(grammarAccess.getModelComponentAccess().getComponentNameIDTerminalRuleCall_2_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getModelComponentAccess().getComponentNameIDTerminalRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__ComponentNameAssignment_2" |
| |
| |
| // $ANTLR start "rule__ModelComponent__BaseAssignment_3_1" |
| // InternalFSM.g:10014:1: rule__ModelComponent__BaseAssignment_3_1 : ( ( ruleFQN ) ) ; |
| public final void rule__ModelComponent__BaseAssignment_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10018:1: ( ( ( ruleFQN ) ) ) |
| // InternalFSM.g:10019:1: ( ( ruleFQN ) ) |
| { |
| // InternalFSM.g:10019:1: ( ( ruleFQN ) ) |
| // InternalFSM.g:10020:1: ( ruleFQN ) |
| { |
| before(grammarAccess.getModelComponentAccess().getBaseModelComponentCrossReference_3_1_0()); |
| // InternalFSM.g:10021:1: ( ruleFQN ) |
| // InternalFSM.g:10022:1: ruleFQN |
| { |
| before(grammarAccess.getModelComponentAccess().getBaseModelComponentFQNParserRuleCall_3_1_0_1()); |
| pushFollow(FOLLOW_2); |
| ruleFQN(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getModelComponentAccess().getBaseModelComponentFQNParserRuleCall_3_1_0_1()); |
| |
| } |
| |
| after(grammarAccess.getModelComponentAccess().getBaseModelComponentCrossReference_3_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__BaseAssignment_3_1" |
| |
| |
| // $ANTLR start "rule__ModelComponent__StateMachineAssignment_4" |
| // InternalFSM.g:10033:1: rule__ModelComponent__StateMachineAssignment_4 : ( ruleStateMachine ) ; |
| public final void rule__ModelComponent__StateMachineAssignment_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10037:1: ( ( ruleStateMachine ) ) |
| // InternalFSM.g:10038:1: ( ruleStateMachine ) |
| { |
| // InternalFSM.g:10038:1: ( ruleStateMachine ) |
| // InternalFSM.g:10039:1: ruleStateMachine |
| { |
| before(grammarAccess.getModelComponentAccess().getStateMachineStateMachineParserRuleCall_4_0()); |
| pushFollow(FOLLOW_2); |
| ruleStateMachine(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getModelComponentAccess().getStateMachineStateMachineParserRuleCall_4_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ModelComponent__StateMachineAssignment_4" |
| |
| |
| // $ANTLR start "rule__StateGraph__StatesAssignment_2_0" |
| // InternalFSM.g:10048:1: rule__StateGraph__StatesAssignment_2_0 : ( ruleState ) ; |
| public final void rule__StateGraph__StatesAssignment_2_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10052:1: ( ( ruleState ) ) |
| // InternalFSM.g:10053:1: ( ruleState ) |
| { |
| // InternalFSM.g:10053:1: ( ruleState ) |
| // InternalFSM.g:10054:1: ruleState |
| { |
| before(grammarAccess.getStateGraphAccess().getStatesStateParserRuleCall_2_0_0()); |
| pushFollow(FOLLOW_2); |
| ruleState(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateGraphAccess().getStatesStateParserRuleCall_2_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__StatesAssignment_2_0" |
| |
| |
| // $ANTLR start "rule__StateGraph__TrPointsAssignment_2_1" |
| // InternalFSM.g:10063:1: rule__StateGraph__TrPointsAssignment_2_1 : ( ruleTrPoint ) ; |
| public final void rule__StateGraph__TrPointsAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10067:1: ( ( ruleTrPoint ) ) |
| // InternalFSM.g:10068:1: ( ruleTrPoint ) |
| { |
| // InternalFSM.g:10068:1: ( ruleTrPoint ) |
| // InternalFSM.g:10069:1: ruleTrPoint |
| { |
| before(grammarAccess.getStateGraphAccess().getTrPointsTrPointParserRuleCall_2_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleTrPoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateGraphAccess().getTrPointsTrPointParserRuleCall_2_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__TrPointsAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__StateGraph__ChPointsAssignment_2_2" |
| // InternalFSM.g:10078:1: rule__StateGraph__ChPointsAssignment_2_2 : ( ruleChoicePoint ) ; |
| public final void rule__StateGraph__ChPointsAssignment_2_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10082:1: ( ( ruleChoicePoint ) ) |
| // InternalFSM.g:10083:1: ( ruleChoicePoint ) |
| { |
| // InternalFSM.g:10083:1: ( ruleChoicePoint ) |
| // InternalFSM.g:10084:1: ruleChoicePoint |
| { |
| before(grammarAccess.getStateGraphAccess().getChPointsChoicePointParserRuleCall_2_2_0()); |
| pushFollow(FOLLOW_2); |
| ruleChoicePoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateGraphAccess().getChPointsChoicePointParserRuleCall_2_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__ChPointsAssignment_2_2" |
| |
| |
| // $ANTLR start "rule__StateGraph__TransitionsAssignment_2_3" |
| // InternalFSM.g:10093:1: rule__StateGraph__TransitionsAssignment_2_3 : ( ruleTransition ) ; |
| public final void rule__StateGraph__TransitionsAssignment_2_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10097:1: ( ( ruleTransition ) ) |
| // InternalFSM.g:10098:1: ( ruleTransition ) |
| { |
| // InternalFSM.g:10098:1: ( ruleTransition ) |
| // InternalFSM.g:10099:1: ruleTransition |
| { |
| before(grammarAccess.getStateGraphAccess().getTransitionsTransitionParserRuleCall_2_3_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateGraphAccess().getTransitionsTransitionParserRuleCall_2_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__TransitionsAssignment_2_3" |
| |
| |
| // $ANTLR start "rule__StateGraph__RefinedTransitionsAssignment_2_4" |
| // InternalFSM.g:10108:1: rule__StateGraph__RefinedTransitionsAssignment_2_4 : ( ruleRefinedTransition ) ; |
| public final void rule__StateGraph__RefinedTransitionsAssignment_2_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10112:1: ( ( ruleRefinedTransition ) ) |
| // InternalFSM.g:10113:1: ( ruleRefinedTransition ) |
| { |
| // InternalFSM.g:10113:1: ( ruleRefinedTransition ) |
| // InternalFSM.g:10114:1: ruleRefinedTransition |
| { |
| before(grammarAccess.getStateGraphAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_2_4_0()); |
| pushFollow(FOLLOW_2); |
| ruleRefinedTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateGraphAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_2_4_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateGraph__RefinedTransitionsAssignment_2_4" |
| |
| |
| // $ANTLR start "rule__StateMachine__StatesAssignment_3_0" |
| // InternalFSM.g:10123:1: rule__StateMachine__StatesAssignment_3_0 : ( ruleState ) ; |
| public final void rule__StateMachine__StatesAssignment_3_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10127:1: ( ( ruleState ) ) |
| // InternalFSM.g:10128:1: ( ruleState ) |
| { |
| // InternalFSM.g:10128:1: ( ruleState ) |
| // InternalFSM.g:10129:1: ruleState |
| { |
| before(grammarAccess.getStateMachineAccess().getStatesStateParserRuleCall_3_0_0()); |
| pushFollow(FOLLOW_2); |
| ruleState(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateMachineAccess().getStatesStateParserRuleCall_3_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__StatesAssignment_3_0" |
| |
| |
| // $ANTLR start "rule__StateMachine__TrPointsAssignment_3_1" |
| // InternalFSM.g:10138:1: rule__StateMachine__TrPointsAssignment_3_1 : ( ruleTrPoint ) ; |
| public final void rule__StateMachine__TrPointsAssignment_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10142:1: ( ( ruleTrPoint ) ) |
| // InternalFSM.g:10143:1: ( ruleTrPoint ) |
| { |
| // InternalFSM.g:10143:1: ( ruleTrPoint ) |
| // InternalFSM.g:10144:1: ruleTrPoint |
| { |
| before(grammarAccess.getStateMachineAccess().getTrPointsTrPointParserRuleCall_3_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleTrPoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateMachineAccess().getTrPointsTrPointParserRuleCall_3_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__TrPointsAssignment_3_1" |
| |
| |
| // $ANTLR start "rule__StateMachine__ChPointsAssignment_3_2" |
| // InternalFSM.g:10153:1: rule__StateMachine__ChPointsAssignment_3_2 : ( ruleChoicePoint ) ; |
| public final void rule__StateMachine__ChPointsAssignment_3_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10157:1: ( ( ruleChoicePoint ) ) |
| // InternalFSM.g:10158:1: ( ruleChoicePoint ) |
| { |
| // InternalFSM.g:10158:1: ( ruleChoicePoint ) |
| // InternalFSM.g:10159:1: ruleChoicePoint |
| { |
| before(grammarAccess.getStateMachineAccess().getChPointsChoicePointParserRuleCall_3_2_0()); |
| pushFollow(FOLLOW_2); |
| ruleChoicePoint(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateMachineAccess().getChPointsChoicePointParserRuleCall_3_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__ChPointsAssignment_3_2" |
| |
| |
| // $ANTLR start "rule__StateMachine__TransitionsAssignment_3_3" |
| // InternalFSM.g:10168:1: rule__StateMachine__TransitionsAssignment_3_3 : ( ruleTransition ) ; |
| public final void rule__StateMachine__TransitionsAssignment_3_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10172:1: ( ( ruleTransition ) ) |
| // InternalFSM.g:10173:1: ( ruleTransition ) |
| { |
| // InternalFSM.g:10173:1: ( ruleTransition ) |
| // InternalFSM.g:10174:1: ruleTransition |
| { |
| before(grammarAccess.getStateMachineAccess().getTransitionsTransitionParserRuleCall_3_3_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateMachineAccess().getTransitionsTransitionParserRuleCall_3_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__TransitionsAssignment_3_3" |
| |
| |
| // $ANTLR start "rule__StateMachine__RefinedTransitionsAssignment_3_4" |
| // InternalFSM.g:10183:1: rule__StateMachine__RefinedTransitionsAssignment_3_4 : ( ruleRefinedTransition ) ; |
| public final void rule__StateMachine__RefinedTransitionsAssignment_3_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10187:1: ( ( ruleRefinedTransition ) ) |
| // InternalFSM.g:10188:1: ( ruleRefinedTransition ) |
| { |
| // InternalFSM.g:10188:1: ( ruleRefinedTransition ) |
| // InternalFSM.g:10189:1: ruleRefinedTransition |
| { |
| before(grammarAccess.getStateMachineAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_3_4_0()); |
| pushFollow(FOLLOW_2); |
| ruleRefinedTransition(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getStateMachineAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_3_4_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateMachine__RefinedTransitionsAssignment_3_4" |
| |
| |
| // $ANTLR start "rule__SimpleState__NameAssignment_1" |
| // InternalFSM.g:10198:1: rule__SimpleState__NameAssignment_1 : ( RULE_ID ) ; |
| public final void rule__SimpleState__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10202:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10203:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10203:1: ( RULE_ID ) |
| // InternalFSM.g:10204:1: RULE_ID |
| { |
| before(grammarAccess.getSimpleStateAccess().getNameIDTerminalRuleCall_1_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getSimpleStateAccess().getNameIDTerminalRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__SimpleState__DocuAssignment_2" |
| // InternalFSM.g:10213:1: rule__SimpleState__DocuAssignment_2 : ( ruleDocumentation ) ; |
| public final void rule__SimpleState__DocuAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10217:1: ( ( ruleDocumentation ) ) |
| // InternalFSM.g:10218:1: ( ruleDocumentation ) |
| { |
| // InternalFSM.g:10218:1: ( ruleDocumentation ) |
| // InternalFSM.g:10219:1: ruleDocumentation |
| { |
| before(grammarAccess.getSimpleStateAccess().getDocuDocumentationParserRuleCall_2_0()); |
| pushFollow(FOLLOW_2); |
| ruleDocumentation(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSimpleStateAccess().getDocuDocumentationParserRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__DocuAssignment_2" |
| |
| |
| // $ANTLR start "rule__SimpleState__EntryCodeAssignment_3_1_1" |
| // InternalFSM.g:10228:1: rule__SimpleState__EntryCodeAssignment_3_1_1 : ( ruleDetailCode ) ; |
| public final void rule__SimpleState__EntryCodeAssignment_3_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10232:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10233:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10233:1: ( ruleDetailCode ) |
| // InternalFSM.g:10234:1: ruleDetailCode |
| { |
| before(grammarAccess.getSimpleStateAccess().getEntryCodeDetailCodeParserRuleCall_3_1_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSimpleStateAccess().getEntryCodeDetailCodeParserRuleCall_3_1_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__EntryCodeAssignment_3_1_1" |
| |
| |
| // $ANTLR start "rule__SimpleState__ExitCodeAssignment_3_2_1" |
| // InternalFSM.g:10243:1: rule__SimpleState__ExitCodeAssignment_3_2_1 : ( ruleDetailCode ) ; |
| public final void rule__SimpleState__ExitCodeAssignment_3_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10247:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10248:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10248:1: ( ruleDetailCode ) |
| // InternalFSM.g:10249:1: ruleDetailCode |
| { |
| before(grammarAccess.getSimpleStateAccess().getExitCodeDetailCodeParserRuleCall_3_2_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSimpleStateAccess().getExitCodeDetailCodeParserRuleCall_3_2_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__ExitCodeAssignment_3_2_1" |
| |
| |
| // $ANTLR start "rule__SimpleState__DoCodeAssignment_3_3_1" |
| // InternalFSM.g:10258:1: rule__SimpleState__DoCodeAssignment_3_3_1 : ( ruleDetailCode ) ; |
| public final void rule__SimpleState__DoCodeAssignment_3_3_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10262:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10263:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10263:1: ( ruleDetailCode ) |
| // InternalFSM.g:10264:1: ruleDetailCode |
| { |
| before(grammarAccess.getSimpleStateAccess().getDoCodeDetailCodeParserRuleCall_3_3_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSimpleStateAccess().getDoCodeDetailCodeParserRuleCall_3_3_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__DoCodeAssignment_3_3_1" |
| |
| |
| // $ANTLR start "rule__SimpleState__SubgraphAssignment_3_4_1" |
| // InternalFSM.g:10273:1: rule__SimpleState__SubgraphAssignment_3_4_1 : ( ruleStateGraph ) ; |
| public final void rule__SimpleState__SubgraphAssignment_3_4_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10277:1: ( ( ruleStateGraph ) ) |
| // InternalFSM.g:10278:1: ( ruleStateGraph ) |
| { |
| // InternalFSM.g:10278:1: ( ruleStateGraph ) |
| // InternalFSM.g:10279:1: ruleStateGraph |
| { |
| before(grammarAccess.getSimpleStateAccess().getSubgraphStateGraphParserRuleCall_3_4_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleStateGraph(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSimpleStateAccess().getSubgraphStateGraphParserRuleCall_3_4_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleState__SubgraphAssignment_3_4_1" |
| |
| |
| // $ANTLR start "rule__RefinedState__TargetAssignment_1" |
| // InternalFSM.g:10288:1: rule__RefinedState__TargetAssignment_1 : ( ( ruleFQN ) ) ; |
| public final void rule__RefinedState__TargetAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10292:1: ( ( ( ruleFQN ) ) ) |
| // InternalFSM.g:10293:1: ( ( ruleFQN ) ) |
| { |
| // InternalFSM.g:10293:1: ( ( ruleFQN ) ) |
| // InternalFSM.g:10294:1: ( ruleFQN ) |
| { |
| before(grammarAccess.getRefinedStateAccess().getTargetStateCrossReference_1_0()); |
| // InternalFSM.g:10295:1: ( ruleFQN ) |
| // InternalFSM.g:10296:1: ruleFQN |
| { |
| before(grammarAccess.getRefinedStateAccess().getTargetStateFQNParserRuleCall_1_0_1()); |
| pushFollow(FOLLOW_2); |
| ruleFQN(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedStateAccess().getTargetStateFQNParserRuleCall_1_0_1()); |
| |
| } |
| |
| after(grammarAccess.getRefinedStateAccess().getTargetStateCrossReference_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__TargetAssignment_1" |
| |
| |
| // $ANTLR start "rule__RefinedState__DocuAssignment_2" |
| // InternalFSM.g:10307:1: rule__RefinedState__DocuAssignment_2 : ( ruleDocumentation ) ; |
| public final void rule__RefinedState__DocuAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10311:1: ( ( ruleDocumentation ) ) |
| // InternalFSM.g:10312:1: ( ruleDocumentation ) |
| { |
| // InternalFSM.g:10312:1: ( ruleDocumentation ) |
| // InternalFSM.g:10313:1: ruleDocumentation |
| { |
| before(grammarAccess.getRefinedStateAccess().getDocuDocumentationParserRuleCall_2_0()); |
| pushFollow(FOLLOW_2); |
| ruleDocumentation(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedStateAccess().getDocuDocumentationParserRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__DocuAssignment_2" |
| |
| |
| // $ANTLR start "rule__RefinedState__EntryCodeAssignment_4_1" |
| // InternalFSM.g:10322:1: rule__RefinedState__EntryCodeAssignment_4_1 : ( ruleDetailCode ) ; |
| public final void rule__RefinedState__EntryCodeAssignment_4_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10326:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10327:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10327:1: ( ruleDetailCode ) |
| // InternalFSM.g:10328:1: ruleDetailCode |
| { |
| before(grammarAccess.getRefinedStateAccess().getEntryCodeDetailCodeParserRuleCall_4_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedStateAccess().getEntryCodeDetailCodeParserRuleCall_4_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__EntryCodeAssignment_4_1" |
| |
| |
| // $ANTLR start "rule__RefinedState__ExitCodeAssignment_5_1" |
| // InternalFSM.g:10337:1: rule__RefinedState__ExitCodeAssignment_5_1 : ( ruleDetailCode ) ; |
| public final void rule__RefinedState__ExitCodeAssignment_5_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10341:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10342:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10342:1: ( ruleDetailCode ) |
| // InternalFSM.g:10343:1: ruleDetailCode |
| { |
| before(grammarAccess.getRefinedStateAccess().getExitCodeDetailCodeParserRuleCall_5_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedStateAccess().getExitCodeDetailCodeParserRuleCall_5_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__ExitCodeAssignment_5_1" |
| |
| |
| // $ANTLR start "rule__RefinedState__DoCodeAssignment_6_1" |
| // InternalFSM.g:10352:1: rule__RefinedState__DoCodeAssignment_6_1 : ( ruleDetailCode ) ; |
| public final void rule__RefinedState__DoCodeAssignment_6_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10356:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10357:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10357:1: ( ruleDetailCode ) |
| // InternalFSM.g:10358:1: ruleDetailCode |
| { |
| before(grammarAccess.getRefinedStateAccess().getDoCodeDetailCodeParserRuleCall_6_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedStateAccess().getDoCodeDetailCodeParserRuleCall_6_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__DoCodeAssignment_6_1" |
| |
| |
| // $ANTLR start "rule__RefinedState__SubgraphAssignment_7_1" |
| // InternalFSM.g:10367:1: rule__RefinedState__SubgraphAssignment_7_1 : ( ruleStateGraph ) ; |
| public final void rule__RefinedState__SubgraphAssignment_7_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10371:1: ( ( ruleStateGraph ) ) |
| // InternalFSM.g:10372:1: ( ruleStateGraph ) |
| { |
| // InternalFSM.g:10372:1: ( ruleStateGraph ) |
| // InternalFSM.g:10373:1: ruleStateGraph |
| { |
| before(grammarAccess.getRefinedStateAccess().getSubgraphStateGraphParserRuleCall_7_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleStateGraph(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedStateAccess().getSubgraphStateGraphParserRuleCall_7_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedState__SubgraphAssignment_7_1" |
| |
| |
| // $ANTLR start "rule__DetailCode__UsedAssignment_1" |
| // InternalFSM.g:10382:1: rule__DetailCode__UsedAssignment_1 : ( ( '{' ) ) ; |
| public final void rule__DetailCode__UsedAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10386:1: ( ( ( '{' ) ) ) |
| // InternalFSM.g:10387:1: ( ( '{' ) ) |
| { |
| // InternalFSM.g:10387:1: ( ( '{' ) ) |
| // InternalFSM.g:10388:1: ( '{' ) |
| { |
| before(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0()); |
| // InternalFSM.g:10389:1: ( '{' ) |
| // InternalFSM.g:10390:1: '{' |
| { |
| before(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0()); |
| match(input,28,FOLLOW_2); |
| after(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0()); |
| |
| } |
| |
| after(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DetailCode__UsedAssignment_1" |
| |
| |
| // $ANTLR start "rule__DetailCode__LinesAssignment_2" |
| // InternalFSM.g:10405:1: rule__DetailCode__LinesAssignment_2 : ( RULE_STRING ) ; |
| public final void rule__DetailCode__LinesAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10409:1: ( ( RULE_STRING ) ) |
| // InternalFSM.g:10410:1: ( RULE_STRING ) |
| { |
| // InternalFSM.g:10410:1: ( RULE_STRING ) |
| // InternalFSM.g:10411:1: RULE_STRING |
| { |
| before(grammarAccess.getDetailCodeAccess().getLinesSTRINGTerminalRuleCall_2_0()); |
| match(input,RULE_STRING,FOLLOW_2); |
| after(grammarAccess.getDetailCodeAccess().getLinesSTRINGTerminalRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__DetailCode__LinesAssignment_2" |
| |
| |
| // $ANTLR start "rule__TransitionPoint__HandlerAssignment_0" |
| // InternalFSM.g:10420:1: rule__TransitionPoint__HandlerAssignment_0 : ( ( 'handler' ) ) ; |
| public final void rule__TransitionPoint__HandlerAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10424:1: ( ( ( 'handler' ) ) ) |
| // InternalFSM.g:10425:1: ( ( 'handler' ) ) |
| { |
| // InternalFSM.g:10425:1: ( ( 'handler' ) ) |
| // InternalFSM.g:10426:1: ( 'handler' ) |
| { |
| before(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); |
| // InternalFSM.g:10427:1: ( 'handler' ) |
| // InternalFSM.g:10428:1: 'handler' |
| { |
| before(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); |
| match(input,69,FOLLOW_2); |
| after(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); |
| |
| } |
| |
| after(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TransitionPoint__HandlerAssignment_0" |
| |
| |
| // $ANTLR start "rule__TransitionPoint__NameAssignment_2" |
| // InternalFSM.g:10443:1: rule__TransitionPoint__NameAssignment_2 : ( RULE_ID ) ; |
| public final void rule__TransitionPoint__NameAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10447:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10448:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10448:1: ( RULE_ID ) |
| // InternalFSM.g:10449:1: RULE_ID |
| { |
| before(grammarAccess.getTransitionPointAccess().getNameIDTerminalRuleCall_2_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getTransitionPointAccess().getNameIDTerminalRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TransitionPoint__NameAssignment_2" |
| |
| |
| // $ANTLR start "rule__EntryPoint__NameAssignment_1" |
| // InternalFSM.g:10458:1: rule__EntryPoint__NameAssignment_1 : ( RULE_ID ) ; |
| public final void rule__EntryPoint__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10462:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10463:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10463:1: ( RULE_ID ) |
| // InternalFSM.g:10464:1: RULE_ID |
| { |
| before(grammarAccess.getEntryPointAccess().getNameIDTerminalRuleCall_1_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getEntryPointAccess().getNameIDTerminalRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EntryPoint__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__ExitPoint__NameAssignment_1" |
| // InternalFSM.g:10473:1: rule__ExitPoint__NameAssignment_1 : ( RULE_ID ) ; |
| public final void rule__ExitPoint__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10477:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10478:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10478:1: ( RULE_ID ) |
| // InternalFSM.g:10479:1: RULE_ID |
| { |
| before(grammarAccess.getExitPointAccess().getNameIDTerminalRuleCall_1_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getExitPointAccess().getNameIDTerminalRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ExitPoint__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__ChoicePoint__NameAssignment_1" |
| // InternalFSM.g:10488:1: rule__ChoicePoint__NameAssignment_1 : ( RULE_ID ) ; |
| public final void rule__ChoicePoint__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10492:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10493:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10493:1: ( RULE_ID ) |
| // InternalFSM.g:10494:1: RULE_ID |
| { |
| before(grammarAccess.getChoicePointAccess().getNameIDTerminalRuleCall_1_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getChoicePointAccess().getNameIDTerminalRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicePoint__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__ChoicePoint__DocuAssignment_2" |
| // InternalFSM.g:10503:1: rule__ChoicePoint__DocuAssignment_2 : ( ruleDocumentation ) ; |
| public final void rule__ChoicePoint__DocuAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10507:1: ( ( ruleDocumentation ) ) |
| // InternalFSM.g:10508:1: ( ruleDocumentation ) |
| { |
| // InternalFSM.g:10508:1: ( ruleDocumentation ) |
| // InternalFSM.g:10509:1: ruleDocumentation |
| { |
| before(grammarAccess.getChoicePointAccess().getDocuDocumentationParserRuleCall_2_0()); |
| pushFollow(FOLLOW_2); |
| ruleDocumentation(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getChoicePointAccess().getDocuDocumentationParserRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicePoint__DocuAssignment_2" |
| |
| |
| // $ANTLR start "rule__InitialTransition__NameAssignment_1" |
| // InternalFSM.g:10518:1: rule__InitialTransition__NameAssignment_1 : ( RULE_ID ) ; |
| public final void rule__InitialTransition__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10522:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10523:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10523:1: ( RULE_ID ) |
| // InternalFSM.g:10524:1: RULE_ID |
| { |
| before(grammarAccess.getInitialTransitionAccess().getNameIDTerminalRuleCall_1_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getInitialTransitionAccess().getNameIDTerminalRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__InitialTransition__ToAssignment_5" |
| // InternalFSM.g:10533:1: rule__InitialTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ; |
| public final void rule__InitialTransition__ToAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10537:1: ( ( ruleTransitionTerminal ) ) |
| // InternalFSM.g:10538:1: ( ruleTransitionTerminal ) |
| { |
| // InternalFSM.g:10538:1: ( ruleTransitionTerminal ) |
| // InternalFSM.g:10539:1: ruleTransitionTerminal |
| { |
| before(grammarAccess.getInitialTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getInitialTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__ToAssignment_5" |
| |
| |
| // $ANTLR start "rule__InitialTransition__DocuAssignment_6" |
| // InternalFSM.g:10548:1: rule__InitialTransition__DocuAssignment_6 : ( ruleDocumentation ) ; |
| public final void rule__InitialTransition__DocuAssignment_6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10552:1: ( ( ruleDocumentation ) ) |
| // InternalFSM.g:10553:1: ( ruleDocumentation ) |
| { |
| // InternalFSM.g:10553:1: ( ruleDocumentation ) |
| // InternalFSM.g:10554:1: ruleDocumentation |
| { |
| before(grammarAccess.getInitialTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); |
| pushFollow(FOLLOW_2); |
| ruleDocumentation(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getInitialTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__DocuAssignment_6" |
| |
| |
| // $ANTLR start "rule__InitialTransition__ActionAssignment_7_1_1" |
| // InternalFSM.g:10563:1: rule__InitialTransition__ActionAssignment_7_1_1 : ( ruleDetailCode ) ; |
| public final void rule__InitialTransition__ActionAssignment_7_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10567:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10568:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10568:1: ( ruleDetailCode ) |
| // InternalFSM.g:10569:1: ruleDetailCode |
| { |
| before(grammarAccess.getInitialTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getInitialTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InitialTransition__ActionAssignment_7_1_1" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__NameAssignment_1" |
| // InternalFSM.g:10578:1: rule__ContinuationTransition__NameAssignment_1 : ( RULE_ID ) ; |
| public final void rule__ContinuationTransition__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10582:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10583:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10583:1: ( RULE_ID ) |
| // InternalFSM.g:10584:1: RULE_ID |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getNameIDTerminalRuleCall_1_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getContinuationTransitionAccess().getNameIDTerminalRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__FromAssignment_3" |
| // InternalFSM.g:10593:1: rule__ContinuationTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ; |
| public final void rule__ContinuationTransition__FromAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10597:1: ( ( ruleTransitionTerminal ) ) |
| // InternalFSM.g:10598:1: ( ruleTransitionTerminal ) |
| { |
| // InternalFSM.g:10598:1: ( ruleTransitionTerminal ) |
| // InternalFSM.g:10599:1: ruleTransitionTerminal |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getContinuationTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__FromAssignment_3" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__ToAssignment_5" |
| // InternalFSM.g:10608:1: rule__ContinuationTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ; |
| public final void rule__ContinuationTransition__ToAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10612:1: ( ( ruleTransitionTerminal ) ) |
| // InternalFSM.g:10613:1: ( ruleTransitionTerminal ) |
| { |
| // InternalFSM.g:10613:1: ( ruleTransitionTerminal ) |
| // InternalFSM.g:10614:1: ruleTransitionTerminal |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getContinuationTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__ToAssignment_5" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__DocuAssignment_6" |
| // InternalFSM.g:10623:1: rule__ContinuationTransition__DocuAssignment_6 : ( ruleDocumentation ) ; |
| public final void rule__ContinuationTransition__DocuAssignment_6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10627:1: ( ( ruleDocumentation ) ) |
| // InternalFSM.g:10628:1: ( ruleDocumentation ) |
| { |
| // InternalFSM.g:10628:1: ( ruleDocumentation ) |
| // InternalFSM.g:10629:1: ruleDocumentation |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); |
| pushFollow(FOLLOW_2); |
| ruleDocumentation(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getContinuationTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__DocuAssignment_6" |
| |
| |
| // $ANTLR start "rule__ContinuationTransition__ActionAssignment_7_1_1" |
| // InternalFSM.g:10638:1: rule__ContinuationTransition__ActionAssignment_7_1_1 : ( ruleDetailCode ) ; |
| public final void rule__ContinuationTransition__ActionAssignment_7_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10642:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10643:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10643:1: ( ruleDetailCode ) |
| // InternalFSM.g:10644:1: ruleDetailCode |
| { |
| before(grammarAccess.getContinuationTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getContinuationTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ContinuationTransition__ActionAssignment_7_1_1" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__NameAssignment_1" |
| // InternalFSM.g:10653:1: rule__TriggeredTransition__NameAssignment_1 : ( RULE_ID ) ; |
| public final void rule__TriggeredTransition__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10657:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10658:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10658:1: ( RULE_ID ) |
| // InternalFSM.g:10659:1: RULE_ID |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getNameIDTerminalRuleCall_1_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getTriggeredTransitionAccess().getNameIDTerminalRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__FromAssignment_3" |
| // InternalFSM.g:10668:1: rule__TriggeredTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ; |
| public final void rule__TriggeredTransition__FromAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10672:1: ( ( ruleTransitionTerminal ) ) |
| // InternalFSM.g:10673:1: ( ruleTransitionTerminal ) |
| { |
| // InternalFSM.g:10673:1: ( ruleTransitionTerminal ) |
| // InternalFSM.g:10674:1: ruleTransitionTerminal |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__FromAssignment_3" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__ToAssignment_5" |
| // InternalFSM.g:10683:1: rule__TriggeredTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ; |
| public final void rule__TriggeredTransition__ToAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10687:1: ( ( ruleTransitionTerminal ) ) |
| // InternalFSM.g:10688:1: ( ruleTransitionTerminal ) |
| { |
| // InternalFSM.g:10688:1: ( ruleTransitionTerminal ) |
| // InternalFSM.g:10689:1: ruleTransitionTerminal |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__ToAssignment_5" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__DocuAssignment_6" |
| // InternalFSM.g:10698:1: rule__TriggeredTransition__DocuAssignment_6 : ( ruleDocumentation ) ; |
| public final void rule__TriggeredTransition__DocuAssignment_6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10702:1: ( ( ruleDocumentation ) ) |
| // InternalFSM.g:10703:1: ( ruleDocumentation ) |
| { |
| // InternalFSM.g:10703:1: ( ruleDocumentation ) |
| // InternalFSM.g:10704:1: ruleDocumentation |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); |
| pushFollow(FOLLOW_2); |
| ruleDocumentation(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__DocuAssignment_6" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__TriggersAssignment_10" |
| // InternalFSM.g:10713:1: rule__TriggeredTransition__TriggersAssignment_10 : ( ruleTrigger ) ; |
| public final void rule__TriggeredTransition__TriggersAssignment_10() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10717:1: ( ( ruleTrigger ) ) |
| // InternalFSM.g:10718:1: ( ruleTrigger ) |
| { |
| // InternalFSM.g:10718:1: ( ruleTrigger ) |
| // InternalFSM.g:10719:1: ruleTrigger |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_10_0()); |
| pushFollow(FOLLOW_2); |
| ruleTrigger(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_10_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__TriggersAssignment_10" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__TriggersAssignment_11_1" |
| // InternalFSM.g:10728:1: rule__TriggeredTransition__TriggersAssignment_11_1 : ( ruleTrigger ) ; |
| public final void rule__TriggeredTransition__TriggersAssignment_11_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10732:1: ( ( ruleTrigger ) ) |
| // InternalFSM.g:10733:1: ( ruleTrigger ) |
| { |
| // InternalFSM.g:10733:1: ( ruleTrigger ) |
| // InternalFSM.g:10734:1: ruleTrigger |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_11_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleTrigger(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_11_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__TriggersAssignment_11_1" |
| |
| |
| // $ANTLR start "rule__TriggeredTransition__ActionAssignment_13_1" |
| // InternalFSM.g:10743:1: rule__TriggeredTransition__ActionAssignment_13_1 : ( ruleDetailCode ) ; |
| public final void rule__TriggeredTransition__ActionAssignment_13_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10747:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10748:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10748:1: ( ruleDetailCode ) |
| // InternalFSM.g:10749:1: ruleDetailCode |
| { |
| before(grammarAccess.getTriggeredTransitionAccess().getActionDetailCodeParserRuleCall_13_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggeredTransitionAccess().getActionDetailCodeParserRuleCall_13_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TriggeredTransition__ActionAssignment_13_1" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__NameAssignment_1" |
| // InternalFSM.g:10758:1: rule__GuardedTransition__NameAssignment_1 : ( RULE_ID ) ; |
| public final void rule__GuardedTransition__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10762:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10763:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10763:1: ( RULE_ID ) |
| // InternalFSM.g:10764:1: RULE_ID |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getNameIDTerminalRuleCall_1_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getGuardedTransitionAccess().getNameIDTerminalRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__FromAssignment_3" |
| // InternalFSM.g:10773:1: rule__GuardedTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ; |
| public final void rule__GuardedTransition__FromAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10777:1: ( ( ruleTransitionTerminal ) ) |
| // InternalFSM.g:10778:1: ( ruleTransitionTerminal ) |
| { |
| // InternalFSM.g:10778:1: ( ruleTransitionTerminal ) |
| // InternalFSM.g:10779:1: ruleTransitionTerminal |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getGuardedTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__FromAssignment_3" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__ToAssignment_5" |
| // InternalFSM.g:10788:1: rule__GuardedTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ; |
| public final void rule__GuardedTransition__ToAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10792:1: ( ( ruleTransitionTerminal ) ) |
| // InternalFSM.g:10793:1: ( ruleTransitionTerminal ) |
| { |
| // InternalFSM.g:10793:1: ( ruleTransitionTerminal ) |
| // InternalFSM.g:10794:1: ruleTransitionTerminal |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getGuardedTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__ToAssignment_5" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__DocuAssignment_6" |
| // InternalFSM.g:10803:1: rule__GuardedTransition__DocuAssignment_6 : ( ruleDocumentation ) ; |
| public final void rule__GuardedTransition__DocuAssignment_6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10807:1: ( ( ruleDocumentation ) ) |
| // InternalFSM.g:10808:1: ( ruleDocumentation ) |
| { |
| // InternalFSM.g:10808:1: ( ruleDocumentation ) |
| // InternalFSM.g:10809:1: ruleDocumentation |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); |
| pushFollow(FOLLOW_2); |
| ruleDocumentation(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getGuardedTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__DocuAssignment_6" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__GuardAssignment_9" |
| // InternalFSM.g:10818:1: rule__GuardedTransition__GuardAssignment_9 : ( ruleDetailCode ) ; |
| public final void rule__GuardedTransition__GuardAssignment_9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10822:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10823:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10823:1: ( ruleDetailCode ) |
| // InternalFSM.g:10824:1: ruleDetailCode |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getGuardDetailCodeParserRuleCall_9_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getGuardedTransitionAccess().getGuardDetailCodeParserRuleCall_9_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__GuardAssignment_9" |
| |
| |
| // $ANTLR start "rule__GuardedTransition__ActionAssignment_10_1" |
| // InternalFSM.g:10833:1: rule__GuardedTransition__ActionAssignment_10_1 : ( ruleDetailCode ) ; |
| public final void rule__GuardedTransition__ActionAssignment_10_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10837:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10838:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10838:1: ( ruleDetailCode ) |
| // InternalFSM.g:10839:1: ruleDetailCode |
| { |
| before(grammarAccess.getGuardedTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getGuardedTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__GuardedTransition__ActionAssignment_10_1" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__NameAssignment_1" |
| // InternalFSM.g:10848:1: rule__CPBranchTransition__NameAssignment_1 : ( RULE_ID ) ; |
| public final void rule__CPBranchTransition__NameAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10852:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10853:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:10853:1: ( RULE_ID ) |
| // InternalFSM.g:10854:1: RULE_ID |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getNameIDTerminalRuleCall_1_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getCPBranchTransitionAccess().getNameIDTerminalRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__NameAssignment_1" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__FromAssignment_3" |
| // InternalFSM.g:10863:1: rule__CPBranchTransition__FromAssignment_3 : ( ruleTransitionTerminal ) ; |
| public final void rule__CPBranchTransition__FromAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10867:1: ( ( ruleTransitionTerminal ) ) |
| // InternalFSM.g:10868:1: ( ruleTransitionTerminal ) |
| { |
| // InternalFSM.g:10868:1: ( ruleTransitionTerminal ) |
| // InternalFSM.g:10869:1: ruleTransitionTerminal |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__FromAssignment_3" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__ToAssignment_5" |
| // InternalFSM.g:10878:1: rule__CPBranchTransition__ToAssignment_5 : ( ruleTransitionTerminal ) ; |
| public final void rule__CPBranchTransition__ToAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10882:1: ( ( ruleTransitionTerminal ) ) |
| // InternalFSM.g:10883:1: ( ruleTransitionTerminal ) |
| { |
| // InternalFSM.g:10883:1: ( ruleTransitionTerminal ) |
| // InternalFSM.g:10884:1: ruleTransitionTerminal |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); |
| pushFollow(FOLLOW_2); |
| ruleTransitionTerminal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__ToAssignment_5" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__DocuAssignment_6" |
| // InternalFSM.g:10893:1: rule__CPBranchTransition__DocuAssignment_6 : ( ruleDocumentation ) ; |
| public final void rule__CPBranchTransition__DocuAssignment_6() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10897:1: ( ( ruleDocumentation ) ) |
| // InternalFSM.g:10898:1: ( ruleDocumentation ) |
| { |
| // InternalFSM.g:10898:1: ( ruleDocumentation ) |
| // InternalFSM.g:10899:1: ruleDocumentation |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); |
| pushFollow(FOLLOW_2); |
| ruleDocumentation(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__DocuAssignment_6" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__ConditionAssignment_9" |
| // InternalFSM.g:10908:1: rule__CPBranchTransition__ConditionAssignment_9 : ( ruleDetailCode ) ; |
| public final void rule__CPBranchTransition__ConditionAssignment_9() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10912:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10913:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10913:1: ( ruleDetailCode ) |
| // InternalFSM.g:10914:1: ruleDetailCode |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getConditionDetailCodeParserRuleCall_9_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getConditionDetailCodeParserRuleCall_9_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__ConditionAssignment_9" |
| |
| |
| // $ANTLR start "rule__CPBranchTransition__ActionAssignment_10_1" |
| // InternalFSM.g:10923:1: rule__CPBranchTransition__ActionAssignment_10_1 : ( ruleDetailCode ) ; |
| public final void rule__CPBranchTransition__ActionAssignment_10_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10927:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10928:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10928:1: ( ruleDetailCode ) |
| // InternalFSM.g:10929:1: ruleDetailCode |
| { |
| before(grammarAccess.getCPBranchTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getCPBranchTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__CPBranchTransition__ActionAssignment_10_1" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__TargetAssignment_1" |
| // InternalFSM.g:10938:1: rule__RefinedTransition__TargetAssignment_1 : ( ( ruleFQN ) ) ; |
| public final void rule__RefinedTransition__TargetAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10942:1: ( ( ( ruleFQN ) ) ) |
| // InternalFSM.g:10943:1: ( ( ruleFQN ) ) |
| { |
| // InternalFSM.g:10943:1: ( ( ruleFQN ) ) |
| // InternalFSM.g:10944:1: ( ruleFQN ) |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getTargetTransitionCrossReference_1_0()); |
| // InternalFSM.g:10945:1: ( ruleFQN ) |
| // InternalFSM.g:10946:1: ruleFQN |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getTargetTransitionFQNParserRuleCall_1_0_1()); |
| pushFollow(FOLLOW_2); |
| ruleFQN(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedTransitionAccess().getTargetTransitionFQNParserRuleCall_1_0_1()); |
| |
| } |
| |
| after(grammarAccess.getRefinedTransitionAccess().getTargetTransitionCrossReference_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__TargetAssignment_1" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__DocuAssignment_2" |
| // InternalFSM.g:10957:1: rule__RefinedTransition__DocuAssignment_2 : ( ruleDocumentation ) ; |
| public final void rule__RefinedTransition__DocuAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10961:1: ( ( ruleDocumentation ) ) |
| // InternalFSM.g:10962:1: ( ruleDocumentation ) |
| { |
| // InternalFSM.g:10962:1: ( ruleDocumentation ) |
| // InternalFSM.g:10963:1: ruleDocumentation |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getDocuDocumentationParserRuleCall_2_0()); |
| pushFollow(FOLLOW_2); |
| ruleDocumentation(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedTransitionAccess().getDocuDocumentationParserRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__DocuAssignment_2" |
| |
| |
| // $ANTLR start "rule__RefinedTransition__ActionAssignment_5" |
| // InternalFSM.g:10972:1: rule__RefinedTransition__ActionAssignment_5 : ( ruleDetailCode ) ; |
| public final void rule__RefinedTransition__ActionAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10976:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:10977:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:10977:1: ( ruleDetailCode ) |
| // InternalFSM.g:10978:1: ruleDetailCode |
| { |
| before(grammarAccess.getRefinedTransitionAccess().getActionDetailCodeParserRuleCall_5_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRefinedTransitionAccess().getActionDetailCodeParserRuleCall_5_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RefinedTransition__ActionAssignment_5" |
| |
| |
| // $ANTLR start "rule__StateTerminal__StateAssignment" |
| // InternalFSM.g:10987:1: rule__StateTerminal__StateAssignment : ( ( RULE_ID ) ) ; |
| public final void rule__StateTerminal__StateAssignment() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:10991:1: ( ( ( RULE_ID ) ) ) |
| // InternalFSM.g:10992:1: ( ( RULE_ID ) ) |
| { |
| // InternalFSM.g:10992:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:10993:1: ( RULE_ID ) |
| { |
| before(grammarAccess.getStateTerminalAccess().getStateStateCrossReference_0()); |
| // InternalFSM.g:10994:1: ( RULE_ID ) |
| // InternalFSM.g:10995:1: RULE_ID |
| { |
| before(grammarAccess.getStateTerminalAccess().getStateStateIDTerminalRuleCall_0_1()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getStateTerminalAccess().getStateStateIDTerminalRuleCall_0_1()); |
| |
| } |
| |
| after(grammarAccess.getStateTerminalAccess().getStateStateCrossReference_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StateTerminal__StateAssignment" |
| |
| |
| // $ANTLR start "rule__TrPointTerminal__TrPointAssignment_1" |
| // InternalFSM.g:11006:1: rule__TrPointTerminal__TrPointAssignment_1 : ( ( RULE_ID ) ) ; |
| public final void rule__TrPointTerminal__TrPointAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11010:1: ( ( ( RULE_ID ) ) ) |
| // InternalFSM.g:11011:1: ( ( RULE_ID ) ) |
| { |
| // InternalFSM.g:11011:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11012:1: ( RULE_ID ) |
| { |
| before(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointCrossReference_1_0()); |
| // InternalFSM.g:11013:1: ( RULE_ID ) |
| // InternalFSM.g:11014:1: RULE_ID |
| { |
| before(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_1_0_1()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_1_0_1()); |
| |
| } |
| |
| after(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointCrossReference_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__TrPointTerminal__TrPointAssignment_1" |
| |
| |
| // $ANTLR start "rule__SubStateTrPointTerminal__TrPointAssignment_0" |
| // InternalFSM.g:11025:1: rule__SubStateTrPointTerminal__TrPointAssignment_0 : ( ( RULE_ID ) ) ; |
| public final void rule__SubStateTrPointTerminal__TrPointAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11029:1: ( ( ( RULE_ID ) ) ) |
| // InternalFSM.g:11030:1: ( ( RULE_ID ) ) |
| { |
| // InternalFSM.g:11030:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11031:1: ( RULE_ID ) |
| { |
| before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointCrossReference_0_0()); |
| // InternalFSM.g:11032:1: ( RULE_ID ) |
| // InternalFSM.g:11033:1: RULE_ID |
| { |
| before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_0_0_1()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_0_0_1()); |
| |
| } |
| |
| after(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointCrossReference_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SubStateTrPointTerminal__TrPointAssignment_0" |
| |
| |
| // $ANTLR start "rule__SubStateTrPointTerminal__StateAssignment_2" |
| // InternalFSM.g:11044:1: rule__SubStateTrPointTerminal__StateAssignment_2 : ( ( RULE_ID ) ) ; |
| public final void rule__SubStateTrPointTerminal__StateAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11048:1: ( ( ( RULE_ID ) ) ) |
| // InternalFSM.g:11049:1: ( ( RULE_ID ) ) |
| { |
| // InternalFSM.g:11049:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11050:1: ( RULE_ID ) |
| { |
| before(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateCrossReference_2_0()); |
| // InternalFSM.g:11051:1: ( RULE_ID ) |
| // InternalFSM.g:11052:1: RULE_ID |
| { |
| before(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateIDTerminalRuleCall_2_0_1()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateIDTerminalRuleCall_2_0_1()); |
| |
| } |
| |
| after(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateCrossReference_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SubStateTrPointTerminal__StateAssignment_2" |
| |
| |
| // $ANTLR start "rule__ChoicepointTerminal__CpAssignment_1" |
| // InternalFSM.g:11063:1: rule__ChoicepointTerminal__CpAssignment_1 : ( ( RULE_ID ) ) ; |
| public final void rule__ChoicepointTerminal__CpAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11067:1: ( ( ( RULE_ID ) ) ) |
| // InternalFSM.g:11068:1: ( ( RULE_ID ) ) |
| { |
| // InternalFSM.g:11068:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11069:1: ( RULE_ID ) |
| { |
| before(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointCrossReference_1_0()); |
| // InternalFSM.g:11070:1: ( RULE_ID ) |
| // InternalFSM.g:11071:1: RULE_ID |
| { |
| before(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointIDTerminalRuleCall_1_0_1()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointIDTerminalRuleCall_1_0_1()); |
| |
| } |
| |
| after(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointCrossReference_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__ChoicepointTerminal__CpAssignment_1" |
| |
| |
| // $ANTLR start "rule__Trigger__MsgFromIfPairsAssignment_1" |
| // InternalFSM.g:11082:1: rule__Trigger__MsgFromIfPairsAssignment_1 : ( ruleMessageFromIf ) ; |
| public final void rule__Trigger__MsgFromIfPairsAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11086:1: ( ( ruleMessageFromIf ) ) |
| // InternalFSM.g:11087:1: ( ruleMessageFromIf ) |
| { |
| // InternalFSM.g:11087:1: ( ruleMessageFromIf ) |
| // InternalFSM.g:11088:1: ruleMessageFromIf |
| { |
| before(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleMessageFromIf(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__MsgFromIfPairsAssignment_1" |
| |
| |
| // $ANTLR start "rule__Trigger__MsgFromIfPairsAssignment_2_1" |
| // InternalFSM.g:11097:1: rule__Trigger__MsgFromIfPairsAssignment_2_1 : ( ruleMessageFromIf ) ; |
| public final void rule__Trigger__MsgFromIfPairsAssignment_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11101:1: ( ( ruleMessageFromIf ) ) |
| // InternalFSM.g:11102:1: ( ruleMessageFromIf ) |
| { |
| // InternalFSM.g:11102:1: ( ruleMessageFromIf ) |
| // InternalFSM.g:11103:1: ruleMessageFromIf |
| { |
| before(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_2_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleMessageFromIf(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_2_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__MsgFromIfPairsAssignment_2_1" |
| |
| |
| // $ANTLR start "rule__Trigger__GuardAssignment_3" |
| // InternalFSM.g:11112:1: rule__Trigger__GuardAssignment_3 : ( ruleGuard ) ; |
| public final void rule__Trigger__GuardAssignment_3() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11116:1: ( ( ruleGuard ) ) |
| // InternalFSM.g:11117:1: ( ruleGuard ) |
| { |
| // InternalFSM.g:11117:1: ( ruleGuard ) |
| // InternalFSM.g:11118:1: ruleGuard |
| { |
| before(grammarAccess.getTriggerAccess().getGuardGuardParserRuleCall_3_0()); |
| pushFollow(FOLLOW_2); |
| ruleGuard(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getTriggerAccess().getGuardGuardParserRuleCall_3_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Trigger__GuardAssignment_3" |
| |
| |
| // $ANTLR start "rule__MessageFromIf__MessageAssignment_0" |
| // InternalFSM.g:11127:1: rule__MessageFromIf__MessageAssignment_0 : ( ( RULE_ID ) ) ; |
| public final void rule__MessageFromIf__MessageAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11131:1: ( ( ( RULE_ID ) ) ) |
| // InternalFSM.g:11132:1: ( ( RULE_ID ) ) |
| { |
| // InternalFSM.g:11132:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11133:1: ( RULE_ID ) |
| { |
| before(grammarAccess.getMessageFromIfAccess().getMessageEObjectCrossReference_0_0()); |
| // InternalFSM.g:11134:1: ( RULE_ID ) |
| // InternalFSM.g:11135:1: RULE_ID |
| { |
| before(grammarAccess.getMessageFromIfAccess().getMessageEObjectIDTerminalRuleCall_0_0_1()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getMessageFromIfAccess().getMessageEObjectIDTerminalRuleCall_0_0_1()); |
| |
| } |
| |
| after(grammarAccess.getMessageFromIfAccess().getMessageEObjectCrossReference_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MessageFromIf__MessageAssignment_0" |
| |
| |
| // $ANTLR start "rule__MessageFromIf__FromAssignment_2" |
| // InternalFSM.g:11146:1: rule__MessageFromIf__FromAssignment_2 : ( ( RULE_ID ) ) ; |
| public final void rule__MessageFromIf__FromAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11150:1: ( ( ( RULE_ID ) ) ) |
| // InternalFSM.g:11151:1: ( ( RULE_ID ) ) |
| { |
| // InternalFSM.g:11151:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11152:1: ( RULE_ID ) |
| { |
| before(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemCrossReference_2_0()); |
| // InternalFSM.g:11153:1: ( RULE_ID ) |
| // InternalFSM.g:11154:1: RULE_ID |
| { |
| before(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemIDTerminalRuleCall_2_0_1()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemIDTerminalRuleCall_2_0_1()); |
| |
| } |
| |
| after(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemCrossReference_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__MessageFromIf__FromAssignment_2" |
| |
| |
| // $ANTLR start "rule__Guard__GuardAssignment_1" |
| // InternalFSM.g:11166:1: rule__Guard__GuardAssignment_1 : ( ruleDetailCode ) ; |
| public final void rule__Guard__GuardAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11170:1: ( ( ruleDetailCode ) ) |
| // InternalFSM.g:11171:1: ( ruleDetailCode ) |
| { |
| // InternalFSM.g:11171:1: ( ruleDetailCode ) |
| // InternalFSM.g:11172:1: ruleDetailCode |
| { |
| before(grammarAccess.getGuardAccess().getGuardDetailCodeParserRuleCall_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleDetailCode(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getGuardAccess().getGuardDetailCodeParserRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Guard__GuardAssignment_1" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__MsgAssignment_2" |
| // InternalFSM.g:11182:1: rule__InSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ; |
| public final void rule__InSemanticsRule__MsgAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11186:1: ( ( ( RULE_ID ) ) ) |
| // InternalFSM.g:11187:1: ( ( RULE_ID ) ) |
| { |
| // InternalFSM.g:11187:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11188:1: ( RULE_ID ) |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); |
| // InternalFSM.g:11189:1: ( RULE_ID ) |
| // InternalFSM.g:11190:1: RULE_ID |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); |
| |
| } |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__MsgAssignment_2" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__FollowUpsAssignment_3_1_0" |
| // InternalFSM.g:11201:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_0 : ( ruleSemanticsRule ) ; |
| public final void rule__InSemanticsRule__FollowUpsAssignment_3_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11205:1: ( ( ruleSemanticsRule ) ) |
| // InternalFSM.g:11206:1: ( ruleSemanticsRule ) |
| { |
| // InternalFSM.g:11206:1: ( ruleSemanticsRule ) |
| // InternalFSM.g:11207:1: ruleSemanticsRule |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); |
| pushFollow(FOLLOW_2); |
| ruleSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__FollowUpsAssignment_3_1_0" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1" |
| // InternalFSM.g:11216:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1 : ( ruleSemanticsRule ) ; |
| public final void rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11220:1: ( ( ruleSemanticsRule ) ) |
| // InternalFSM.g:11221:1: ( ruleSemanticsRule ) |
| { |
| // InternalFSM.g:11221:1: ( ruleSemanticsRule ) |
| // InternalFSM.g:11222:1: ruleSemanticsRule |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1" |
| |
| |
| // $ANTLR start "rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1" |
| // InternalFSM.g:11231:1: rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1 : ( ruleSemanticsRule ) ; |
| public final void rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11235:1: ( ( ruleSemanticsRule ) ) |
| // InternalFSM.g:11236:1: ( ruleSemanticsRule ) |
| { |
| // InternalFSM.g:11236:1: ( ruleSemanticsRule ) |
| // InternalFSM.g:11237:1: ruleSemanticsRule |
| { |
| before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__MsgAssignment_2" |
| // InternalFSM.g:11246:1: rule__OutSemanticsRule__MsgAssignment_2 : ( ( RULE_ID ) ) ; |
| public final void rule__OutSemanticsRule__MsgAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11250:1: ( ( ( RULE_ID ) ) ) |
| // InternalFSM.g:11251:1: ( ( RULE_ID ) ) |
| { |
| // InternalFSM.g:11251:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11252:1: ( RULE_ID ) |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); |
| // InternalFSM.g:11253:1: ( RULE_ID ) |
| // InternalFSM.g:11254:1: RULE_ID |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); |
| |
| } |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__MsgAssignment_2" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__FollowUpsAssignment_3_1_0" |
| // InternalFSM.g:11265:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_0 : ( ruleSemanticsRule ) ; |
| public final void rule__OutSemanticsRule__FollowUpsAssignment_3_1_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11269:1: ( ( ruleSemanticsRule ) ) |
| // InternalFSM.g:11270:1: ( ruleSemanticsRule ) |
| { |
| // InternalFSM.g:11270:1: ( ruleSemanticsRule ) |
| // InternalFSM.g:11271:1: ruleSemanticsRule |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); |
| pushFollow(FOLLOW_2); |
| ruleSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__FollowUpsAssignment_3_1_0" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1" |
| // InternalFSM.g:11280:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1 : ( ruleSemanticsRule ) ; |
| public final void rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11284:1: ( ( ruleSemanticsRule ) ) |
| // InternalFSM.g:11285:1: ( ruleSemanticsRule ) |
| { |
| // InternalFSM.g:11285:1: ( ruleSemanticsRule ) |
| // InternalFSM.g:11286:1: ruleSemanticsRule |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1" |
| |
| |
| // $ANTLR start "rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1" |
| // InternalFSM.g:11295:1: rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1 : ( ruleSemanticsRule ) ; |
| public final void rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11299:1: ( ( ruleSemanticsRule ) ) |
| // InternalFSM.g:11300:1: ( ruleSemanticsRule ) |
| { |
| // InternalFSM.g:11300:1: ( ruleSemanticsRule ) |
| // InternalFSM.g:11301:1: ruleSemanticsRule |
| { |
| before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleSemanticsRule(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1" |
| |
| |
| // $ANTLR start "rule__KeyValue__KeyAssignment_0" |
| // InternalFSM.g:11313:1: rule__KeyValue__KeyAssignment_0 : ( RULE_ID ) ; |
| public final void rule__KeyValue__KeyAssignment_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11317:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11318:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:11318:1: ( RULE_ID ) |
| // InternalFSM.g:11319:1: RULE_ID |
| { |
| before(grammarAccess.getKeyValueAccess().getKeyIDTerminalRuleCall_0_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getKeyValueAccess().getKeyIDTerminalRuleCall_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__KeyValue__KeyAssignment_0" |
| |
| |
| // $ANTLR start "rule__KeyValue__ValueAssignment_2" |
| // InternalFSM.g:11328:1: rule__KeyValue__ValueAssignment_2 : ( ruleLiteral ) ; |
| public final void rule__KeyValue__ValueAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11332:1: ( ( ruleLiteral ) ) |
| // InternalFSM.g:11333:1: ( ruleLiteral ) |
| { |
| // InternalFSM.g:11333:1: ( ruleLiteral ) |
| // InternalFSM.g:11334:1: ruleLiteral |
| { |
| before(grammarAccess.getKeyValueAccess().getValueLiteralParserRuleCall_2_0()); |
| pushFollow(FOLLOW_2); |
| ruleLiteral(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getKeyValueAccess().getValueLiteralParserRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__KeyValue__ValueAssignment_2" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__OptionalAssignment_0_0" |
| // InternalFSM.g:11349:1: rule__SimpleAnnotationAttribute__OptionalAssignment_0_0 : ( ( 'optional' ) ) ; |
| public final void rule__SimpleAnnotationAttribute__OptionalAssignment_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11353:1: ( ( ( 'optional' ) ) ) |
| // InternalFSM.g:11354:1: ( ( 'optional' ) ) |
| { |
| // InternalFSM.g:11354:1: ( ( 'optional' ) ) |
| // InternalFSM.g:11355:1: ( 'optional' ) |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); |
| // InternalFSM.g:11356:1: ( 'optional' ) |
| // InternalFSM.g:11357:1: 'optional' |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); |
| match(input,70,FOLLOW_2); |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); |
| |
| } |
| |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__OptionalAssignment_0_0" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__NameAssignment_2" |
| // InternalFSM.g:11372:1: rule__SimpleAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ; |
| public final void rule__SimpleAnnotationAttribute__NameAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11376:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11377:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:11377:1: ( RULE_ID ) |
| // InternalFSM.g:11378:1: RULE_ID |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__NameAssignment_2" |
| |
| |
| // $ANTLR start "rule__SimpleAnnotationAttribute__TypeAssignment_4" |
| // InternalFSM.g:11387:1: rule__SimpleAnnotationAttribute__TypeAssignment_4 : ( ruleLiteralType ) ; |
| public final void rule__SimpleAnnotationAttribute__TypeAssignment_4() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11391:1: ( ( ruleLiteralType ) ) |
| // InternalFSM.g:11392:1: ( ruleLiteralType ) |
| { |
| // InternalFSM.g:11392:1: ( ruleLiteralType ) |
| // InternalFSM.g:11393:1: ruleLiteralType |
| { |
| before(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeLiteralTypeEnumRuleCall_4_0()); |
| pushFollow(FOLLOW_2); |
| ruleLiteralType(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeLiteralTypeEnumRuleCall_4_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__SimpleAnnotationAttribute__TypeAssignment_4" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__OptionalAssignment_0_0" |
| // InternalFSM.g:11402:1: rule__EnumAnnotationAttribute__OptionalAssignment_0_0 : ( ( 'optional' ) ) ; |
| public final void rule__EnumAnnotationAttribute__OptionalAssignment_0_0() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11406:1: ( ( ( 'optional' ) ) ) |
| // InternalFSM.g:11407:1: ( ( 'optional' ) ) |
| { |
| // InternalFSM.g:11407:1: ( ( 'optional' ) ) |
| // InternalFSM.g:11408:1: ( 'optional' ) |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); |
| // InternalFSM.g:11409:1: ( 'optional' ) |
| // InternalFSM.g:11410:1: 'optional' |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); |
| match(input,70,FOLLOW_2); |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); |
| |
| } |
| |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__OptionalAssignment_0_0" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__NameAssignment_2" |
| // InternalFSM.g:11425:1: rule__EnumAnnotationAttribute__NameAssignment_2 : ( RULE_ID ) ; |
| public final void rule__EnumAnnotationAttribute__NameAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11429:1: ( ( RULE_ID ) ) |
| // InternalFSM.g:11430:1: ( RULE_ID ) |
| { |
| // InternalFSM.g:11430:1: ( RULE_ID ) |
| // InternalFSM.g:11431:1: RULE_ID |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); |
| match(input,RULE_ID,FOLLOW_2); |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__NameAssignment_2" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__ValuesAssignment_5" |
| // InternalFSM.g:11440:1: rule__EnumAnnotationAttribute__ValuesAssignment_5 : ( RULE_STRING ) ; |
| public final void rule__EnumAnnotationAttribute__ValuesAssignment_5() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11444:1: ( ( RULE_STRING ) ) |
| // InternalFSM.g:11445:1: ( RULE_STRING ) |
| { |
| // InternalFSM.g:11445:1: ( RULE_STRING ) |
| // InternalFSM.g:11446:1: RULE_STRING |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_5_0()); |
| match(input,RULE_STRING,FOLLOW_2); |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_5_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__ValuesAssignment_5" |
| |
| |
| // $ANTLR start "rule__EnumAnnotationAttribute__ValuesAssignment_6_1" |
| // InternalFSM.g:11455:1: rule__EnumAnnotationAttribute__ValuesAssignment_6_1 : ( RULE_STRING ) ; |
| public final void rule__EnumAnnotationAttribute__ValuesAssignment_6_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11459:1: ( ( RULE_STRING ) ) |
| // InternalFSM.g:11460:1: ( RULE_STRING ) |
| { |
| // InternalFSM.g:11460:1: ( RULE_STRING ) |
| // InternalFSM.g:11461:1: RULE_STRING |
| { |
| before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_6_1_0()); |
| match(input,RULE_STRING,FOLLOW_2); |
| after(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_6_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__EnumAnnotationAttribute__ValuesAssignment_6_1" |
| |
| |
| // $ANTLR start "rule__Documentation__LinesAssignment_2" |
| // InternalFSM.g:11472:1: rule__Documentation__LinesAssignment_2 : ( RULE_STRING ) ; |
| public final void rule__Documentation__LinesAssignment_2() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11476:1: ( ( RULE_STRING ) ) |
| // InternalFSM.g:11477:1: ( RULE_STRING ) |
| { |
| // InternalFSM.g:11477:1: ( RULE_STRING ) |
| // InternalFSM.g:11478:1: RULE_STRING |
| { |
| before(grammarAccess.getDocumentationAccess().getLinesSTRINGTerminalRuleCall_2_0()); |
| match(input,RULE_STRING,FOLLOW_2); |
| after(grammarAccess.getDocumentationAccess().getLinesSTRINGTerminalRuleCall_2_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__Documentation__LinesAssignment_2" |
| |
| |
| // $ANTLR start "rule__BooleanLiteral__IsTrueAssignment_1_1" |
| // InternalFSM.g:11489:1: rule__BooleanLiteral__IsTrueAssignment_1_1 : ( ( 'true' ) ) ; |
| public final void rule__BooleanLiteral__IsTrueAssignment_1_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11493:1: ( ( ( 'true' ) ) ) |
| // InternalFSM.g:11494:1: ( ( 'true' ) ) |
| { |
| // InternalFSM.g:11494:1: ( ( 'true' ) ) |
| // InternalFSM.g:11495:1: ( 'true' ) |
| { |
| before(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); |
| // InternalFSM.g:11496:1: ( 'true' ) |
| // InternalFSM.g:11497:1: 'true' |
| { |
| before(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); |
| match(input,71,FOLLOW_2); |
| after(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); |
| |
| } |
| |
| after(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__BooleanLiteral__IsTrueAssignment_1_1" |
| |
| |
| // $ANTLR start "rule__RealLiteral__ValueAssignment_1" |
| // InternalFSM.g:11512:1: rule__RealLiteral__ValueAssignment_1 : ( ruleReal ) ; |
| public final void rule__RealLiteral__ValueAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11516:1: ( ( ruleReal ) ) |
| // InternalFSM.g:11517:1: ( ruleReal ) |
| { |
| // InternalFSM.g:11517:1: ( ruleReal ) |
| // InternalFSM.g:11518:1: ruleReal |
| { |
| before(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleReal(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__RealLiteral__ValueAssignment_1" |
| |
| |
| // $ANTLR start "rule__IntLiteral__ValueAssignment_1" |
| // InternalFSM.g:11527:1: rule__IntLiteral__ValueAssignment_1 : ( ruleInteger ) ; |
| public final void rule__IntLiteral__ValueAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11531:1: ( ( ruleInteger ) ) |
| // InternalFSM.g:11532:1: ( ruleInteger ) |
| { |
| // InternalFSM.g:11532:1: ( ruleInteger ) |
| // InternalFSM.g:11533:1: ruleInteger |
| { |
| before(grammarAccess.getIntLiteralAccess().getValueIntegerParserRuleCall_1_0()); |
| pushFollow(FOLLOW_2); |
| ruleInteger(); |
| |
| state._fsp--; |
| |
| after(grammarAccess.getIntLiteralAccess().getValueIntegerParserRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__IntLiteral__ValueAssignment_1" |
| |
| |
| // $ANTLR start "rule__StringLiteral__ValueAssignment_1" |
| // InternalFSM.g:11542:1: rule__StringLiteral__ValueAssignment_1 : ( RULE_STRING ) ; |
| public final void rule__StringLiteral__ValueAssignment_1() throws RecognitionException { |
| |
| int stackSize = keepStackSize(); |
| |
| try { |
| // InternalFSM.g:11546:1: ( ( RULE_STRING ) ) |
| // InternalFSM.g:11547:1: ( RULE_STRING ) |
| { |
| // InternalFSM.g:11547:1: ( RULE_STRING ) |
| // InternalFSM.g:11548:1: RULE_STRING |
| { |
| before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); |
| match(input,RULE_STRING,FOLLOW_2); |
| after(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); |
| |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| |
| restoreStackSize(stackSize); |
| |
| } |
| return ; |
| } |
| // $ANTLR end "rule__StringLiteral__ValueAssignment_1" |
| |
| // Delegated rules |
| |
| |
| protected DFA8 dfa8 = new DFA8(this); |
| protected DFA9 dfa9 = new DFA9(this); |
| static final String dfa_1s = "\32\uffff"; |
| static final String dfa_2s = "\13\uffff\1\22\7\uffff\2\22\1\uffff\1\22\2\uffff\1\22"; |
| static final String dfa_3s = "\1\51\1\4\1\52\1\4\1\54\4\4\2\54\1\34\2\4\1\54\1\7\1\35\1\4\1\uffff\2\34\1\7\1\34\2\uffff\1\34"; |
| static final String dfa_4s = "\1\51\2\52\1\65\1\64\2\4\1\65\1\4\2\54\1\105\2\4\1\54\1\102\1\61\1\4\1\uffff\2\105\1\102\1\105\2\uffff\1\105"; |
| static final String dfa_5s = "\22\uffff\1\2\4\uffff\1\3\1\1\1\uffff"; |
| static final String dfa_6s = "\32\uffff}>"; |
| static final String[] dfa_7s = { |
| "\1\1", |
| "\1\2\45\uffff\1\3", |
| "\1\3", |
| "\1\4\56\uffff\1\5\1\uffff\1\6", |
| "\1\7\7\uffff\1\10", |
| "\1\11", |
| "\1\12", |
| "\1\13\56\uffff\1\14\1\uffff\1\15", |
| "\1\16", |
| "\1\7", |
| "\1\7", |
| "\1\20\1\22\1\uffff\1\22\4\uffff\6\22\10\uffff\1\22\1\uffff\1\21\14\uffff\1\17\3\uffff\1\22", |
| "\1\23", |
| "\1\24", |
| "\1\7", |
| "\1\25\72\uffff\1\26", |
| "\1\22\17\uffff\1\22\1\30\1\uffff\1\30\1\27", |
| "\1\31", |
| "", |
| "\1\20\1\22\1\uffff\1\22\4\uffff\6\22\10\uffff\1\22\16\uffff\1\17\3\uffff\1\22", |
| "\1\20\1\22\1\uffff\1\22\4\uffff\6\22\10\uffff\1\22\16\uffff\1\17\3\uffff\1\22", |
| "\1\25\72\uffff\1\26", |
| "\1\20\1\22\1\uffff\1\22\4\uffff\6\22\10\uffff\1\22\22\uffff\1\22", |
| "", |
| "", |
| "\1\20\1\22\1\uffff\1\22\4\uffff\6\22\10\uffff\1\22\16\uffff\1\17\3\uffff\1\22" |
| }; |
| |
| static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); |
| static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s); |
| static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); |
| static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s); |
| static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); |
| static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s); |
| static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s); |
| |
| class DFA8 extends DFA { |
| |
| public DFA8(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 8; |
| this.eot = dfa_1; |
| this.eof = dfa_2; |
| this.min = dfa_3; |
| this.max = dfa_4; |
| this.accept = dfa_5; |
| this.special = dfa_6; |
| this.transition = dfa_7; |
| } |
| public String getDescription() { |
| return "1770:1: rule__NonInitialTransition__Alternatives : ( ( ruleTransitionChainStartTransition ) | ( ruleContinuationTransition ) | ( ruleCPBranchTransition ) );"; |
| } |
| } |
| static final String dfa_8s = "\31\uffff"; |
| static final String dfa_9s = "\1\51\1\4\1\52\1\4\1\54\4\4\3\54\1\34\2\4\1\7\1\56\1\4\2\34\1\7\1\34\2\uffff\1\34"; |
| static final String dfa_10s = "\1\51\2\52\1\65\1\64\3\4\1\65\3\54\1\101\2\4\1\102\1\60\1\4\2\101\1\102\1\34\2\uffff\1\101"; |
| static final String dfa_11s = "\26\uffff\1\1\1\2\1\uffff"; |
| static final String dfa_12s = "\31\uffff}>"; |
| static final String[] dfa_13s = { |
| "\1\1", |
| "\1\2\45\uffff\1\3", |
| "\1\3", |
| "\1\4\56\uffff\1\5\1\uffff\1\6", |
| "\1\10\7\uffff\1\7", |
| "\1\11", |
| "\1\12", |
| "\1\13", |
| "\1\14\56\uffff\1\15\1\uffff\1\16", |
| "\1\10", |
| "\1\10", |
| "\1\10", |
| "\1\20\27\uffff\1\21\14\uffff\1\17", |
| "\1\22", |
| "\1\23", |
| "\1\24\72\uffff\1\25", |
| "\1\26\1\uffff\1\27", |
| "\1\30", |
| "\1\20\44\uffff\1\17", |
| "\1\20\44\uffff\1\17", |
| "\1\24\72\uffff\1\25", |
| "\1\20", |
| "", |
| "", |
| "\1\20\44\uffff\1\17" |
| }; |
| |
| static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s); |
| static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); |
| static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s); |
| static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); |
| static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); |
| static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s); |
| |
| class DFA9 extends DFA { |
| |
| public DFA9(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 9; |
| this.eot = dfa_8; |
| this.eof = dfa_8; |
| this.min = dfa_9; |
| this.max = dfa_10; |
| this.accept = dfa_11; |
| this.special = dfa_12; |
| this.transition = dfa_13; |
| } |
| public String getDescription() { |
| return "1798:1: rule__TransitionChainStartTransition__Alternatives : ( ( ruleTriggeredTransition ) | ( ruleGuardedTransition ) );"; |
| } |
| } |
| |
| |
| public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); |
| public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x00000000003C0002L,0x0000000000000010L}); |
| public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000004000000L}); |
| public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000048000000L}); |
| public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000010000000L}); |
| public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x000403F0A0000000L,0x0000000000000020L}); |
| public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x000403F080000002L,0x0000000000000020L}); |
| public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000F20000000L}); |
| public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000020000080L}); |
| public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000082L}); |
| public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000002000000000L,0x0000000000000020L}); |
| public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000040000000010L}); |
| public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000080000000000L}); |
| public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000100000000000L}); |
| public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0028000000000010L}); |
| public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000200020000000L}); |
| public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000400000000000L}); |
| public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0040000000000000L}); |
| public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000800020000000L}); |
| public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000800000000002L}); |
| public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0001000000000000L}); |
| public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0002000000000000L}); |
| public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000200000000000L}); |
| public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000020000000L}); |
| public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0010000000000000L}); |
| public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0181000000000000L}); |
| public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0100000000000002L}); |
| public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000040000000000L}); |
| public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x2600000000000000L}); |
| public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x2200000000000000L}); |
| public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x1000000000000000L}); |
| public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0800000000000000L}); |
| public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x1000000000000002L}); |
| public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x4000000000000000L}); |
| public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x000000000000E0E0L,0x0000000000000080L}); |
| public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x8000000000000000L}); |
| public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000003C00000L}); |
| public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000080L}); |
| public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x1000000020000000L}); |
| public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000080L,0x0000000000000004L}); |
| public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000002000L,0x0000000000000080L}); |
| public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x000000000000C060L}); |
| public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x000000000000C040L}); |
| public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); |
| public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000040L}); |
| public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000030000L}); |
| public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000008L}); |
| |
| } |
